An industry fine-tuning-oriented large model light-weight training resource management and control system

Abstract

The application discloses an industry fine-tuning-oriented large model light-weight training resource management and control system, which comprises a data refinement and preprocessing module, a domain thought chain generation module, a hybrid training management and control module, a heterogeneous resource scheduling module, a strategy knowledge graph receiving module, a state sensing, scheduling decision and asynchronous strategy updating closed-loop scheduling link dynamic allocation of computing resources in the process of the hybrid training management and control module executing a training task, and output of scheduling execution data, a strategy evolution and evaluation module, and a three-stage progressive training of "explicit injection, implicit solidification and parameter simplification". The three-stage progressive training is that reasoning basis is constructed by means of thought chain injection, explicit reasoning is internalized into implicit decision by means of simplification of training data, and the quantity of compressed parameters is adapted by means of quantization and low rank, so that the reasoning capability is retained, the thought chain generation delay in the reasoning stage is eliminated, and the training can be completed in a resource-limited environment.

Description

Technical Field

[0001] This application belongs to the field of large model training technology, specifically involving a lightweight training resource management system for large models oriented towards industry fine-tuning. Background Technology

[0002] With the rapid development of large-scale model technology, fine-tuning general-purpose large models for specific industry sectors has become a major technical path for applying artificial intelligence capabilities to vertical industries. Enterprises utilize specialized data from their respective fields to fine-tune general-purpose large models, obtaining customized models with industry-specific capabilities at a lower cost. However, in the process of moving large-scale model fine-tuning technology from the laboratory to industrial applications, the following technical challenges still urgently need to be addressed:

[0003] The quality of original training data in the industry is inconsistent and the redundancy is high. Existing data screening methods lack consideration for the complexity of reasoning logic. A large number of low-value samples consume computing power, and key reasoning chains are easily damaged during the compression process, resulting in low fine-tuning efficiency.

[0004] The industry fine-tuning process lacks a structured domain knowledge injection mechanism, and the model reasoning process is in a "black box" state, making it difficult to meet the requirements of compliance audit and decision traceability.

[0005] Fine-tuning all parameters of a large model requires extremely high GPU memory and a long training cycle. While traditional lightweight solutions (such as LoRA) reduce training overhead, they do not solve the problem of additional latency caused by the generation of thought chains during the inference stage, making it difficult to achieve a balance between performance and efficiency in resource-constrained environments.

[0006] Resource scheduling in a cloud-edge heterogeneous environment faces challenges such as performance fluctuations of edge nodes and extended inference time for large models (averaging no less than 375 seconds). Existing static scheduling strategies cannot adapt to dynamic changes, and strategy updates and real-time decisions block each other, resulting in delayed scheduling response.

[0007] Existing fine-tuning processes are mostly one-time training processes, lacking multi-dimensional evaluation of training results and reverse optimization mechanisms, thus failing to achieve continuous evolution of system parameters.

[0008] In summary, there is an urgent need for a comprehensive management and control system that can coordinate the entire process from data refinement, knowledge injection, lightweight training, resource scheduling to closed-loop optimization. Summary of the Invention

[0009] This application provides a lightweight training resource management system for large models for industry fine-tuning, aiming to solve the problems of high redundancy of training data, insufficient injection of inference knowledge, high consumption of computing resources, low efficiency of heterogeneous resource scheduling, and lack of closed-loop optimization mechanism in existing technologies for industry fine-tuning.

[0010] A lightweight training resource management system for large models designed for industry-specific fine-tuning includes:

[0011] The data refinement and preprocessing module receives the original industry training dataset and transforms it into a refined training sample set through a pipeline-style data processing chain of semantic encoding, knowledge domain clustering, inference contribution quantification, and refined sample output.

[0012] The domain thinking chain generation module receives the refined training sample set and transforms it into a thinking chain template set and a strategy knowledge graph through a progressive knowledge processing chain of knowledge accumulation, template induction and graph transformation.

[0013] The hybrid training control module receives the refined training sample set and the thought chain template set. Through a progressive training pipeline of explicit reasoning training, implicit reasoning compression and efficient parameter fine-tuning, it internalizes the explicit domain reasoning logic into the implicit decision-making ability in the model parameters and outputs a lightweight fine-tuned model.

[0014] The heterogeneous resource scheduling module receives the policy knowledge graph and dynamically allocates computing resources through a closed-loop scheduling link of state awareness, scheduling decision and asynchronous policy update during the execution of training tasks by the hybrid training control module, while outputting scheduling execution data.

[0015] The strategy evolution and evaluation module receives the lightweight fine-tuning model and the scheduling execution data, and generates structured feedback signals through a closed-loop iterative link of performance evaluation and feedback optimization, which drive the data refinement and preprocessing module, the domain thinking chain generation module and the hybrid training control module to perform targeted optimization.

[0016] Optionally, the data refinement and preprocessing module includes:

[0017] The semantic encoding submodule uses a pre-trained semantic encoding model to map each data sample in the original industry training dataset into a dense feature vector of fixed dimensions. The feature vectors of all samples constitute a feature matrix.

[0018] The knowledge domain clustering submodule, based on the feature matrix, uses a clustering algorithm to divide the original industry training dataset into multiple knowledge domain subsets;

[0019] The reasoning contribution quantification submodule calculates the marginal contribution value of each data sample to the improvement of the model's reasoning ability based on the multi-step reasoning logic complexity within each knowledge domain subset, and sorts the samples within each knowledge domain subset according to the marginal contribution value.

[0020] The refined sample output submodule selects representative samples from each knowledge domain subset according to the sorting results within each knowledge domain subset and merges them to generate the refined training sample set.

[0021] The semantic encoding submodule, the knowledge domain clustering submodule, the reasoning contribution quantification submodule, and the refined sample output submodule form a pipeline-style data processing link of "encoding-clustering-quantification-screening".

[0022] Optionally, when calculating the marginal contribution value, the inference contribution quantification submodule considers the following three dimensions: the number of inference steps; the depth of logical dependencies between inference steps; and the weight of each inference step's influence on the final conclusion.

[0023] The influence weights are calculated using an attribution analysis method based on Shapley values, treating each reasoning step as a player in a cooperative game and calculating its marginal contribution to the final correct answer.

[0024] Optionally, the domain mind chain generation module includes:

[0025] The domain knowledge base submodule pre-integrates industry standards, compliance clauses, and dynamic hierarchical logic to construct a three-layer structured knowledge base consisting of a standard specification layer, a logical rule layer, and a knowledge representation layer.

[0026] The thought chain template generation submodule receives the refined training sample set and the three-layer structured knowledge base, and automatically summarizes the domain reasoning pattern through a few-shot learning mechanism to generate the thought chain template set that conforms to industry logic.

[0027] The strategy knowledge graph construction submodule transforms the set of thought chain templates into a knowledge graph structure represented by entities and relations, stores scheduling strategies and inference rules in the form of triples, and outputs the strategy knowledge graph.

[0028] The domain knowledge base submodule, the mind chain template generation submodule, and the strategy knowledge graph construction submodule form a progressive knowledge processing chain of "knowledge accumulation - template summarization - graph transformation".

[0029] Optionally, the hybrid training control module includes:

[0030] The explicit reasoning training submodule receives the thought chain template set and the refined training sample set, and concatenates the two to construct the "question-thought chain reasoning steps-answer" triple training data. Through multi-task learning, it simultaneously optimizes the classification loss and the reasoning chain reconstruction loss, and guides the large model to learn the explicit decision logic based on the thought chain.

[0031] The implicit reasoning compression submodule loads the intermediate model parameters trained by the explicit reasoning training submodule and constructs a simplified training dataset after removing the reasoning process description and thought chain. It then performs secondary fine-tuning using the "question-answer" pair to internalize the explicit reasoning logic into an implicit decision-making pattern.

[0032] The parameter high-efficiency fine-tuning submodule receives the model parameters compressed by the implicit inference compression submodule, uses quantization low-rank adaptation technology to perform high-efficiency fine-tuning of the model parameters, introduces a low-rank adapter in the model attention layer, updates only the parameters of the low-rank adapter, and outputs the lightweight fine-tuned model.

[0033] The explicit inference training submodule, the implicit inference compression submodule, and the parameter efficient fine-tuning submodule work together in a logical sequence of "explicit injection - implicit solidification - parameter simplification" to form a complete training pipeline.

[0034] Optionally, the heterogeneous resource scheduling module includes:

[0035] The resource status awareness submodule monitors the multi-dimensional status information of cloud servers and edge servers in real time and constructs a node status vector. The node status vector includes resource utilization, communication bandwidth and performance degradation factor. The performance degradation factor is dynamically modeled using a probability model based on Weibull distribution and log-normal distribution.

[0036] The scheduling decision submodule receives the global state, the training task workflow to be scheduled, and the policy knowledge graph. It uses a problem decomposition method to recursively decompose the scheduling problem into multiple sub-problems and generates mapping decisions from sub-tasks to computing nodes through collaborative reasoning of a large model.

[0037] The asynchronous policy update submodule extracts samples from historical scheduling data at preset time intervals and calls the large model to update the policy knowledge graph, thus decoupling the policy update process from the real-time scheduling decision process.

[0038] The resource status awareness submodule, the scheduling decision submodule, and the asynchronous policy update submodule form a closed-loop scheduling link of "perception-decision-evolution".

[0039] Optionally, the scheduling decision submodule recursively decomposes and solves the scheduling problem according to the following process:

[0040] The first step is to extract sub-knowledge graphs related to the current sub-problem from the strategy knowledge graph, which will serve as a guide for the thought process;

[0041] The second step is to combine the current sub-problem, the sub-knowledge graph, and the contextual prompt words into decomposition prompt words, input them into the large model, and guide the model to decompose the current sub-problem into several sub-problems, with each sub-problem accompanied by an influence factor.

[0042] The third step is to sort the sub-problems in descending order of the influencing factors and divide them into strongly coupled core problems, moderately correlated problems, and weakly correlated problems, and solve them differently by using recursive decomposition, direct calling of large models, and early elimination methods respectively.

[0043] The fourth step involves recombining the answer pairs for each sub-problem, the sub-knowledge graph, and the current sub-problem into a complete set of prompts, inputting them into the large model for comprehensive reasoning, and obtaining the decision result for the current sub-problem.

[0044] Optionally, the strategy evolution and evaluation module includes:

[0045] The model performance evaluation submodule receives the lightweight fine-tuned model, evaluates the model's inference performance on multiple industry benchmark test sets, calculates four core evaluation indicators: classification accuracy, inference latency, computational energy consumption, and inference chain integrity score, and outputs a performance evaluation report; the inference chain integrity score is a measure of the semantic alignment between the inference steps generated by the model and the standard inference path.

[0046] The strategy feedback optimization submodule receives the performance evaluation report and the scheduling execution data, performs multi-dimensional diagnostic analysis on the performance evaluation report, compares each indicator with preset thresholds, identifies the performance bottleneck type, and generates a structured feedback signal based on the performance bottleneck type. The feedback signal is transmitted to the data refinement and preprocessing module and the domain thinking chain generation module, respectively.

[0047] The model performance evaluation submodule and the strategy feedback optimization submodule form a closed-loop logic of "evaluation-diagnosis-feedback-evolution".

[0048] Optionally, the diagnostic logic of the strategy feedback optimization submodule includes:

[0049] When the classification accuracy is lower than a preset threshold, it is determined that the inference coverage of the current refined training sample set is insufficient, and a first type of feedback signal is generated. The first type of feedback signal includes instructions to adjust the weight coefficients in the inference contribution quantification formula, reduce the diversity sampling intensity, and increase the number of knowledge domain clusters, and is transmitted to the data refinement and preprocessing module.

[0050] When the inference latency or computational energy consumption exceeds a preset threshold, it is determined that the inference steps of the current thinking chain template are too long or the model compression is insufficient. A second type of feedback signal is generated. The second type of feedback signal includes instructions to merge the steps of the thinking chain template, adjust the credibility weight of the inference rules in the strategy knowledge graph, and adjust the low-rank dimension. These instructions are then transmitted to the domain thinking chain generation module.

[0051] When the reasoning chain integrity score is lower than the preset threshold, it is determined that there is a deviation between the reasoning path of the current thinking chain template and the domain compliance logic, and a third type of feedback signal is generated. The third type of feedback signal includes instructions to send a rule supplementation request to the domain knowledge base submodule, adjust the selection strategy of few sample demonstration examples, and increase the matching threshold of the rule engine filtering verification. At the same time, it is transmitted to the domain thinking chain generation module and the data refinement and preprocessing module.

[0052] Compared with the prior art, this application has at least the following beneficial effects:

[0053] This application uses semantic encoding, clustering, inference contribution quantification (combining inference steps, logical dependency depth, and step influence weights) and determinant point process sampling to eliminate low-contribution and highly redundant samples while fully covering key knowledge categories, thereby significantly compressing the amount of training data and saving computing power.

[0054] This application constructs a three-layer structured knowledge base, which automatically summarizes thought chain templates through few-sample learning and transforms them into a strategy knowledge graph, making each reasoning step traceable to specific legal provisions, significantly improving the interpretability and compliance of the fine-tuning model.

[0055] This application adopts a three-stage progressive training approach: "explicit injection - implicit solidification - parameter simplification". First, the reasoning foundation is built through the injection of thought chains. Then, the training data is simplified to internalize explicit reasoning into implicit decision-making. Finally, the number of parameters is compressed using quantized low-rank adaptation. This approach retains reasoning ability while eliminating the time delay in the generation of thought chains during the reasoning stage, enabling training to be completed in a resource-constrained environment.

[0056] This application decouples time-consuming strategy induction from real-time scheduling by introducing dynamic probabilistic modeling of performance degradation factors, recursive decomposition of scheduling problems guided by thought chains, and asynchronous strategy update mechanism. This ensures rapid scheduling response while dealing with performance fluctuations of edge nodes and continuously optimizes scheduling strategies.

[0057] This application establishes an evaluation system covering four dimensions: accuracy, latency, energy consumption, and interpretability. Based on performance bottlenecks, it automatically generates differentiated feedback signals (adjusting data refinement parameters, simplifying thought chain templates, supplementing knowledge base rules, etc.) to drive iterative optimization of the front-end module, approaching the Pareto optimal state through multiple closed-loop iterations. Attached Figure Description

[0058] Figure 1 This is a schematic diagram of the module connections of a lightweight training resource management system for large models with industry-specific fine-tuning, provided as an embodiment of this application. Detailed Implementation

[0059] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments.

[0060] This application provides a lightweight training resource management system for large models designed for industry-specific fine-tuning, such as... Figure 1 As shown, it includes: a data refinement and preprocessing module, a domain thinking chain generation module, a hybrid training control module, a heterogeneous resource scheduling module, and a strategy evolution and evaluation module;

[0061] The data refinement and preprocessing module is responsible for transforming the original industry training data into a high-value, low-redundancy refined sample set, providing a data foundation for subsequent domain-specific thought chain generation and hybrid training. This module consists of four parts: a semantic encoding submodule, a knowledge domain clustering submodule, a reasoning contribution quantification submodule, and a refined sample output submodule. These submodules form a pipeline-style data processing chain of "encoding—clustering—quantification—screening".

[0062] The semantic encoding submodule receives the original industry training dataset. ,in Enter the problem to be processed or input text. This describes the corresponding reasoning process. This is for the final answer or category label. This submodule uses a pre-trained semantic encoding model (e.g., a pre-trained Transformer model under the Sentence-Transformers framework) to encode each data sample. Mapped to dense feature vectors of fixed dimensions ;

[0063] Specifically, the semantic coding model first models the context of the input text using a Transformer encoder, and then aggregates the variable-length token sequence into a single sentence-level vector representation through a pooling layer.

[0064] To improve encoding quality, this submodule supports task-specific fine-tuning of the semantic encoding model based on industry domain characteristics, enabling it to more accurately capture industry terminology and domain semantics. After encoding, the feature vectors of all samples constitute a feature matrix. This serves as the input for the next submodule;

[0065] The knowledge domain clustering submodule is based on the feature matrix output by the semantic encoding submodule. Clustering algorithms are used to divide the original dataset Divided into k knowledge domain subsets The core objective of clustering algorithms is to group semantically similar data samples into the same subset, so that the samples within each subset have high cohesion in the semantic space, while different subsets have good discriminability.

[0066] This submodule can employ the K-means clustering algorithm or its improved version (such as K-means++) to iteratively optimize the cluster center positions by minimizing the sum of squared distances between samples within a cluster and the cluster center. The value of the cluster number k can be adaptively determined based on the characteristics of the industry data using methods such as the elbow rule or silhouette coefficient. After clustering is completed, each knowledge domain subset... Include A sample, satisfying Furthermore, the samples within each subset are semantically focused on a specific knowledge domain (for example, in a medical data grading scenario, different semantic clusters such as "medical records," "image reports," and "test results" can be formed). This submodule can also manually label each cluster after clustering according to actual needs to enhance the semantic interpretability of each knowledge domain subset;

[0067] The reasoning contribution metric submodule in subsets of various knowledge domains Internally, it works independently, calculating the marginal contribution of each data sample to the model's reasoning capability based on the complexity of multi-step inference logic. This applies to data samples involving multi-step inference processes. Let its reasoning steps sequence be as follows: , where n is the number of reasoning steps. Reasoning contribution. The calculation takes into account the following three dimensions:

[0068] (1) Number of reasoning steps n: The more reasoning steps there are, the longer the logical chain contained in the sample, and the higher the training value for the model's reasoning ability.

[0069] (2) Depth of logical dependencies between reasoning steps: d: Definition ,in The logical correctness depends on The conclusion is that d reflects the length of the longest dependency path in the inference chain, and the deeper the dependency, the higher the inference complexity of the sample.

[0070] (3) The influence weight of each reasoning step on the final conclusion : Using a Shapley value-based attribution analysis method, each reasoning step is analyzed. Considering Shapley as a "player" in a cooperative game, calculate its marginal contribution to the final correct answer 'a'. The formula for calculating Shapley's value is:

[0071]

[0072] in For the set of indices of all reasoning steps, Let T be the probability evaluation function for arriving at the correct answer based solely on the reasoning steps in the subset T. The above formula precisely quantifies the marginal contribution of each reasoning step to the final conclusion.

[0073] Combining the above three dimensions, the contribution of reasoning The quantification formula is:

[0074]

[0075] Where α, β, and γ are preset non-negative weighting coefficients used to adjust the relative importance of the three dimensions in the contribution calculation. Logarithmically scaling the number of reasoning steps is applied to avoid long-chain samples excessively dominating the screening results. Samples within each knowledge domain subset are sorted from highest to lowest according to their reasoning contribution.

[0076] This submodule can also employ an active learning sampling method based on model prediction entropy as an alternative quantification scheme for inference contribution, by calculating the uncertainty of the model's prediction of samples (i.e., prediction entropy). The information gain potential of a sample can be evaluated using a sampling method based on singular value decomposition (SVD), which involves performing SVD on the sample feature matrix. diagonal matrix Singularity Square proportion To measure the amount of core feature information carried by the sample;

[0077] The refined sample output submodule sorts the results according to the reasoning contribution within each knowledge domain subset, from each subset. Filter by preset quantity ( Representative samples from ) are merged to generate a refined training sample set. ,satisfy To ensure that the refined dataset maintains sample diversity while avoiding redundancy, this submodule introduces a Determinantal Point Process (DPP) for diversified sampling during the selection process. Specifically, a kernel matrix is ​​constructed based on the feature vectors of samples within each knowledge domain subset. ,in Measure the similarity between sample u and sample v;

[0078] The DPP sampling algorithm maximizes the determinant value of the kernel matrix of the selected subset. This submodule aims to maximize diversity among samples while ensuring that the selected samples contribute significantly to inference. Complete coverage of the original dataset The key knowledge categories were identified, while a large number of low-contribution and highly redundant samples were removed, providing a high-quality, low-redundancy training data foundation for the subsequent domain thinking chain generation module.

[0079] The domain thinking chain generation module is responsible for transforming the refined training sample set output by the data refinement and preprocessing module into a structured reasoning knowledge carrier, providing explicit domain reasoning logic for the hybrid training control module. This module consists of three parts: a domain knowledge base submodule, a thinking chain template generation submodule, and a strategy knowledge graph construction submodule, forming a progressive knowledge processing chain of "knowledge accumulation - template induction - graph transformation".

[0080] The domain knowledge base submodule serves as the knowledge foundation of the entire module. It pre-integrates industry standards, compliance clauses, and dynamic hierarchical logic, constructing a three-layer structured knowledge foundation comprising a standard specification layer, a logical rule layer, and a knowledge representation layer. The standard specification layer integrates authoritative laws, regulations, standards, and normative documents relevant to the industry.

[0081] The logic rules layer builds a dynamic hierarchical logic library on this basis, defining a multi-layered mapping relationship of "data fields - processing rules - compliance clauses - security level";

[0082] The logical rule layer adopts the expression form of production rule, namely IF-THEN rule set. Each rule consists of an antecedent (condition part) and a consequent (conclusion part), supporting chain triggering and compound reasoning between rules.

[0083] The knowledge representation layer employs an ontology-based modeling approach, transforming unstructured and semi-structured knowledge from the standard specification layer and logical rule layer into a machine-understandable triple knowledge graph representation. This layer first defines the core concept system of the industry domain, including entity types (such as "data field," "processing activity," "compliance clause," and "security level"), relation types (such as "belongs to," "trigger," "maps to," and "constraint"), and attribute types (such as "field sensitivity" and "clause validity level"). Then, through entity extraction and relation extraction techniques, it transforms the regulatory text and rule base into triples in the form of (head entity, relation, tail entity), which are stored in a graph database.

[0084] The three-layer structure forms a bottom-up knowledge abstraction chain: the standard specification layer provides the original regulatory text materials, the logic rule layer extracts executable judgment rules from them, and the knowledge representation layer further abstracts the rules into graph-structured knowledge, supporting subsequent semantic retrieval and logical verification. This submodule also has a built-in rule version management mechanism. When industry regulations are updated, the knowledge base can be partially updated through incremental import without rebuilding the entire knowledge base.

[0085] The thought chain template generation submodule receives the refined training sample set output by the data refinement and preprocessing module. The domain knowledge base submodule provides a three-layer structured knowledge foundation, which automatically summarizes domain reasoning patterns through a few-shot learning mechanism, generating thought chain templates that conform to industry logic. The core of this submodule lies in transforming the implicit compliance logic in the domain knowledge base into explicit multi-step reasoning path templates. Specifically:

[0086] This submodule refines the training sample set. Based on the clustering results of knowledge domains, a small number of representative samples are selected as demonstration examples for few-shot learning. Each demonstration example includes input data, a complete sequence of reasoning steps, and the final decision result. The selection of demonstration examples takes into account both the coverage of each knowledge domain and the diversity of reasoning paths.

[0087] This submodule semantically aligns the demonstration examples with rule primitives in the domain knowledge base. For each reasoning step in the demonstration example... By calculating semantic similarity and matching it with triples in the knowledge representation layer, the legal provisions or rule primitives upon which the reasoning step is based are determined, thereby establishing a traceable association between the reasoning step and domain knowledge. The semantic similarity calculation employs the vector cosine similarity method, encoding the reasoning step text and the triple text into dense vectors and then comparing their similarity. A match is determined when the similarity exceeds a preset threshold.

[0088] This submodule, based on the alignment results, automatically summarizes domain reasoning patterns using the contextual learning capabilities of a large language model. Specifically, it combines demonstration examples, aligned domain knowledge triples, and task descriptions into few-sample prompts, inputs them into the large language model, and guides the model to abstract a general reasoning path template from the demonstration examples. The reasoning path template is represented using placeholders and includes a series of reasoning steps from input data parsing to the final decision output. Each step includes a step type (e.g., "semantic recognition," "rule matching," "level determination"), the knowledge base rule identifier it is based on, and the logical dependencies between steps.

[0089] Taking a medical data classification scenario as an example, the generated thought chain template is as follows: Step ① "Identify data type: Determine whether the input text contains the [Personal Health Information] category field" → Step ② "Match classification rules: Determine the data category by referring to Article [X] of the [Health and Wellness Industry Data Classification and Grading Guide]" → Step ③ "Inference conclusion: Output [Security level] based on the category". The content within the square brackets is a replaceable placeholder that is dynamically filled in based on the specific input content during actual reasoning.

[0090] Finally, this submodule performs rule engine filtering and verification on the generated thought chain templates, including two stages: syntax verification and semantic verification. Syntax verification uses regular expression matching to ensure that the template contains a complete chain of reasoning steps (at least two levels of rule mapping) and that the steps have a clear logical progression. Semantic verification uses a domain knowledge base to correlate and retrieve the rule clauses and data features referenced in the template, verifying the consistency between the reasoning logic and the legal provisions, and filtering out invalid templates with logical conflicts or deviations from regulations. The resulting set of verified thought chain templates... As the output of this submodule, each template A standardized reasoning path corresponding to a certain type of reasoning scenario;

[0091] The strategy knowledge graph construction submodule transforms the set of thought chain templates T output by the thought chain template generation submodule into a knowledge graph structure represented by entities and relations. It stores scheduling strategies and inference rules in triples, allowing the heterogeneous resource scheduling module to directly call them during the online inference phase. The core design of this submodule lies in further structuring the thought chain templates described in natural language into graph knowledge, enabling the inference logic not only to be understood by humans but also to be efficiently retrieved and executed by machines.

[0092] Specifically, this submodule first examines each thought chain template. The structured parsing process extracts three core elements: reasoning entities (such as "data fields", "compliance clauses", "security levels", "computation nodes", "subtasks", etc.), reasoning relationships (such as "trigger", "map to", "priority allocation", "dependency", etc.), and reasoning constraints (such as "if and only if", "not less than", "priority to", etc.).

[0093] The extraction process employs a combination of rule-based pattern matching and large-model-based semantic parsing: rule matching is used to identify structured information in the template that conforms to a preset pattern (such as the rule number in "match [rule X]"), while semantic parsing is used to process the unstructured natural language description in the template.

[0094] This submodule organizes the extracted three types of elements into (head entity, relation, tail entity) triples, forming an initial set of triples. Taking a scheduling strategy scenario as an example, from the reasoning rule "subtasks on the critical path should be preferentially assigned to cloud nodes with sufficient computing resources," the triples (critical path subtask, preferentially assigned to, cloud node) and (cloud node, has attributes, sufficient computing resources) can be extracted.

[0095] For classification and grading scenarios, from the inference rule "data fields containing personal health information should match C3 level protection requirements", a triple (personal health information field, trigger, C3 level protection requirements) can be extracted. Each triple is also accompanied by metadata tags, including the thought chain template number from which the triple comes, the domain knowledge base rule identifier on which it is based, and the credibility weight of the inference rule;

[0096] This submodule performs knowledge fusion and conflict resolution on the initial set of triples. Knowledge fusion refers to merging semantically equivalent but differently expressed triples (e.g., normalizing "preferred allocation to" and "preferred scheduling to" to the same relation type); conflict resolution refers to detecting and handling logically contradictory triples (e.g., the same entity being mapped to two different security levels under the same conditions). The conflict resolution strategy is to make a decision based on the priority level of rules in the domain knowledge base (higher rule rank takes precedence) and the timeliness of the rules (new rules take precedence over old rules).

[0097] Finally, this submodule stores the fused and resolved triple set in a graph database, constructing a complete PolicyKG. Entity nodes in the graph contain attribute information (such as node computing resource capacity, communication bandwidth, etc.), and relationship edges contain relationship type and weight information. PolicyKG adopts a storage architecture that separates TBox and ABox: the TBox layer stores general inference rules and concept definitions (such as general policies like "critical path subtasks should be preferentially assigned to nodes with sufficient resources"), while the ABox layer stores specific instance data (such as the real-time resource status of each node in the current cluster).

[0098] The two layers are linked through instantiation relationships, enabling the scheduling decision submodule to perform reasoning queries on specific instances in the ABox layer based on the general rules of the TBox layer during online inference. PolicyKG also supports an incremental update mechanism. When the thought chain template generation submodule produces a new template or the domain knowledge base submodule is updated, the submodule only needs to perform local addition, deletion, and modification operations on the affected triples, without having to rebuild the entire graph, thus ensuring the efficient evolution of policy knowledge.

[0099] The PolicyKG output by this submodule is transmitted to the hybrid training control module as a knowledge injection source for the explicit reasoning training phase, and to the heterogeneous resource scheduling module as the reasoning basis for online scheduling decisions.

[0100] The hybrid training control module receives the thought chain template and refined training sample set output by the domain thought chain generation module. Through a two-stage progressive training process, it internalizes explicit domain reasoning logic into implicit decision-making capabilities in the model parameters, ultimately outputting a lightweight, fine-tuned model that can be used by downstream tasks. This module consists of three parts: an explicit reasoning training submodule, an implicit reasoning compression submodule, and a parameter efficient fine-tuning submodule. These three submodules work collaboratively in a logical order of "explicit injection—implicit solidification—parameter simplification" to form a complete training pipeline.

[0101] The explicit reasoning training submodule receives the set of thought chain templates output by the domain thought chain generation module. and the refined training sample set output by the data refinement and preprocessing module. The two are then combined in a structured format to construct training data consisting of "problem-thought chain reasoning steps-answer" triplets, which guides the large model to learn explicit decision-making logic based on thought chains.

[0102] Specifically, for refining the training sample set... Each sample ,in For inputting questions or data to be processed, This describes the original reasoning process. For the final answer or category label, this submodule first selects from the set of thought chain templates based on the knowledge domain affiliation of the sample. Match the corresponding domain mind chain template The matching is based on the semantic consistency between the cluster identifier of the knowledge domain subset where the sample is located and the inference scenario label covered by the template;

[0103] After matching is complete, the template will be... Replace the placeholders in the sample The specific content in the code generates an instantiated reasoning chain. The instantiated inference chain contains a complete sequence of inference steps from input data parsing and domain rule matching to the final decision output. Each step is accompanied by a domain knowledge base rule identifier on which it is based, making the inference process fully traceable.

[0104] Based on this, this submodule constructs a standardized training format:

[0105]

[0106] The "problem" field contains the original input data, the "CoT" field contains the instantiated thought chain reasoning steps, and the "label" field contains the final answer label. During training, the model simultaneously optimizes two loss functions through multi-task learning: classification loss. Inference chain reconstruction loss is used to penalize prediction errors in the final answer. This is used to penalize the generation bias of the inference step sequence. The total loss function is defined as:

[0107]

[0108] in and These are preset weight coefficients used to adjust the relative importance between the two optimization objectives. Through the aforementioned multi-task learning mechanism, the model is simultaneously constrained by both the correctness of the final answer and the rationality of the reasoning process during parameter updates, thus forming a composite representation in the parameter space that includes both domain knowledge and reasoning logic. Training of this submodule continues until... The model parameters are passed to the implicit inference compression submodule as intermediate products until convergence on the validation set.

[0109] The implicit reasoning compression submodule is launched after the explicit reasoning training submodule has completed training. Its core design concept is that after the model has gone through the explicit reasoning training stage, the domain reasoning logic has been encoded into the model parameters to a certain extent. At this time, by removing the thought chain part in the input and only keeping the "question-answer" pair for secondary fine-tuning, the model is forced to internalize the explicit reasoning process that originally relied on external prompts into the implicit decision mode in the parameter space, thereby realizing the "black box" compression of the reasoning process and significantly reducing the computational overhead of the reasoning stage while maintaining classification accuracy.

[0110] Specifically, this submodule first loads model parameters from the intermediate model output by the explicit inference training submodule as the initial state for the implicit compression stage. Then, it constructs a streamlined training dataset. That is, from refining the training sample set Remove the description of the reasoning process from the middle. and mind chain Only retain input issues and final answer tag During training, the model only uses... Direct prediction for input The optimization objective is only the classification loss. It no longer includes inference chain reconstruction loss;

[0111] The technical principle of this submodule draws on the idea of ​​knowledge distillation, which regards the reasoning knowledge learned in the explicit reasoning training stage as "teacher knowledge". Through secondary fine-tuning under the simplified data format, this knowledge is "distilled" from the explicit output layer of the model to the implicit parameter representation of the model.

[0112] In this process, the model needs to complete the reasoning chain from input to output on its own, no longer relying on externally provided explicit reasoning steps. This internalization process allows the model to directly output the correct answer without generating lengthy reasoning chain text word by word during actual reasoning, resulting in a significant improvement in reasoning speed compared to pure thought chain models. This submodule typically has fewer training rounds than the explicit reasoning training phase, employing an early stopping strategy to prevent overfitting. The model parameters output after training are passed as intermediate products to the parameter fine-tuning submodule.

[0113] The parameter-efficient fine-tuning submodule receives model parameters from the implicit inference compression submodule and employs Quantized Low-Rank Adaptation (QLoRA) technology to efficiently fine-tune the model parameters. A low-rank adapter is introduced into the model's attention layer, decomposing the original weight matrix into the product of two low-rank matrices. Only the low-rank adapter parameters are updated, thus significantly reducing memory usage and training time while maintaining model performance. The core design of this submodule lies in transforming the large model fine-tuning process, which originally required updating all parameters, into a lightweight process that only requires updating a very small number of adapter parameters. This allows the entire training pipeline to be completed in a resource-constrained hardware environment.

[0114] The specific implementation is as follows: This submodule first performs 4-bit quantization compression on the large base model, reducing the model weights from the original FP16 or BF16 precision to 4-bit integer precision, significantly reducing the space occupied by the model in GPU memory. The quantization process adopts a block quantization strategy, dividing the weight matrix into several small blocks, and calculating the quantization parameters (scaling factor and zero offset) independently for each block to minimize the loss of quantization precision;

[0115] Based on the quantized model, this submodule introduces a low-rank adapter (LoRA Adapter) in each attention mechanism layer of the Transformer architecture. For the original weight matrix... The low-rank adapter decomposes it into two low-rank matrices. and The product of satisfies:

[0116]

[0117] Where r is the low-rank dimension, typically taking values ​​of 4, 8, or 16, much smaller than the original dimension d(r). d). During training, the original weight matrix The model remains frozen (i.e., does not participate in gradient updates), and gradient calculations and updates are performed only on the parameters of the low-rank matrices A and B. Since the total number of parameters in A and B is only 2×d×r, which is much smaller than the d×d number of parameters in the original weight matrix, the number of trainable parameters is compressed to the order of 0.1% to 1% of the original model's number of parameters.

[0118] This submodule employs a two-stage parameter update strategy combining collaborative learning and frozen optimization. During the collaborative learning phase (typically the first few epochs of training), both the low-rank adapter parameters and some core model parameters (such as layer normalization parameters) are updated simultaneously, enabling the model to quickly adapt to the domain task characteristics. This phase uses the AdamW optimizer with a learning rate of 10. -4 During the freeze optimization phase, all principal parameters of the model are fixed, and only the low-rank adapter is fine-tuned to avoid overfitting and catastrophic forgetting. This is achieved by reducing the learning rate to 10. -5 Further optimize domain adaptability. The switch between the two stages is automatically determined based on the changing trend of the validation set loss curve: when the validation set loss no longer decreases over several consecutive epochs, the system automatically switches from the collaborative learning stage to the frozen optimization stage;

[0119] This submodule also supports adapter merging and exporting. After training, the product ΔW of the low-rank matrices A and B can be combined with the original weight matrix. Merged into a single weight matrix This ensures that the model structure during inference is completely consistent with the original model, eliminating the need to load an additional adapter module and thus removing the extra computational overhead during the inference phase. The merged lightweight model is then transferred to the policy evolution and evaluation module for multi-dimensional performance evaluation, and can also be deployed as the final output to target industry application scenarios.

[0120] The three sub-modules form a progressive training pipeline: the explicit reasoning training sub-module injects domain logic through thought chains, building the foundation for the model's reasoning ability; the implicit reasoning compression sub-module internalizes explicit reasoning logic into implicit decision-making patterns, compressing inference latency while maintaining accuracy; and the parameter efficient fine-tuning sub-module further compresses training resource overhead through low-rank adaptation and quantization techniques. The synergistic effect of these three modules enables the entire hybrid training management module to achieve systematic balance and optimization across the three dimensions of "reasoning ability construction—reasoning process optimization—training resource simplification."

[0121] The heterogeneous resource scheduling module receives the strategy knowledge graph output by the domain thinking chain generation module, dynamically allocates computing resources during the training task execution process of the hybrid training control module, and feeds back the scheduling execution results to the strategy evolution and evaluation module to form a closed-loop optimization.

[0122] This module consists of three parts: a resource status awareness submodule, a scheduling decision submodule, and an asynchronous policy update submodule. The three submodules work together in accordance with the collaborative logic of "perception-decision-evolution" to form a closed-loop scheduling link of "status acquisition driving decision, decision execution feeding back to update, and update results optimizing decision".

[0123] The resource status awareness submodule monitors the multi-dimensional status information of cloud servers and edge servers in real time, constructs node status vectors, and provides accurate real-time data support for scheduling decisions. The core design of this submodule lies in not only collecting conventional resource utilization indicators, but also introducing a dynamic modeling mechanism for performance degradation factors to accurately characterize the real computing capabilities of edge servers under load fluctuations and performance degradation conditions.

[0124] The specific implementation method is as follows: This submodule is implemented on each computing node in the cluster (including cloud servers and edge servers). A lightweight monitoring agent is deployed on the node to collect multi-dimensional state data of the node at a preset sampling period Δt (e.g., every 5 seconds). The collected raw state data includes: the usage of the r-th type of computing resource (1≤r≤m, including CPU, memory, disk I / O, network bandwidth, etc.). and total amount Based on this, the resource utilization rate is calculated. ; Communication bandwidth of node s (Unit: Mbit / s); and node performance degradation factor. ;

[0125] Performance degradation factor The modeling is the key innovation that distinguishes this submodule from conventional resource monitoring mechanisms. Considering that edge servers generally experience fluctuations in computing performance during actual operation, especially in multi-task concurrent scenarios where resource contention can easily lead to performance degradation, this submodule adopts a two-layer dynamic modeling architecture of "offline distribution fitting + online Bayesian posterior estimation". It combines the prior distribution model with real-time measured data to achieve an accurate characterization of the node performance degradation state.

[0126] Offline Phase – Distribution Parameter Fitting: This submodule first performs distribution parameter fitting based on historical observation data. Historical observation data comes from node operation logs, including but not limited to: CPU throttling event records, memory ECC error rate time-series data, task execution time jitter coefficients, node restart and recovery logs, etc. Based on the above historical data, this submodule uses the Maximum Likelihood Estimation (MLE) method to fit the parameters of the following two probability distributions:

[0127] The interval between performance degradation events is modeled using a Weibull distribution, with the following probability density function:

[0128]

[0129] Where λ is the scale parameter. Here, is the shape parameter, and t is the continuous running time of the node since the last recovery. Shape parameter This reflects the failure mode of the degradation event: <1 indicates an early failure period. =1 indicates a random expiration period. >1 indicates the wear failure period. MLE fitting allows estimation of the appropriate failure period for the current node type from historical data. And the value of λ;

[0130] The temporal probability distribution of system recovery events is described by a log-normal distribution, and its probability density function is:

[0131]

[0132] Where μ and σ are the logarithmic mean and logarithmic standard deviation, respectively, and are also obtained by fitting from historical recovery time data using the MLE method;

[0133] Online Phase – Real-time Monitoring and Bayesian Posterior Update: During actual system operation, the resource status awareness submodule collects measured performance indicators of each edge node in real time at a preset sampling period Δt. These indicators include, but are not limited to: CPU utilization and frequency reduction status, memory error rate, disk I / O wait time percentage, network packet loss rate, and the ratio of actual task execution time to expected execution time (i.e., execution time jitter coefficient). The above measured indicators constitute the observation vector. ;

[0134] This submodule uses the Weibull and log-normal distribution parameters obtained from the offline stage as prior distributions, and at each sampling time t, based on the current observation vector... Infer the posterior degeneracy probability of updating node s using Bayesian inference:

[0135]

[0136] in The state transition probability is derived from the offline fitted Weibull distribution. The observation likelihood function is modeled based on the statistical correlation between measured indices and degradation status.

[0137] Through the aforementioned Bayesian posterior update, this submodule estimates the degradation factor of each edge node in real time. , This indicates that the server is in a stable operating state. This indicates that performance has reached the maximum degradation threshold. Unlike edge nodes, cloud servers have stability advantages in terms of architecture design and resource provisioning, therefore their performance degradation factor is constant. ;

[0138] The role of Monte Carlo simulation: The Monte Carlo stochastic simulation method is not directly used to generate online [databases] in this system. Instead of being used for the following two auxiliary scenarios: (a) In the offline strategy evaluation stage, a variety of performance degradation scenarios are generated through a large number of Monte Carlo samplings to test and verify the robustness of the scheduling strategy under different degradation modes; (b) In the early stage of the new edge node going online (when historical observation data is insufficient and MLE fitting accuracy is low), Monte Carlo sampling is performed based on the typical distribution parameters of similar nodes to generate a prior distribution as a transitional scheme for the cold start stage. After the node accumulates enough running data, it is then switched to the offline fitting process based on MLE.

[0139] Based on the above data collection and modeling results, this submodule constructs a state vector for each node s. And aggregate the state vectors of all nodes into a global state. This submodule employs a dual-mode reporting mechanism: a combination of periodic reporting and event-triggered reporting.

[0140] Periodic reporting pushes status data to the scheduling decision submodule at fixed time intervals Δt; event-triggered reporting occurs when a significant change in node status is detected (such as resource utilization fluctuations exceeding a preset threshold δ or performance degradation factors). When a sudden change occurs, it is immediately reported to ensure that the scheduling decision submodule can promptly detect sudden changes in the cluster state. The global state (State) output by this submodule is transmitted to the scheduling decision submodule in real time as the input basis for scheduling inference.

[0141] The scheduling decision submodule receives the global state State, the training task workflow G to be scheduled (represented by a directed acyclic graph DAG, containing several subtasks with dependencies) transmitted in real time by the resource state awareness submodule, and the policy knowledge graph PolicyKG output by the domain thinking chain generation module. It uses a problem decomposition method to recursively decompose the scheduling problem into multiple sub-problems, and generates the mapping decision X from subtasks to computing nodes through collaborative reasoning of a large model.

[0142] It should be noted that the scheduling decision latency of this submodule is effectively guaranteed through the following three mechanisms, which can meet the real-time requirements of training task scheduling:

[0143] First, the decision-making model and the strategy induction model are architecturally separated. The scheduling decision submodule calls a lightweight inference model (with ≤7B parameters) that is structured and constrained by the strategy knowledge graph. This model only needs to perform path retrieval and constraint satisfaction inference on a limited knowledge graph subgraph during inference, without needing to perform a complete scan of the global knowledge. The problem decomposition depth of each decision is controlled within a preset maximum depth threshold (≤3 layers), and the number of large model calls in a single scheduling decision does not exceed 2N+1 times (where N is the number of sub-problem decomposition layers). The average end-to-end latency of a single decision is controlled within 30 seconds.

[0144] In contrast, the asynchronous policy update submodule calls a general large model (parameter count ≥ 70B), and its complete inference latency is on the order of 375 seconds. This order of 375 seconds is the main processing object that this system decouples from real-time scheduling through the asynchronous update mechanism. The two links use models of different scales, and their latency characteristics are not comparable.

[0145] Second, scheduling decisions are triggered at the batch processing granularity. Subtask scheduling in the training task workflow is not triggered at the granularity of a single operator or a single data point, but rather executed in batches. Scheduling decisions are triggered every 5 to 10 minutes, rather than once per second. This time window is sufficient to accommodate the cumulative latency overhead of multiple rounds of large model inference (as mentioned earlier, a single decision is controlled within 30 seconds). During the interval between two scheduling triggers, the issued scheduling decisions are stably executed by the cluster execution layer according to the established mapping scheme, without requiring repeated intervention from the large model.

[0146] Third, a hybrid decision-making architecture that integrates the rule engine and the large model. The scheduling decision submodule does not trigger deep inference from the large model for all scheduling requests. This submodule has a built-in rule engine based on a policy knowledge graph. For regular scheduling scenarios (accounting for approximately 70% of actual scheduling requests), the rule engine directly matches general scheduling rules at the TBox layer of PolicyKG and retrieves the real-time status of nodes at the ABox layer, completing the decision-making process in milliseconds through structured queries. Only when the rule engine fails to match or detects resource conflicts, significant node performance degradation, or dynamic changes in the workflow topology (accounting for approximately 30%), does the submodule trigger the recursive problem decomposition and deep inference path of the large model. This hybrid architecture of "rule first, large model as a backup" ensures ultra-low latency response in regular scenarios while retaining high-quality decision-making capabilities in complex scenarios.

[0147] With the coordinated protection of the above three mechanisms, the scheduling decision submodule can not only achieve rapid response through lightweight inference models and rule engines, but also handle complex scheduling scenarios with the deep inference capabilities of large models. Its average decision latency is much lower than the execution cycle of training task subtasks and will not become a bottleneck in system performance.

[0148] The core design of this submodule is to transform the complex cloud-edge collaborative scheduling problem (which has been proven to be an NP-hard problem) into a sequence of sub-problems that can be efficiently processed by a large model through a problem decomposition mechanism guided by the thinking chain, thereby obtaining a high-quality scheduling solution within a reasonable time.

[0149] The specific implementation method is as follows: This submodule first selects the subtask set in the workflow G to be scheduled. Hierarchical structure is established based on topological dependencies, identifying subtasks on critical paths and subtasks on non-critical paths. For each subtask... Calculate its impact factor ,in This represents the expected execution time of the subtask. This represents the relaxation time of the subtask (i.e., the difference between the latest start time and the earliest start time). A larger impact factor indicates a more significant impact of the subtask on the overall workflow completion time. Subtasks on the critical path ( It has the highest scheduling priority;

[0150] Based on this, this submodule will address the scheduling issue. (The initial problem is "Please generate the optimal scheduling decision for the current workflow") The following process will be used for recursive decomposition and solution:

[0151] The first step is to extract the sub-problem thought chain: This sub-module extracts the sub-problem from PolicyKG. The related sub-knowledge graph is CurKG. Specifically, it first filters entities from the head entity set of PolicyKG using semantic matching. Semantically related entities form an entity set EntityS; then, all triples in PolicyKG are traversed, and triples whose head entities are contained in EntityS are extracted to form CurKG. CurKG serves as a thought chain guide for the current subproblem, providing structured policy constraints for reasoning in the large model;

[0152] The second step is problem decomposition: This submodule will break down the current subproblem. CurKG and contextual cues (including background information from historical scheduling samples) are combined to form decomposition cues, which are then input into the large model to guide the model to... Decompose into several subproblems Each subproblem q is accompanied by an impact factor, which indicates the importance of the subproblem to the solution quality of the current problem.

[0153] The third step is differential solution: This submodule sorts SubQues in descending order of impact and divides them into three categories: For the strongly coupled core problem (highly related to the scheduling objective), a recursive decomposition method is adopted to further solve it at a finer granular level. For problems with moderate correlation, directly call the large model to generate a solution; For problems with weak correlation, an early elimination strategy is used to skip them directly. The depth of problem decomposition is controlled by a preset maximum depth. When the recursion depth reaches this threshold, further decomposition stops, and the problem is solved directly.

[0154] Step 4, Restructuring and Reasoning: This submodule combines the question-and-answer pairs for solving each sub-problem with CurKG and... Recombined into complete prompts, input into the large model for comprehensive reasoning, and the decision result for the current sub-problem is obtained;

[0155] For the initial problem Its final output is a complete set of scheduling decision variables. ,in This indicates whether subtask j of workflow i is mapped to server k for execution. Scheduling decisions must satisfy resource capacity constraints. (in (Reserving resources for the system) and uniqueness constraints for subtasks ;

[0156] The scheduling decision X output by this submodule is, on the one hand, sent to the cluster execution layer to complete the actual deployment of the subtask, and on the other hand, the decision result along with the actual completion time after execution is sent to the cluster execution layer. Along with resource consumption data, it is transmitted to the strategy evolution and evaluation module as the basis for strategy optimization. Simultaneously, scheduling decision X and workflow execution results are recorded in the historical dataset H for sampling by the asynchronous strategy update submodule.

[0157] The asynchronous policy update submodule decouples the policy update process from the real-time scheduling decision-making process. It extracts samples from historical scheduling data at preset time intervals T and calls the large model to update the policy knowledge graph (PolicyKG), ensuring that policy evolution does not block the real-time response of online scheduling. The core design of this submodule is based on the recognition that the inference latency of the large model (averaging no less than 375 seconds) constitutes a significant bottleneck constraint for the real-time scheduling system. Therefore, it is necessary to separate the time-consuming policy induction from the lightweight scheduling execution in time.

[0158] The specific implementation is as follows: This submodule maintains a background process independent of the main scheduling decision thread, triggering a policy update cycle at a preset time interval T (e.g., every 30 minutes). During each update cycle, this submodule performs the following operations:

[0159] Step 1, Historical Data Sampling: From historical datasets Extract the scheduling records added since the last update, including the global state (State), workflow (G), decision variable (X), and actual execution result for each scheduling decision. ;

[0160] To control sample size and ensure sample diversity, this submodule employs a Determinantal Point Process (DPP) sampling algorithm for sample selection. Specifically, it uses the sample's feature vector (including the workflow's weighted resource requirements) to filter samples. The similarity matrix between samples is calculated using the reward function value. The DPP algorithm selects k representative samples from historical data by maximizing the determinant of the kernel matrix of the selected subset. The sampling process takes into account both positive samples (samples with good performance under the edge-first scheduling strategy) and negative samples (samples with poor performance under the cloud-first scheduling strategy). The two types of samples are initially screened with probability γ before DPP sampling is performed.

[0161] Step 2, Strategy Induction: This submodule combines the sampled sample set S, the meaning descriptions of the sample data fields, and load balancing prompts into scenario prompts. Following the problem decomposition and solution process (the same problem decomposition mechanism as the scheduling decision submodule), it inputs these prompts into the large model, guiding the model to summarize the optimized scheduling strategy from historical scheduling data. The output of strategy induction is a natural language description of the policy text.

[0162] Step 3, Knowledge Graph Update: This submodule incrementally updates the policy text into a structured knowledge graph. Specifically, it first extracts the newly added or modified reasoning rule triples (head entity, relation, tail entity) from the policy, and then compares them with the existing PolicyKG: newly added triples are directly inserted into the graph database;

[0163] For modified triples (i.e., changes occur in the same head entity and the tail entity under the same relation), a versioned storage method is used to retain historical versions and mark the new version as effective;

[0164] For triples that conflict with existing rules, a decision is made based on the credibility weight and timeliness of the rule source. The updated PolicyKG takes effect immediately and can be called by subsequent scheduling decision submodules;

[0165] The asynchronous update mechanism of this submodule brings two significant advantages: First, the policy update process does not block online scheduling decisions. The scheduling decision submodule always performs inference based on the currently effective PolicyKG, and the response latency is not affected by the inference time of the large model.

[0166] Secondly, the strategy update utilizes historical execution data to continuously optimize the scheduling strategy, enabling the system to adaptively respond to changes in node status and load characteristics in the cloud-edge collaborative environment;

[0167] The updated PolicyKG output by this submodule is persistently stored in the graph database for use in subsequent scheduling cycles. On the other hand, the update summary (including newly added and modified policy rules) is synchronized to the policy evolution and evaluation module so that the module can refer to the policy evolution trajectory when evaluating model performance.

[0168] The three sub-modules form a closed-loop collaboration: the resource status awareness sub-module continuously collects cluster status data to drive scheduling decisions; the scheduling decision sub-module generates scheduling schemes based on the policy knowledge graph and real-time status and records the execution results; and the asynchronous policy update sub-module periodically learns from historical data and optimizes the policy knowledge graph. This synergistic effect enables the entire heterogeneous resource scheduling module to achieve systematic balance and optimization across the three dimensions of "real-time response—decision quality—policy evolution."

[0169] The strategy evolution and evaluation module receives the lightweight fine-tuning model output by the hybrid training and control module and the scheduling execution data recorded by the heterogeneous resource scheduling module. Through multi-dimensional performance evaluation and structured feedback signal generation, it drives the continuous optimization of the data refinement and preprocessing module and the domain thinking chain generation module.

[0170] This module consists of two parts: a model performance evaluation submodule and a strategy feedback optimization submodule. The two submodules work together in accordance with the closed-loop logic of "evaluation-diagnosis-feedback-evolution" to form a complete feedback link from model performance quantification to system parameter optimization.

[0171] The model performance evaluation submodule receives the fine-tuned model parameters output by the hybrid training and management module, and performs a comprehensive inference performance evaluation on multiple industry benchmark test sets. It calculates four core evaluation metrics: classification accuracy, inference latency, computational energy consumption, and inference chain integrity score, providing a quantitative performance benchmark for policy feedback optimization. The core design of this submodule lies in constructing a three-dimensional evaluation system covering four dimensions: accuracy, efficiency, energy consumption, and interpretability. The inference chain integrity score is a quantitative indicator of interpretability, avoiding the one-sided performance representation problem caused by evaluating a single metric.

[0172] The specific implementation method is as follows: This submodule first constructs a multi-level test dataset oriented towards industry application scenarios. Each of them For each specific industry benchmark test set (e.g., in the medical data classification scenario, it may include electronic medical record classification test set, medical image report classification test set, patient privacy data identification test set, etc.), the test sets are differentiated in terms of data distribution, knowledge domain and difficulty level to ensure that the evaluation results are sufficiently representative.

[0173] The classification accuracy is evaluated using a standardized accuracy metric, defined as the proportion of correctly predicted samples out of the total number of test samples:

[0174]

[0175] Where x represents the input data for the test sample, and y represents the true label. For the model's predicted output, This is the indicator function. For classification and grading tasks with class imbalance, this submodule also calculates both macro-averaged accuracy and weighted-averaged accuracy to eliminate the interference of sample distribution bias on the evaluation results;

[0176] To evaluate the interpretability quality of the model's reasoning, this submodule also introduces the CoT-Integrity score (which is the quantitative indicator of the aforementioned interpretability dimension). This score quantifies the logical completeness and compliance of the reasoning process by calculating the semantic alignment between the model-generated reasoning steps and the standard reasoning paths in the domain knowledge base. The score employs a similarity metric based on graph edit distance, transforming the model-generated reasoning step sequence and the standard reasoning path into directed graph structures respectively, and calculating the minimum edit cost between them as the inverse indicator of the completeness score.

[0177] It should be noted that the inference chain integrity score is used to evaluate the intermediate model after the explicit inference training submodule has completed training but before implicit inference compression. This score serves as a benchmark for inference capability before implicit compression, ensuring that the model's inference logic has sufficient accuracy and compliance before explicit inference is internalized into implicit decisions. After implicit compression, the actual deployed model no longer generates explicit inference step sequences during the inference phase to eliminate the latency in generating the thought chain; its interpretability is guaranteed through joint monitoring of the pre-compression score and the post-compression accuracy. In evaluation scenarios where the inference chain integrity of the final model needs to be verified, this submodule can force the model to output the inference step sequence for integrity calculation in evaluation mode by adding an evaluation prompt of "Please reason step by step and output your thought process". This evaluation prompt is only used for offline performance evaluation and does not affect the normal inference mode and response latency of the model in the actual deployment environment.

[0178] The scoring method uses a similarity measure based on graph edit distance, which transforms the inference step sequence generated by the model and the standard inference path into directed graph structures respectively, and calculates the minimum edit cost between the two as the inverse indicator of the integrity score.

[0179] Inference latency is evaluated in a standardized hardware environment, measuring the end-to-end time required for the model to go from receiving input to outputting a complete inference result (including inference chain generation and final answer output). This submodule sets up three test modes: single-sample inference mode (measuring the average inference latency of a single sample), batch inference mode (measuring the average inference latency per sample when the batch size is b, where b can be 4, 8, 16, or 32), and streaming inference mode (measuring the latency of the first token and the average generation latency per token).

[0180] The inference latency for each mode is calculated as the average of multiple repeated measurements to eliminate the interference of system noise on the measurement results. The evaluation result of inference latency is directly related to the compression effect of the implicit inference compression submodule in the hybrid training control module—the more sufficient the compression, the lower the inference latency, but it may be accompanied by a slight decrease in accuracy. This submodule visually presents the trade-off between the two by plotting an accuracy-latency Pareto curve.

[0181] The evaluation of computational energy consumption is based on actual power consumption measurements during model inference. This submodule records the instantaneous power consumption of each computing node during model inference on the full test set using power monitoring tools deployed on the computing nodes. Total energy consumption is calculated cumulatively:

[0182]

[0183] Where S represents the set of computational nodes participating in the inference process, and T represents the total duration of the inference process. To eliminate energy consumption differences caused by different hardware platforms, this submodule also normalizes absolute energy consumption into a relative energy consumption index. ,in This represents the baseline energy consumption when running the baseline model on a reference hardware platform (such as a standard-configuration cloud server). The model performance evaluation report is composed of three evaluation metrics. This report serves two purposes: firstly, it determines whether the model meets the deployment requirements; secondly, it acts as a data source for feedback signals, which are then transmitted to the strategy feedback optimization submodule.

[0184] The strategy feedback optimization submodule receives the performance evaluation report R output by the model performance evaluation submodule and the scheduling execution data recorded by the heterogeneous resource scheduling module (including the decision variables X for each round of scheduling and the actual execution delay). (e.g., calculating energy consumption E), and generating structured feedback signals based on the evaluation results to achieve two-way closed-loop optimization. The core design of this submodule lies in transforming abstract evaluation indicators into specific, executable adjustment instructions, which drive the targeted optimization of the data refinement and preprocessing module and the domain thinking chain generation module, respectively.

[0185] The specific implementation method is as follows: This submodule first performs multi-dimensional diagnostic analysis on the performance evaluation report R, comparing each indicator with preset thresholds to identify the specific manifestation type of the performance bottleneck. The diagnostic logic is divided into the following three categories:

[0186] The first scenario is where accuracy is not up to standard: when accuracy is lower than the preset industry application threshold. (For example, in a medical data grading scenario where the threshold is set to 95%), this submodule determines that the inference coverage of the current refined training sample set is insufficient. The feedback signal generated at this time... The specific adjustment instructions include: (1) Adjusting the weight coefficients α, β, and γ in the inference contribution metric formula, increasing the weight of the logical dependency depth d between inference steps, so as to prioritize the retention of complex samples with longer logical chains; (2) Reducing the strength of the diversity penalty term in DPP sampling, allowing more similar high-contribution samples to be retained in the same knowledge domain subset; (3) Increasing the value of the knowledge domain cluster number k, dividing the data into finer granularities, and ensuring that rare knowledge domain samples are not overwhelmed by the "large cluster swallowing" effect in the clustering process. This feedback signal The data is transmitted to the data refinement and preprocessing module, which triggers the module to re-execute the sample refinement process with the adjusted parameters.

[0187] The second scenario involves excessive inference latency or computational power consumption: when latency exceeds the real-time requirement threshold. or Exceeding the energy consumption budget threshold At this point, the submodule determines that the reasoning steps of the current thought chain template are too lengthy or the model compression is insufficient. The feedback signal generated at this time... The following specific adjustment instructions are included: (1) Perform a "step merging" operation on the thought chain template in the domain thought chain generation module to merge multiple consecutive reasoning steps into a composite step and reduce the total length of the reasoning chain; (2) Adjust the credibility weight of the reasoning rules in the PolicyKG to reduce the impact of low-value reasoning paths on scheduling decisions; (3) Send the adjustment suggestion of low-rank dimension r to the parameter efficient fine-tuning submodule of the hybrid training control module (e.g., from r=8 to r=4) to further compress the number of trainable parameters to reduce the computational overhead of the reasoning stage.

[0188] This feedback signal The instructions for merging thought chain template steps and adjusting the knowledge graph credibility weights are respectively transmitted to the domain thought chain generation module and the hybrid training control module. The domain thought chain generation module executes the instructions for adjusting low-rank dimensions, while the parameter fine-tuning submodule of the hybrid training control module executes the instructions for adjusting low-rank dimensions. This enables each module to respond to feedback signals according to its respective responsibilities.

[0189] The third scenario involves insufficient inference chain integrity: when CoT-Integrity is below the interpretability requirement threshold. At this point, the submodule determines that there is a deviation between the reasoning path of the current thought chain template and the domain compliance logic. A feedback signal is then generated. The specific adjustment instructions include: (1) sending a rule supplement request to the domain knowledge base submodule, requesting the expansion of the missing compliance clause mapping relationship in the logical rule layer; (2) adjusting the selection strategy of few sample demonstration examples in the process of generating the thinking chain template, giving priority to selecting samples with complete reasoning paths and accurate legal references as demonstrations; (3) increasing the matching threshold of semantic verification in the rule engine filtering and verification stage, and eliminating more templates with insufficient logical rigor. This feedback signal is simultaneously transmitted to the domain thinking chain generation module and the data refinement and preprocessing module to achieve coordinated adjustment of the two modules;

[0190] This submodule also includes a built-in priority arbitration mechanism for feedback signals. When multiple performance metrics exceed the limits simultaneously (e.g., both accuracy and inference latency fail to meet the standards), the system determines the execution order of feedback signals based on the priority configuration of the industry application scenario (preset by the user): for scenarios with high real-time requirements (such as online inference services), the feedback signals are executed first. Feedback mechanisms are used to compress inference latency; for scenarios with high accuracy requirements (such as compliance audits), priority is given to execution. Feedback is used to improve accuracy. Feedback signals are encapsulated in a structured format (JSON or XML), including fields such as signal type, target module identifier, list of adjustment parameters, and execution priority, ensuring that the target module can correctly parse and execute the corresponding optimization operations;

[0191] The two submodules form a closed-loop iterative mechanism of "evaluation-diagnosis-feedback-reevaluation": the model performance evaluation submodule continuously produces quantitative performance reports, which the strategy feedback optimization submodule uses to generate targeted optimization instructions to drive the front-end module to adjust. The adjusted module then produces an optimized model or data, which re-enters the evaluation stage. After multiple rounds of closed-loop iteration, the system gradually approaches Pareto optimality in four dimensions: accuracy, inference efficiency, computational energy consumption, and interpretability. This submodule is also responsible for maintaining a complete feedback history. ,in This is the performance report for the t-th round of evaluation. For the feedback signal generated in round t, This serves as a performance report for the next round of evaluation after feedback. This historical record is used both to track the effectiveness of each optimization round and as a source of reward signals in subsequent reinforcement learning training, providing data support for the system's automated evolution.

[0192] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

Claims

1. A lightweight training resource management system for large models designed for industry-specific fine-tuning, characterized in that, include: The data refinement and preprocessing module receives the original industry training dataset and transforms it into a refined training sample set through a pipeline-style data processing chain of semantic encoding, knowledge domain clustering, inference contribution quantification, and refined sample output. The domain thinking chain generation module receives the refined training sample set and transforms it into a thinking chain template set and a strategy knowledge graph through a progressive knowledge processing chain of knowledge accumulation, template induction and graph transformation. The hybrid training control module receives the refined training sample set and the thought chain template set. Through a progressive training pipeline of explicit reasoning training, implicit reasoning compression and efficient parameter fine-tuning, it internalizes the explicit domain reasoning logic into the implicit decision-making ability in the model parameters and outputs a lightweight fine-tuned model. The heterogeneous resource scheduling module receives the policy knowledge graph and dynamically allocates computing resources through a closed-loop scheduling link of state awareness, scheduling decision and asynchronous policy update during the execution of training tasks by the hybrid training control module, while outputting scheduling execution data. The strategy evolution and evaluation module receives the lightweight fine-tuning model and the scheduling execution data, and generates structured feedback signals through a closed-loop iterative link of performance evaluation and feedback optimization, which drive the data refinement and preprocessing module, the domain thinking chain generation module and the hybrid training control module to perform targeted optimization.

2. The lightweight training resource management system for large models oriented to industry fine-tuning as described in claim 1, characterized in that, The data refinement and preprocessing module includes: The semantic encoding submodule uses a pre-trained semantic encoding model to map each data sample in the original industry training dataset into a dense feature vector of fixed dimensions. The feature vectors of all samples constitute a feature matrix. The knowledge domain clustering submodule, based on the feature matrix, uses a clustering algorithm to divide the original industry training dataset into multiple knowledge domain subsets; The reasoning contribution quantification submodule calculates the marginal contribution value of each data sample to the improvement of the model's reasoning ability based on the multi-step reasoning logic complexity within each knowledge domain subset, and sorts the samples within each knowledge domain subset according to the marginal contribution value. The refined sample output submodule selects representative samples from each knowledge domain subset according to the sorting results within each knowledge domain subset and merges them to generate the refined training sample set. The semantic encoding submodule, the knowledge domain clustering submodule, the reasoning contribution quantification submodule, and the refined sample output submodule form a pipeline-style data processing link of "encoding-clustering-quantification-screening".

3. The lightweight training resource management system for large models oriented to industry fine-tuning as described in claim 2, characterized in that, When calculating the marginal contribution value, the reasoning contribution quantification submodule considers the following three dimensions: the number of reasoning steps; the depth of logical dependencies between reasoning steps; and the weight of each reasoning step's influence on the final conclusion. The influence weights are calculated using an attribution analysis method based on Shapley values, treating each reasoning step as a player in a cooperative game and calculating its marginal contribution to the final correct answer.

4. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 1, characterized in that, The domain-specific thought chain generation module includes: The domain knowledge base submodule pre-integrates industry standards, compliance clauses, and dynamic hierarchical logic to construct a three-layer structured knowledge base consisting of a standard specification layer, a logical rule layer, and a knowledge representation layer. The thought chain template generation submodule receives the refined training sample set and the three-layer structured knowledge base, and automatically summarizes the domain reasoning pattern through a few-shot learning mechanism to generate the thought chain template set that conforms to industry logic. The strategy knowledge graph construction submodule transforms the set of thought chain templates into a knowledge graph structure represented by entities and relations, stores scheduling strategies and inference rules in the form of triples, and outputs the strategy knowledge graph. The domain knowledge base submodule, the mind chain template generation submodule, and the strategy knowledge graph construction submodule form a progressive knowledge processing chain of "knowledge accumulation - template summarization - graph transformation".

5. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 1, characterized in that, The hybrid training control module includes: The explicit reasoning training submodule receives the thought chain template set and the refined training sample set, and concatenates the two to construct the "question-thought chain reasoning steps-answer" triple training data. Through multi-task learning, it simultaneously optimizes the classification loss and the reasoning chain reconstruction loss, and guides the large model to learn the explicit decision logic based on the thought chain. The implicit reasoning compression submodule loads the intermediate model parameters trained by the explicit reasoning training submodule and constructs a simplified training dataset after removing the reasoning process description and thought chain. It then performs secondary fine-tuning using the "question-answer" pair to internalize the explicit reasoning logic into an implicit decision-making pattern. The parameter high-efficiency fine-tuning submodule receives the model parameters compressed by the implicit inference compression submodule, uses quantization low-rank adaptation technology to perform high-efficiency fine-tuning of the model parameters, introduces a low-rank adapter in the model attention layer, updates only the parameters of the low-rank adapter, and outputs the lightweight fine-tuned model. The explicit inference training submodule, the implicit inference compression submodule, and the parameter efficient fine-tuning submodule work together in a logical sequence of "explicit injection - implicit solidification - parameter simplification" to form a complete training pipeline.

6. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 1, characterized in that, The heterogeneous resource scheduling module includes: The resource status awareness submodule monitors the multi-dimensional status information of cloud servers and edge servers in real time and constructs a node status vector. The node status vector includes resource utilization, communication bandwidth and performance degradation factor. The performance degradation factor is dynamically modeled using a probability model based on Weibull distribution and log-normal distribution. The scheduling decision submodule receives the global state, the training task workflow to be scheduled, and the policy knowledge graph. It uses a problem decomposition method to recursively decompose the scheduling problem into multiple sub-problems and generates mapping decisions from sub-tasks to computing nodes through collaborative reasoning of a large model. The asynchronous policy update submodule extracts samples from historical scheduling data at preset time intervals and calls the large model to update the policy knowledge graph, thus decoupling the policy update process from the real-time scheduling decision process. The resource status awareness submodule, the scheduling decision submodule, and the asynchronous policy update submodule form a closed-loop scheduling link of "perception-decision-evolution".

7. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 6, characterized in that, The scheduling decision submodule recursively decomposes and solves the scheduling problem according to the following process: The first step is to extract sub-knowledge graphs related to the current sub-problem from the strategy knowledge graph, which will serve as a guide for the thought process; The second step is to combine the current sub-problem, the sub-knowledge graph, and the contextual prompt words into decomposition prompt words, input them into the large model, and guide the model to decompose the current sub-problem into several sub-problems, with each sub-problem accompanied by an influence factor. The third step is to sort the sub-problems in descending order of the influencing factors and divide them into strongly coupled core problems, moderately correlated problems, and weakly correlated problems, and solve them differently by using recursive decomposition, direct calling of large models, and early elimination methods respectively. The fourth step involves recombining the answer pairs for each sub-problem, the sub-knowledge graph, and the current sub-problem into a complete set of prompts, inputting them into the large model for comprehensive reasoning, and obtaining the decision result for the current sub-problem.

8. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 1, characterized in that, The strategy evolution and evaluation module includes: The model performance evaluation submodule receives the lightweight fine-tuned model, evaluates the model's inference performance on multiple industry benchmark test sets, calculates four core evaluation indicators: classification accuracy, inference latency, computational energy consumption, and inference chain integrity score, and outputs a performance evaluation report; the inference chain integrity score is a measure of the semantic alignment between the inference steps generated by the model and the standard inference path. The strategy feedback optimization submodule receives the performance evaluation report and the scheduling execution data, performs multi-dimensional diagnostic analysis on the performance evaluation report, compares each indicator with preset thresholds, identifies the performance bottleneck type, and generates a structured feedback signal based on the performance bottleneck type. The feedback signal is transmitted to the data refinement and preprocessing module and the domain thinking chain generation module, respectively. The model performance evaluation submodule and the strategy feedback optimization submodule form a closed-loop logic of "evaluation-diagnosis-feedback-evolution".

9. The lightweight training resource management system for large models oriented to industry fine-tuning according to claim 8, characterized in that, The diagnostic logic of the strategy feedback optimization submodule includes: When the classification accuracy is lower than a preset threshold, it is determined that the inference coverage of the current refined training sample set is insufficient, and a first type of feedback signal is generated. The first type of feedback signal includes instructions to adjust the weight coefficients in the inference contribution quantification formula, reduce the diversity sampling intensity, and increase the number of knowledge domain clusters, and is transmitted to the data refinement and preprocessing module. When the inference latency or computational energy consumption exceeds a preset threshold, it is determined that the inference steps of the current thinking chain template are too long or the model compression is insufficient. A second type of feedback signal is generated. The second type of feedback signal includes instructions to merge the steps of the thinking chain template, adjust the credibility weight of the inference rules in the strategy knowledge graph, and adjust the low-rank dimension. These instructions are transmitted to the domain thinking chain generation module and the hybrid training control module, respectively. When the reasoning chain integrity score is lower than the preset threshold, it is determined that there is a deviation between the reasoning path of the current thinking chain template and the domain compliance logic, and a third type of feedback signal is generated. The third type of feedback signal includes instructions to send a rule supplementation request to the domain knowledge base submodule, adjust the selection strategy of few sample demonstration examples, and increase the matching threshold of the rule engine filtering verification. At the same time, it is transmitted to the domain thinking chain generation module and the data refinement and preprocessing module.

Images