An industrial scene-oriented lightweight model cloud-edge collaborative self-training evolution method

Abstract

The embodiment of the application provides a lightweight model cloud edge collaborative self-training evolution method for an industrial scene, and belongs to the technical field of intelligent industry. The method forms a lightweight representation of a mutation period in a structured log and a window statistical manner on the edge side, and only returns key samples and key contexts when a trigger condition is met, thereby reducing the return bandwidth and return cost. At the same time, the cloud end cognitive writeback provides weak supervision and enhancement instructions for the mutation samples, so that the lightweight edge model has the feasibility of low-cost self-training. Further, through the hierarchical conflict buffer and dynamic gating mechanism, the noise samples are inhibited from damaging the iteration, and the stability after going online is guaranteed through conflict suppression and stability maintenance constraints. Finally, through the effect association of the new inference log and the backflow package, reusable continuous optimization is formed, so as to realize the reduction of edge inference misjudgment rate and the improvement of inference stability, and the real-time and lightweight deployment constraints are also considered.

Description

Technical Field

[0001] This invention relates to the field of smart industrial technology, specifically to a lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios. Background Technology

[0002] In industrial settings, perception and judgment tasks are typically deployed on edge devices, such as real-time identification of status changes, anomalies, or quality risks during production. These scenarios share common characteristics: First, edge computing and storage resources are limited, requiring lightweight models to meet inference latency and stable operation requirements. Second, the distribution of on-site data drifts with factors such as operating conditions, material batches, equipment status, and environmental conditions, leading to increased false positive rates, distorted confidence levels, or abnormal fluctuations in inference time after a period of operation. Third, industrial settings are highly sensitive to the business costs of misjudgments; the costs of misjudgments vary significantly across different categories, making it difficult to meet practical needs by simply using overall accuracy as the sole metric.

[0003] Existing technologies typically employ a combination of offline centralized training and periodic manual updates: on the one hand, data is collected and labeled for training in the cloud; on the other hand, the updated model is redeployed to edge nodes. However, in industrial scenarios, data distribution drift is often sudden and phased, and there are numerous special situations on-site that are difficult to cover in advance. Relying on fixed-cycle manual collection, cleaning, labeling, and centralized training leads to long update cycles, high costs, and an inability to promptly suppress sudden misclassifications. On the other hand, some existing methods attempt to perform self-training or incremental learning directly at the edge, but due to the lack of reliable label sources and the inability to effectively identify and organize data during abrupt changes, erroneous self-training, catastrophic forgetting, or incorrect reinforcement of conflicting samples can easily occur. Consequently, under certain abrupt changes, this not only fails to reduce the misclassification rate but also introduces new risks.

[0004] Furthermore, data from sudden changes in industrial settings often exhibits short-term flooding characteristics: abnormal outputs erupt concentratedly within a short window, and edge devices generate a large number of logs and samples. Directly transmitting the entire dataset back would put pressure on bandwidth and storage; simple sampling, on the other hand, easily misses key conflict samples, preventing the cloud from forming effective write-back and guidance. Some existing solutions mitigate this by adding more complex edge models or introducing multi-source data fusion, further increasing the burden of edge deployment and hindering lightweight design and real-time constraints.

[0005] Therefore, in industrial scenarios, how to construct a low-cost, sustainable, and stable self-training evolutionary method that can be formed between the cloud and the edge, and can maintain stability under sudden changes, without significantly increasing the complexity of edge-side models and the cost of data backhaul, remains a technical problem that urgently needs to be solved in the implementation of industrial edge intelligence. Summary of the Invention

[0006] The purpose of this invention is to provide a lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios, so as to at least solve the problems of uncontrollable self-training caused by concentrated outbreaks of misjudgments during abrupt changes, lack of reliable labels on the edge side, and excessively high cost of full data backhaul in industrial scenarios. This enables the model to achieve continuous optimization under low cost and maintain the real-time performance and stability of edge inference.

[0007] To achieve the above objectives, the first aspect of this invention provides a lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios. The method includes: acquiring continuous input data from industrial edge nodes, performing edge inference processing on each data point to generate inference results, and simultaneously writing the inference results into an inference log; performing window statistical processing based on the inference log using a time-sliding window to generate window statistical results for each time window and a mutation summary characterizing the degree of short-term mutations; and when the mutation summary meets a preset trigger condition, performing key sample extraction processing, key log pruning processing, and flushing processing from the continuous input data and inference log within the corresponding mutation period. The mutation sample is identified and processed, and then encapsulated with the mutation summary into a mutation backflow package. The mutation backflow package undergoes cloud-based cognitive write-back processing to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, forming the rewritten mutation backflow package. A patch training set is constructed based on the rewritten mutation backflow package, and incremental training is performed to generate an updated edge inference model version. The updated edge inference model version undergoes deployment packaging and canary release processing to generate new inference logs, and effect write-back and reuse scheduling are performed based on the temporal range correlation between the new inference logs and the mutation backflow package.

[0008] Optionally, the process involves acquiring continuous input data from industrial edge nodes, performing edge inference processing on each data entry to generate inference results, and simultaneously writing the inference results into an inference log. This includes: acquiring continuous input data from each industrial edge node; generating an input number and timestamp for each data entry for association and traceability, and forming an indexed input record; performing edge inference processing on each indexed input record to generate a prediction result, prediction confidence, and inference time corresponding to each data entry; and combining the input number, timestamp, prediction result, prediction confidence, inference time, and model version number into a single log record, and aggregating these to obtain the inference log.

[0009] Optionally, window statistical processing is performed on the inference log using a time-sliding window to generate window statistical results for each time window and a mutation summary characterizing the degree of short-term mutations. This includes: performing sliding segmentation processing on the inference log according to a preset window length and a preset step size to obtain multiple time windows arranged in chronological order; for any time window, performing anomaly output density statistical processing, high-confidence anomaly proportion statistical processing, confidence average statistical processing, and inference time average statistical processing on the log records within that time window to generate window statistical results for that time window; performing stable baseline generation processing on the window statistical results corresponding to the time windows determined to be stable to obtain a stable baseline; for any time window, performing deviation calculation processing on the window statistical results of that time window and the stable baseline to obtain a mutation score for that time window; and combining the mutation score with the window statistical results of that time window and the stable baseline to generate a mutation summary.

[0010] Optionally, when the mutation summary meets the preset triggering conditions, key sample extraction processing, key log pruning processing, and conflict sample determination processing are performed from the continuous input data and inference log within the corresponding mutation period, and encapsulated with the mutation summary into a mutation backflow package, including: identifying the mutation period that meets the preset triggering conditions based on the mutation summary, and determining the time window range corresponding to the mutation period; within the mutation period, extracting high-confidence anomalous samples from the continuous input data based on the inference confidence ranking rule, and extracting frequently predicted flipped samples based on the output instability ranking rule, while simultaneously based on the inference cost... Time-consuming abnormal samples are extracted using time-sorting rules, merged, and deduplicated to form key samples. During the mutation period, log records corresponding to the key samples are trimmed from the inference log to form key logs. Conflict rule judgment processing is performed based on the key logs to form a conflict sample list. The conflict rule judgment processing includes at least edge-cloud conclusion inconsistency triggering, short-neighborhood output high-frequency flipping triggering, and abnormal output flooding triggering during the mutation period. The key samples, key logs, conflict sample list, and mutation summary are encapsulated into a mutation backflow package, and the mutation backflow package is written to the cloud backflow queue.

[0011] Optionally, cloud-based cognitive write-back processing is performed on the mutation backflow package to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, forming a written-back mutation backflow package. This includes: performing structured processing on the key samples, key logs, conflict sample list, and mutation summary within the mutation backflow package to form a cloud-based write-back input package; performing weak label generation processing on each key sample based on the cloud-based write-back input package, and generating corresponding weak label confidence levels and reason summaries for each weak label; performing enhancement instruction generation processing based on the cloud-based write-back input package to form an enhancement instruction set consisting of directly executable data augmentation actions and their parameter ranges; and writing the weak labels, weak label confidence levels, reason summaries, and enhancement instruction sets into the write-back slots of the mutation backflow package to form a written-back mutation backflow package.

[0012] Optionally, a patch training set is constructed based on the written-back mutation reflow package, and incremental training is performed to generate an updated version of the edge inference model. This includes: performing hierarchical conflict buffering and sample score calculation based on the written-back mutation reflow package; performing dynamic gating filtering based on the sample score calculation results; performing risk constraint weighting based on the dynamic gating filtering results and constructing a patch training set; performing incremental training on the patch training set and performing release write-back and reuse scheduling.

[0013] Optionally, hierarchical conflict buffering and sample scoring calculation are performed based on the written-back mutation reflow package, including: establishing a unified sample index record for each key sample in the written-back mutation reflow package and aggregating it into an index table; performing hierarchical buffering and diversion processing based on the conflict sample list and the conflict or unstable markers in the unified sample index record to form a trusted pool, a pending pool, and a conflict pool; performing edge-cloud consistency scoring calculation, time consistency scoring calculation, burst consistency scoring calculation, and conflict intensity scoring calculation on the samples in the index table, and writing the scoring results back to the index table.

[0014] Optionally, dynamic gating screening is performed based on the sample score calculation results, including: performing confidence calibration parameter solving processing based on stable period samples to obtain confidence calibration parameters, converting edge prediction confidence into post-calibration confidence; calculating dynamic gating thresholds based on mutation scores, performing gating screening processing, and performing joint gating judgment processing on samples to generate a final trust set, a final undetermined set, and a final conflict pool; wherein, samples entering the final trust set meet the following conditions: conflict intensity score does not exceed the dynamic conflict threshold, edge-cloud consistency is non-negative and time consistency is not lower than a preset threshold, and both post-calibration confidence and weak label confidence are not lower than the corresponding dynamic gating threshold.

[0015] Optionally, risk constraint weighting processing is performed based on the dynamic gating screening results to construct a patch training set, including: calculating training weights for samples in the final trusted set; performing enhanced sample generation processing on the final trusted set based on the enhanced instruction set to generate an enhanced sample set, and inheriting or attenuating the training weights for the enhanced samples according to preset rules; merging the final trusted set and the enhanced sample set and performing deduplication processing to form a patch training set; constructing conflict suppression constraints for samples in the final conflict pool, and constructing stability maintenance constraints for the stable benchmark sample set.

[0016] Optionally, incremental training and deployment write-back and reuse scheduling are performed on the patch training set, including: performing incremental training based on the patch training set, conflict suppression constraints, and stability preservation constraints to generate an updated edge inference model version; performing deployment packaging on the updated edge inference model version and performing canary deployment processing on edge nodes to generate new inference logs; performing window statistics and mutation score calculation based on the new inference logs according to the statistical caliber consistent with the mutation summary, and associating the calculation results with the corresponding mutation reflow package based on the time range and model version number; writing the associated calculation results into the effect field of the mutation reflow package to form a mutation reflow package library with effect tags, and performing reflow priority generation processing and training scheduling strategy generation processing for subsequent mutation reflow package construction and training scheduling.

[0017] A second aspect of this invention provides a lightweight model cloud-edge collaborative self-training evolution system for industrial scenarios. The system is used to execute the aforementioned lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios. The system includes: an inference unit, configured to acquire continuous input data from industrial edge nodes, perform edge inference processing line by line to generate inference results, and simultaneously write the inference results to an inference log; a generation unit, configured to perform window statistical processing based on the inference log using a time-sliding window to generate window statistical results for each time window and a mutation summary characterizing the degree of short-term mutation; and an encapsulation unit, configured to extract key samples from the continuous input data and inference log within the corresponding mutation period when the mutation summary meets a preset trigger condition. The system comprises the following components: a processing unit for key log trimming and conflict sample identification, which encapsulates the mutation summary into a mutation reflow package; a forming unit for performing cloud-based cognitive write-back processing on the mutation reflow package to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, thus forming the reflowed mutation reflow package; a building unit for constructing a patch training set based on the reflowed mutation reflow package and performing incremental training to generate an updated edge inference model version; and a deployment unit for performing deployment packaging and canary release processing on the updated edge inference model version to generate new inference logs, and performing effect write-back and reuse scheduling based on the time range correlation between the new inference logs and the mutation reflow package.

[0018] Through the above technical solutions, this invention forms a lightweight representation of mutation periods at the edge using structured logs and window statistics. Only key samples and key contexts are backed up when triggering conditions are met, thereby reducing backhaul bandwidth and cost. Simultaneously, cloud-based cognitive write-back provides weak supervision and enhancement instructions for mutation samples, enabling low-cost self-training of the lightweight edge model. Furthermore, hierarchical conflict buffering and dynamic gating mechanisms suppress the disruption of iteration by noisy samples, and conflict suppression and stability maintenance constraints ensure post-deployment stability. Finally, the correlation between the effects of new inference logs and backhaul packages forms reusable continuous optimization, reducing the false positive rate and improving inference stability at the edge, while balancing real-time performance and lightweight deployment constraints. This solves the problems of concentrated false positives during mutation periods in industrial scenarios, the lack of reliable labels at the edge, and the high cost of full backhaul, leading to uncontrollable self-training. It enables continuous optimization of the model under low-cost conditions while maintaining real-time performance and stability of edge inference.

[0019] Other features and advantages of the embodiments of the present invention will be described in detail in the following detailed description section. Attached Figure Description

[0020] The accompanying drawings are provided to further illustrate embodiments of the present invention and form part of the specification. They are used together with the following detailed description to explain the embodiments of the present invention, but do not constitute a limitation thereof. In the drawings:

[0021] Figure 1 This is a flowchart illustrating the steps of a lightweight cloud-edge collaborative self-training evolutionary method for industrial scenarios, provided by one embodiment of the present invention.

[0022] Figure 2 This is a system architecture diagram of a lightweight cloud-edge collaborative self-training evolutionary system for industrial scenarios provided by one embodiment of the present invention. Detailed Implementation

[0023] The specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0024] like Figure 1 As shown, this invention provides a lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios, the method comprising:

[0025] Step S1: Obtain continuous input data from industrial edge nodes, perform edge inference processing on each data item to generate inference results, and write the inference results into the inference log.

[0026] In this embodiment of the invention, step S1 is used to perform real-time inference on continuous input data at the edge and to precipitate the inference output in a structured manner as an inference log, so as to identify abrupt change periods, extract key samples, and provide a unified index basis for cloud write-back and training.

[0027] This step binds elements such as input number, timestamp, output result, output confidence, inference time, and model version number to the same log record, enabling any subsequent step to trace the corresponding data source based on the same input number. This avoids problems such as unclear origins or broken connections during data reflux and reuse. Compared with common log methods that only record output conclusions, this unified log base organization method can further support statistical analysis of phenomena such as confidence drift, time fluctuations, and output flips, thereby improving the feasibility and accuracy of mutation detection. In one implementation, step S1 includes the following execution sub-steps:

[0028] S101: Acquire continuous input data from each industrial edge node, generate an input number and timestamp for each input data for association and traceability, and form an indexed input record. Specifically, step S101 is used to establish a traceable index identifier before the data enters edge inference.

[0029] In practical applications, industrial field data typically arrives continuously in a streaming manner. Without a unified numbering and timestamp, it becomes difficult to align the same input during subsequent window statistics, sample extraction, cloud write-back, and grayscale comparison, leading to a mismatch between training samples and operational logs. This invention addresses this by synchronously writing a local clock timestamp to the input data received at the edge node and generating an input number according to an auto-incrementing rule. The input number can be segmented by device dimension or reset by session dimension, but is not limited to a single numbering strategy, as long as it ensures uniqueness within a preset backflow period.

[0030] In one executable implementation, the input number and timestamp can be written into a circular cache index table, so that the subsequent step S3 can quickly locate the corresponding original input data by index when extracting key samples during the mutation period, thereby reducing additional retrieval overhead.

[0031] S102: Perform edge inference processing on each indexed input record to generate a prediction result, prediction confidence, and inference time corresponding to each input data record. Specifically, step S102 is used to generate real-time inference output on the edge side.

[0032] In practical applications, abrupt changes not only manifest as changes in the output conclusions, but also as changes in the output confidence distribution and abnormal fluctuations in inference time. Therefore, confidence and time consumption need to be used as important inputs for subsequent statistics and gating.

[0033] As is easily understood, edge inference processing can directly call existing mature inference frameworks to perform forward inference of the model, and the inference time can be obtained by recording the time difference before and after inference. In one executable implementation, the inference time can be decomposed into a combination of preprocessing time, inference time, and postprocessing time, but this decomposition is not necessary, and this invention does not limit the use of a certain time division method.

[0034] S103: Combine the input number, timestamp, prediction result, prediction confidence, inference time, and model version number into a single log record, and aggregate them to obtain the inference log. Specifically, step S103 is used to construct a structured inference log. This embodiment of the invention uses a unified set of fields to form a data table that can be directly consumed by window statistics, enabling step S2 to directly perform sliding window statistics on the log without needing to revisit the original input data.

[0035] In practical applications, inference logs can be written to local files, embedded databases, or message queues, without being limited to a specific storage method, but it is necessary to ensure that step S2 can read or scan log records in chronological order.

[0036] Step S2: Perform window statistics processing based on the inference log by time sliding window to generate window statistics results for each time window and mutation summaries characterizing the degree of short-term mutation.

[0037] In this embodiment of the invention, step S2 is used to perform sliding window statistical processing on the inference log generated in step S1 to form window statistical results, and further construct a mutation summary to determine whether a mutation period has been entered. Specifically, the continuous running process is divided into multiple time windows, and window-scale statistics are used to characterize phenomena such as short-term anomaly outbreaks, confidence drift, and latency increases, so that mutation identification has automatic triggering conditions, thereby providing a clear time range and priority basis for the subsequent step S3 to construct the mutation backflow package. In one embodiment, step S2 includes the following execution sub-steps:

[0038] S201: Perform sliding segmentation processing on the inference log according to a preset window length and a preset step size to obtain multiple time windows arranged in chronological order. Specifically, step S201 is used to divide the log sequence into comparable statistical units.

[0039] Specifically, sudden changes in industrial settings often exhibit characteristics of short-term outbreaks followed by phased recovery. A sliding window can capture the onset and spread of these changes without losing temporal continuity. In this embodiment of the invention, the window length and step size can be set according to the real-time requirements of the site and are not limited to a specific value. For example, the window length can be tens of seconds to several minutes, and the step size can be several seconds to tens of seconds, as long as sufficiently dense statistical points are formed when the sudden change occurs.

[0040] In one executable implementation, the window boundaries can be sliced ​​by timestamp or by the number of log entries. Both methods are executable, and this invention does not limit the use of a particular slicing method.

[0041] S202: For any given time window, based on the log records within that time window, perform statistical processing on the anomaly output density, the proportion of high-confidence anomalies, the mean confidence level, and the mean inference time to generate the window statistics for that time window. Specifically, step S202 is used to extract observable features of mutations at the window scale.

[0042] In industrial scenarios, when changes in operating conditions cause the model to become unsuitable, abnormal outputs often occur in a concentrated burst within a short time window. At the same time, due to model overconfidence or distorted confidence, the proportion of high-confidence anomalies may increase. In addition, resource competition or changes in data form may also lead to an increase in the average inference time.

[0043] In practical applications, abnormal outputs can be defined by business rules. For example, certain output categories can be considered abnormal, or judgment results that exceed the normal range can be considered abnormal. This invention does not limit the definition of abnormalities to a specific rule; however, it is necessary to ensure that the definition of abnormalities remains consistent in step S3 (sample extraction) and step S6 (effect write-back). For example, if the density of abnormal outputs within a window suddenly increases from a low level during the stable period, and the average inference time also increases, then the window is more likely to belong to the mutation phase and needs to proceed to the subsequent mutation summary calculation.

[0044] S203: Perform stable baseline generation processing based on the window statistics corresponding to the time window determined to be stable, to obtain a stable baseline. S204: For any time window, perform deviation calculation processing based on the window statistics of that time window and the stable baseline, to obtain a mutation score for that time window. Specifically, steps S203 and S204 are used to construct a stable reference and compress multi-dimensional deviations into a single triggerable score. In industrial scenarios, the statistical scales of different equipment and production lines vary greatly, and directly using a fixed threshold is prone to false triggering. A stable baseline enables adaptive deviation judgment based on equipment and on-site conditions.

[0045] In this embodiment of the invention, the mutation score satisfies the following expression:

[0046] ;

[0047] in, The mutation score represents the time window w; α, β, γ, and δ represent the deviation weighting coefficients. , , , These represent the abnormal output density, the proportion of high-confidence anomalies, the mean confidence level, and the mean inference time corresponding to the stable baseline, respectively.

[0048] In practical applications, a stable baseline can be obtained by statistically analyzing a set of windows that have been determined to be stable over a recent period. The criteria for determining a stable window are not limited to a specific form and can be selected by filtering based on conditions such as low abnormal output density and small fluctuations in time consumption.

[0049] In one feasible implementation, the weighting coefficients can be configured according to business risk: for example, in scenarios that are more sensitive to high-cost misjudgments, the weights of abnormal output density and the proportion of high-confidence abnormalities can be increased, so that mutation triggers are more biased towards windows of increased risk.

[0050] S205: Combine the mutation score with the window statistics of the time window and the stable baseline to generate a mutation summary. Specifically, step S205 is used to organize the mutation score and window statistics into a mutation summary, so that the subsequent step S3 can directly determine the repatriation period range, repatriation priority and sampling strategy based on the mutation summary.

[0051] In this embodiment of the invention, mutation intensity and mutation manifestation are recorded simultaneously, which can both trigger reflux and guide the focus of subsequent sampling. In practical applications, the triggering condition can be set to the form of mutation score exceeding a preset threshold, or mutation score exceeding the threshold for multiple consecutive windows, etc.

[0052] Step S3: When the mutation summary meets the preset triggering conditions, perform key sample extraction processing, key log pruning processing and conflict sample determination processing from the continuous input data and inference logs within the corresponding mutation period, and encapsulate them with the mutation summary into a mutation backflow package.

[0053] In this embodiment of the invention, step S3 is used to extract key samples from the input data and inference logs during the mutation period, trim key logs, and identify conflicting samples when the mutation summary meets the triggering conditions, and then encapsulate them into a mutation backflow package and transmit it back to the cloud. The mutation backflow package is a key feature of this invention; it represents the minimum sufficient data set during the mutation period, ensuring that the cloud can complete cognitive write-back and training-driven operations without performing a full log backflow. This data organization method differs from traditional random sampling backflow or full log backflow: it not only carries key samples but also the corresponding inference context logs and a list of conflicting samples, enabling the cloud to identify uncertainties and output more controllable weak supervision signals during the write-back stage. In one implementation, step S3 includes the following execution sub-steps:

[0054] S301: Based on the mutation summary, identify mutation periods that meet preset triggering conditions, and determine the time window range corresponding to the mutation periods. Specifically, step S301 is used to clarify the time period boundaries of the reverted data. Only by accurately defining the mutation period range can we ensure that the key samples extracted subsequently do indeed come from the mutation phase, avoiding the dilution of the training target due to the mixing of stable period data.

[0055] In practical applications, the time window identifier of the mutation summary can be used to trace back to the starting window and then extended to the window where the mutation score falls back to a stable range. The extension rule is not limited to a certain form; it can be extended by a fixed number of windows or based on the score decline. For example, if the mutation score is consistently higher than the threshold for three consecutive windows, these three windows, plus one buffer window before and after them, can be considered as the mutation period to cover the prodromal and convergence phases of the mutation.

[0056] S302: During the mutation period, high-confidence anomalous samples are extracted from the continuous input data based on the inference confidence ranking rule, and frequently predicted flipped samples are extracted based on the output instability ranking rule. Simultaneously, time-consuming anomalous samples are extracted based on the inference time consumption ranking rule. After merging and deduplication, key samples are formed. Specifically, step S302 is used to maximize the coverage of mutation features under a limited backflow budget.

[0057] It should be noted that misjudgments during mutation periods often occur in samples with high confidence but potential errors, samples with frequently flipped outputs, and samples with abnormally long inference times, which correspond to cognitive bias risk, decision instability risk, and resource anomaly risk, respectively. The embodiments of the present invention can form a sample set covering the key points of mutation by sorting and extracting these three types of samples.

[0058] In practical applications, high-confidence outlier samples can be extracted by sorting by inference confidence, frequently flipped samples by neighborhood flip count, and time-consuming outlier samples by inference time. These samples are then merged and deduplicated by the input IDs to obtain the key sample set. The number of samples extracted can be configured according to bandwidth and storage budget and is not limited to a fixed size.

[0059] In one executable implementation, different quotas can be assigned to the three types of sampling, for example, increasing the quota for abnormal time-consuming samples when inference time fluctuates significantly; this quota strategy is also not limited to a single implementation.

[0060] In other words, this sub-step is equivalent to prioritizing representative samples from the sample types most likely to cause problems.

[0061] S303: During the mutation period, log records corresponding to the key samples are pruned from the inference log to form a key log. Specifically, step S303 is used to retain the inference context for each key sample.

[0062] It's important to note that cloud-based write-back requires not only the samples themselves but also information such as the edge's output conclusions, confidence levels, and processing time to assess conflict risk and credibility. Therefore, it's necessary to trim log records that match the key samples. In practical applications, corresponding records can be retrieved from the inference log based on the input ID, and the output can be trimmed. The trimmed results can maintain the same order as the key samples for alignment during cloud-based write-back.

[0063] S304: Perform conflict rule determination processing based on the key logs to form a conflict sample list; wherein, the conflict rule determination processing includes at least edge cloud conclusion inconsistency triggering, short neighborhood output high-frequency flipping triggering, and abnormal output flooding triggering during abrupt change periods. Specifically, step S304 is used to pre-label high-risk samples that are not suitable for direct self-training.

[0064] It should be noted that during the mutation period, there may be samples with reversed output and high confidence or concentrated misjudged samples caused by abnormal flooding. If these samples are directly entered into self-training, they are easily reinforced incorrectly. Therefore, they need to be compiled into a list of conflicting samples so that the subsequent step S5 can perform hierarchical conflict buffering.

[0065] In practical applications, conflict rules may include at least: high-frequency flipping of short neighborhood outputs, flooding of abnormal outputs in abrupt windows, and abnormally high confidence levels that are inconsistent with the overall trend of the window. Conflict rules are not limited to the above list and can be expanded according to the risk preferences of industrial sites.

[0066] S305: Encapsulate the key samples, key logs, conflict sample list, and mutation summary into a mutation reflow package, and write the mutation reflow package into the cloud reflow queue. Specifically, step S305 is used to form a reflow data carrier that can be directly consumed by the cloud.

[0067] In this embodiment of the invention, key samples, key logs, conflict sample lists, and mutation summaries are encapsulated in the same package. This allows the cloud to complete cognitive write-back and enhancement instruction generation without relying on other data sources, thereby reducing the likelihood of incomplete cloud processing dependencies. It is easy to understand that the encapsulation fields of the mutation reflow package can be added or removed according to the project implementation; for example, a compression method identifier or sampling strategy identifier can be included, but the alignment relationship between key samples and key logs should not be disrupted.

[0068] Step S4: Perform cloud-based cognitive write-back processing on the mutation backflow package to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, forming the written-back mutation backflow package.

[0069] In this embodiment of the invention, step S4 is used to perform cloud-based cognitive write-back processing on the mutation backflow package, generating weak labels, weak label confidence, reason summaries, and enhancement instruction sets, and writing back the mutation backflow package to form the rewritten mutation backflow package. Then, leveraging the cognitive generalization capabilities of a mature multimodal large model in the cloud, key samples during the mutation period are quickly labeled and enhanced in a weakly supervised manner, thereby driving the training of a lightweight terminal model without increasing the complexity of the edge model.

[0070] It should be noted that the weak label described in this invention is a label form that can be used for training but allows for uncertainty, which is different from the artificial strong label; the confidence of the weak label is used to characterize the reliability of the cloud write-back results, and will subsequently participate in gating and weighting in step S5 to suppress the risk of erroneous self-training.

[0071] In one implementation, step S4 includes the following execution sub-steps:

[0072] S401: Perform structured processing on the key samples, key logs, conflict sample list, and mutation summary within the mutation backflow package to form a cloud write-back input package. Specifically, step S401 organizes the key samples, key logs, conflict list, and mutation summary into a data structure that can be directly processed in the cloud. Cloud write-back requires establishing a clear alignment relationship between samples and context; structured processing can avoid sample mismatches or missing context.

[0073] In practical applications, each key sample and its corresponding log record can be combined into an entry, along with window statistics from the mutation summary as a global context, so that the cloud model can understand the mutation intensity of the system when the sample appears.

[0074] S402: Based on the cloud-based write-back input packet, weak label generation processing is performed on each key sample, and a corresponding weak label confidence score and reason summary are generated for each weak label. Specifically, step S402 is used to form a weak supervision signal. It should be noted that during periods of sudden change in industrial scenarios, timely manual annotation is often lacking. The cloud-based large model provides weak labels through a comprehensive understanding of the sample content and log context, and uses confidence scores to characterize reliability, enabling subsequent training to be carried out under controllable risks.

[0075] In practical applications, this step can be accomplished by calling a mature multimodal large model interface, without requiring the training of a new large model. The specific vendor or implementation method of the large model is not limited. For example, for a key sample, the large model can write back the weak label that is identified as an anomaly, while giving a high confidence level and outputting a reason summary. The reason summary can be used for engineering auditing or subsequent conflict analysis, but the reason summary is not a necessary field for training.

[0076] S403: Based on the cloud-based write-back input packet, perform enhancement instruction generation processing to form an enhancement instruction set consisting of directly executable data enhancement actions and their parameter ranges. Specifically, step S403 is used to provide executable data enhancement actions.

[0077] It should be noted that the number of key samples during mutation periods is limited, and training with only the original samples may not be sufficient. By enhancing the instruction set, the sample morphology space can be expanded without introducing new data sources, thereby improving the generalization ability of the lightweight model to mutation features.

[0078] In practical applications, augmentation actions can be mature and readily available data processing methods, such as noise perturbation, intensity scaling, partial occlusion, temporal pruning, and amplitude normalization. Augmentation instruction sets can include action types and their parameter ranges, used by the edge training side to generate augmented samples according to instructions. It's easy to understand that augmentation instruction sets are not limited to containing a specific augmentation action; the specific set of augmentation actions can be selected according to the business data type, but should maintain the engineering characteristics of being executable, repeatable, and auditable.

[0079] S404: The weak label, the weak label confidence level, the reason summary, and the enhancement instruction set are written into the write-back slot of the mutation reflow package to form a written-back mutation reflow package. Specifically, step S404 is used to form a write-back package that can be directly consumed in subsequent training. Binding the weak label, weak label confidence level, and enhancement instructions to the original reflow package ensures that the same source data is used traceably during the training phase, avoiding uncontrollable situations caused by the separation of training data and write-back data.

[0080] Step S5: Construct a patch training set based on the written-back mutation reflow package, and perform incremental training to generate an updated version of the edge inference model.

[0081] In this embodiment of the invention, step S5 is used to construct a patch training set based on the written-back mutation reflow package and perform incremental training to generate an updated version of the edge inference model. This step introduces a hierarchical conflict buffer self-training improved model mechanism, which makes adaptive improvements to the traditional self-training process for industrial mutation scenarios: it isolates conflict risks through hierarchical conflict buffering, represents edge-cloud consistency and temporal stability through multi-dimensional scoring, suppresses unreliable samples from entering the training through a dynamically changing gating threshold, and reduces catastrophic forgetting through risk-constrained weighting and stability-maintaining constraints. In one implementation, step S5 includes the following execution sub-steps:

[0082] S501: Perform hierarchical conflict buffering and sample score calculation based on the written-back mutation backflow packet, and perform dynamic gating screening based on the sample score calculation result.

[0083] The process involves performing hierarchical conflict buffering and sample scoring calculations based on the written-back mutation reflow package. This includes: establishing a unified sample index record for each key sample within the written-back mutation reflow package and aggregating it into an index table; performing hierarchical buffering and diversion processing based on the conflict sample list and the conflict or instability markers in the unified sample index record to form a trusted pool, a pending pool, and a conflict pool; and performing edge-cloud consistency scoring, time consistency scoring, burst consistency scoring, and conflict intensity scoring calculations on the samples in the index table, and writing the scoring results back to the index table. Specifically, it includes the following two execution processes:

[0084] S5011: Establish a unified sample index and perform hierarchical conflict buffering and traffic splitting.

[0085] Specifically, step S5011 is used to organize the data in the written-back mutation backflow package into a unified index table, and divide the samples into a trusted pool, a pending pool, and a conflict pool. In this embodiment of the invention, elements such as sample body, edge output, cloud weak label, confidence information, mutation window information, and conflict marker are uniformly written into the index table, which can ensure that subsequent scoring and gating are performed based on the same data source; the hierarchical buffer is used to isolate high-risk samples to prevent them from directly affecting training.

[0086] In this embodiment of the invention, the unified sample index record satisfies the following expression: ;

[0087] in, Indicates a sample index record; Indicates key samples; This indicates the edge prediction result; Indicates the confidence level of edge prediction; Indicates the time taken for reasoning; This indicates that weak tags are being written back from the cloud. Indicates the confidence level of a weak label; Indicates a conflict or instability flag; This indicates the time window identifier. In practical applications, the entry conditions for the conflict pool can be directly determined by the list of conflict samples generated in step S3, or additional unstable rules can be superimposed, and it is not limited to a single rule combination.

[0088] Step S5012: Perform multidimensional score calculation and write back to the index table.

[0089] Specifically, step S5012 is used to quantify sample availability. It should be noted that under industrial mutation conditions, screening samples solely based on marginal confidence can easily lead to high-confidence misjudgments; therefore, it is necessary to comprehensively consider factors such as edge-cloud consistency, temporal consistency, mutation window explosiveness, and conflict intensity to form a score.

[0090] In this embodiment of the invention, the score satisfies the following expression:

[0091] ;

[0092] ;

[0093] ;

[0094] ;

[0095] ;

[0096] in, This indicates the edge-cloud consistency score; Indicates the confidence level of edge prediction; Indicates the confidence level of a weak label; This indicates the edge prediction result; This indicates that weak tags are being written back from the cloud. Indicates time consistency score; This indicates the number of output flips within the neighborhood; m represents the neighborhood length. Indicates the burst intensity of the window; Indicates abnormal output density; Indicates the proportion of high-confidence anomalies; , , , Indicates the weighting coefficient; Indicates the consistency score of the outbreak; Indicates the intensity of the conflict; CSET indicates an indicator function; CSET indicates a list of conflicting samples.

[0097] In practical applications, the neighborhood length can be configured according to the log frequency and is not limited to a fixed value; the number of flips can be obtained by statistically analyzing the repeated inputs of the same input number within a short period of time or the output sequences of adjacent samples.

[0098] The dynamic gating screening process based on the sample score calculation results includes: performing confidence calibration parameter solving based on stable period samples to obtain confidence calibration parameters, and converting edge prediction confidence into post-calibration confidence; calculating dynamic gating thresholds based on mutation scores, performing gating screening, and performing joint gating judgment processing on samples to generate a final trust set, a final undetermined set, and a final conflict pool; wherein, samples entering the final trust set meet the following conditions: conflict intensity score does not exceed the dynamic conflict threshold, edge-cloud consistency is non-negative and time consistency is not lower than a preset threshold, and both post-calibration confidence and weak label confidence are not lower than the corresponding dynamic gating threshold.

[0099] Specifically, this process reduces the impact of confidence distortion on screening and implements an adaptive screening strategy where stronger mutations lead to stricter gating. In practical applications, marginal models may become overconfident during distribution drift, and directly gating with the original confidence level will result in a large number of high-confidence false positives. Confidence calibration maps the confidence level to a more stable probability scale, while the dynamic threshold automatically adjusts the screening intensity based on the mutation score.

[0100] In this embodiment of the invention, the post-calibration confidence level satisfies:

[0101] ;

[0102] in, Indicates the confidence level after calibration; σ(·) represents the confidence level before calibration; T represents the confidence calibration parameter; σ(·) represents the Sigmoid function; logit(·) represents the log-odds transformation.

[0103] The dynamic gating threshold satisfies:

[0104] ;

[0105] ;

[0106] in, This represents the high-confidence gating threshold that varies with the degree of mutation. The consistency gating threshold represents how it varies with the degree of mutation. , Indicates the baseline threshold; , This represents the threshold adjustment coefficient; This indicates the mutation score.

[0107] In practical applications, if the number of stable period samples is insufficient to solve the confidence calibration parameters, the default parameters or historical stable period parameters can be reused. This reuse strategy is not limited to a certain implementation method, as long as the system can be executed.

[0108] S502: Based on the dynamic gating screening results, perform risk constraint weighting processing and construct a patch training set. Perform incremental training on the patch training set and perform release write-back and reuse scheduling.

[0109] The process of performing risk constraint weighting processing and constructing a patch training set based on the dynamic gating screening results includes: calculating training weights for samples in the final trusted set; performing enhanced sample generation processing on the final trusted set based on the enhanced instruction set to generate an enhanced sample set, and inheriting or attenuating the training weights for the enhanced samples according to preset rules; merging the final trusted set and the enhanced sample set and performing deduplication processing to form the patch training set; constructing conflict suppression constraints for samples in the final conflict pool, and constructing stability preservation constraints for the stable benchmark sample set. Specifically, it includes the following two execution processes:

[0110] S5021: Perform joint gating screening and build a patch training set.

[0111] Specifically, step S5021 is used to select the final reliable samples from the hierarchical pool, and generate enhanced samples based on the reliable samples according to the enhancement instruction set, ultimately forming a patch training set. Thus, joint gating constrains conflict intensity, edge-cloud consistency, temporal consistency, post-calibration confidence, and weak label confidence, significantly reducing the probability of erroneous weak labels entering training; the method of screening before enhancement avoids amplifying risks by amplifying unreliable samples.

[0112] In practical applications, the final credible set can be set as a set of samples that simultaneously satisfy the following conditions: conflict intensity does not exceed the threshold, edge-cloud consistency is non-negative, time consistency is not lower than the threshold, and post-calibration confidence and weak label confidence are not lower than the dynamic threshold; pending samples can be cached to wait for more subsequent feedback evidence; conflict samples are reserved for constraint construction but do not directly participate in supervised training.

[0113] In one executable implementation, the augmented samples can inherit the weak labels of the original samples and have their training weights decayed according to a preset rule to prevent the proportion of augmented samples from being too high, which could lead to training bias.

[0114] Step S5022: Perform risk constraint weighting and construct conflict suppression constraints and stability maintenance constraints.

[0115] Specifically, step S5022 is used to make training more aligned with industrial risk preferences and to suppress catastrophic forgetting. Incorporating weak label reliability, mutation rate, misjudgment cost, temporal stability, and explosiveness into the training weights allows training to focus more on high-risk and reliable samples. At the same time, conflict suppression constraints limit the model's overconfidence in conflicting samples, and stability constraints ensure that the output distribution of the new and old models is consistent on stable benchmark samples, avoiding the destruction of the original stability after updates.

[0116] In this embodiment of the invention, the training weights satisfy:

[0117] ;

[0118] in, Indicates the training weights; λ represents the confidence level of the weak label; λ represents the noise suppression coefficient. Indicates the mutation priority coefficient; This represents the mutation score; Cost(·) represents the misjudgment cost coefficient function; Indicates time consistency score; This indicates the consistency score for the outbreak.

[0119] The conflict suppression constraint terms satisfy:

[0120] ;

[0121] in, B represents the conflict suppression constraint; B represents the final conflict pool. This represents the model's predicted probability distribution for conflict samples; This represents the maximum confidence threshold.

[0122] The stability preservation constraint terms are satisfied:

[0123] ;

[0124] in, This represents the stability preservation constraint term; Denotes the stable baseline sample set; KL(·||·) represents the KL divergence; This represents the output distribution of the old model; This represents the output distribution of the new model.

[0125] It is easy to understand that the misjudgment cost coefficient function can be given by business configuration and is not limited to a certain fixed form; the stable benchmark sample set can be formed by extracting from the stable window or by reusing from the historical stable library. This invention does not limit its unique source, but requires that it be consistent with the scope of the stable baseline in step S2 to ensure that the constraint is effective.

[0126] The process of incremental training on the patch training set and performing release write-back and reuse scheduling includes: performing incremental training based on the patch training set, conflict suppression constraints, and stability preservation constraints to generate an updated edge inference model version; performing deployment and packaging processing on the updated edge inference model version and performing canary release processing on edge nodes to generate new inference logs; performing window statistics and mutation score calculation processing based on the new inference logs according to the statistical caliber consistent with the mutation summary, and associating the calculation results with the corresponding mutation reflow package based on the time range and model version number; writing the associated calculation results into the effect field of the mutation reflow package to form a mutation reflow package library with effect tags, and performing reflow priority generation processing and training scheduling strategy generation processing for subsequent mutation reflow package construction and training scheduling.

[0127] Specifically, this process is used to update the model version. Conflict suppression and stability preservation constraints are superimposed on the trusted sample supervision term, enabling training to both correct misjudgments of mutations and maintain stable performance.

[0128] In this embodiment of the invention, the overall training objective satisfies:

[0129] ;

[0130] ;

[0131] in, Indicates the overall training objective; The credible sample supervision term is represented by α and β, which represent the weight coefficients of the constraint term; T represents the final credible set. Indicates the training weights; Indicates a weak tag; Indicates a weak tag; Indicates the prediction result; This represents the loss function.

[0132] In practical applications, training can be completed in the cloud and the updated model can be distributed, or it can be completed on an edge server with the necessary conditions. This invention does not limit the location where training calculations take place.

[0133] Step S6: Perform deployment packaging and canary release processing on the updated edge inference model version to generate new inference logs, and perform effect write-back and reuse scheduling based on the time range correlation between the new inference logs and the mutation backflow package.

[0134] In this embodiment of the invention, step S6 is used to deploy, package, and release the updated edge inference model version in a canary release, and write back the effect of the mutation reflow package based on the new inference log during the canary release period, while forming a reuse scheduling strategy for subsequent reflow and training. The new and old models are compared and evaluated using the same statistical criteria as in step S2, and the evaluation results are written back to the reflow package library, enabling the system to accumulate reusable experience in multiple mutation events, thereby reducing the cost of repeated reflow and parameter tuning. In one implementation, step S6 includes the following sub-steps:

[0135] S601: Deploy and package the updated model and perform a canary release, generating a new inference log. Specifically, step S601 is used to gradually replace the model version without affecting production stability. Canary releases can verify the update effect on a small scale, and if negative changes occur, a quick rollback can be performed, thereby reducing risks in industrial settings. In practical applications, canary release ratios can be allocated by device group or by time period; there is no limitation to a specific canary release strategy, as long as a clear version distinction can be formed between the old and new models.

[0136] S602: Based on the new inference log, perform window statistics and mutation scoring calculations using a consistent approach, and associate them with the corresponding mutation backflow package. Specifically, step S602 is used to ensure comparability between the old and new effects. Using the same window statistics items and mutation scoring formula as in step S2, the abnormal output density, high-confidence anomaly ratio, mean confidence level, and mean inference time before and after the update can be directly compared to determine whether the update is effective. In practical applications, the statistical results can be associated with the corresponding mutation backflow package through the time range and model version number to ensure that the effect write-back has a clear source link.

[0137] S603: Write the correlation results into the mutation backflow package to form a backflow package library with effect tags, and generate a reuse scheduling strategy. Specifically, step S603 is used to accumulate reusable experience. The training effect of each mutation is written back to the backflow package library. When encountering similar mutations in the future, the enhancement instructions, gating threshold adjustment experience, or sampling quota configuration in the backflow package can be directly reused, thereby reducing the need for re-exploration.

[0138] In another possible implementation, segment similarity can be replaced by mutation statistical similarity as the reuse criterion, that is, the similarity of statistical items in the mutation summary is compared to select reusable reflow packages; the reuse criterion is not limited to a certain form, as long as it can achieve priority reuse of similar mutations.

[0139] Therefore, this invention reduces backhaul bandwidth and cost by forming a lightweight representation of mutation periods at the edge using structured logs and window statistics, and only backhauling key samples and key contexts when trigger conditions are met. Simultaneously, it provides weak supervision and enhancement instructions for mutation samples through cloud-based cognitive write-back, enabling the lightweight edge model to achieve low-cost self-training. Furthermore, it suppresses the disruption of iteration by noisy samples through hierarchical conflict buffering and dynamic gating mechanisms, and ensures post-deployment stability through conflict suppression and stability maintenance constraints. Finally, it achieves reusable continuous optimization by correlating the effects of new inference logs and backhaul packages, thereby reducing edge inference misjudgment rate and improving inference stability, while balancing real-time performance and lightweight deployment constraints. Ultimately, it can achieve continuous suppression of mutation misjudgments and improved edge inference stability without full backhauling or relying on manual strong annotation.

[0140] like Figure 2 As shown, this invention provides a lightweight model cloud-edge collaborative self-training evolution system for industrial scenarios. The system executes the aforementioned lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios. The system includes: an inference unit, used to acquire continuous input data from industrial edge nodes, perform edge inference processing line by line to generate inference results, and simultaneously write the inference results to an inference log; a generation unit, used to perform window statistical processing based on the inference log using a time-sliding window to generate window statistical results for each time window and a mutation summary characterizing the degree of short-term mutation; and an encapsulation unit, used to execute key sample processing from continuous input data and the inference log within the corresponding mutation period when the mutation summary meets a preset trigger condition. The system comprises the following components: an extraction and processing unit, a key log pruning unit, and a conflict sample determination unit, which encapsulates the mutation summary into a mutation reflow package; a forming unit, which performs cloud-based cognitive write-back processing on the mutation reflow package to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, thus forming the reflowed mutation reflow package; a building unit, which constructs a patch training set based on the reflowed mutation reflow package and performs incremental training to generate an updated edge inference model version; and a deployment unit, which performs deployment packaging and canary release processing on the updated edge inference model version to generate new inference logs, and performs effect write-back and reuse scheduling based on the time range correlation between the new inference logs and the mutation reflow package.

[0141] Those skilled in the art will understand that all or part of the steps in the methods of the above embodiments can be implemented by a program instructing related hardware. This program is stored in a storage medium and includes several instructions to cause a microcontroller, chip, or processor to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes various media capable of storing program code, such as a USB flash drive, portable hard drive, read-only memory (ROM), random access memory (RAM), magnetic disk, or optical disk.

[0142] The optional embodiments of the present invention have been described in detail above with reference to the accompanying drawings. However, the embodiments of the present invention are not limited to the specific details described above. Within the scope of the technical concept of the embodiments of the present invention, various simple modifications can be made to the technical solutions of the embodiments of the present invention, and these simple modifications all fall within the protection scope of the embodiments of the present invention. It should also be noted that the various specific technical features described in the above specific embodiments can be combined in any suitable manner without contradiction. To avoid unnecessary repetition, the embodiments of the present invention will not further describe the various possible combinations.

[0143] Furthermore, various different embodiments of the present invention can be combined in any way, as long as they do not violate the spirit of the embodiments of the present invention, they should also be regarded as the content disclosed by the embodiments of the present invention.

Claims

1. A lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios, characterized in that, The method includes: Continuous input data from industrial edge nodes is acquired, edge inference processing is performed on each data item to generate inference results, and the inference results are written to the inference log. Based on the inference log, window statistics processing is performed on a time-sliding basis to generate window statistics results for each time window and a mutation summary characterizing the degree of short-term mutations; When the mutation summary meets the preset triggering conditions, key sample extraction processing, key log pruning processing and conflict sample determination processing are performed from the continuous input data and inference logs in the corresponding mutation period, and then encapsulated with the mutation summary into a mutation backflow package. The mutation backflow package is processed by cloud-based cognitive write-back to generate weak labels, weak label confidence, and enhancement instruction sets corresponding to the key samples, forming the written-back mutation backflow package. Based on the written-back mutation reflow package, a patch training set is constructed, and incremental training is performed to generate an updated edge inference model version; specifically, this includes: performing hierarchical conflict buffering and sample score calculation based on the written-back mutation reflow package; performing dynamic gating and screening based on the sample score calculation results; performing risk constraint weighting based on the dynamic gating and screening results and constructing a patch training set; performing incremental training on the patch training set and performing release write-back and reuse scheduling; The updated edge inference model version is deployed and packaged, and canary release is performed to generate new inference logs. Based on the time range correlation between the new inference logs and the mutation backflow package, effect write-back and reuse scheduling are performed.

2. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 1, characterized in that, Acquire continuous input data from industrial edge nodes, perform edge inference processing on each data item to generate inference results, and simultaneously write the inference results to an inference log, including: Acquire continuous input data from each industrial edge node, generate an input number and timestamp for each input data for correlation and traceability, and form an indexed input record; Edge reasoning is performed on each of the indexed input records to generate a prediction result, prediction confidence, and inference time corresponding to each input data. The input number, the timestamp, the prediction result, the prediction confidence, the inference time, and the model version number are combined into a single log record, and then aggregated to obtain the inference log.

3. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 1, characterized in that, Based on the inference log, window statistics processing is performed on a time-sliding basis to generate window statistics results for each time window and a mutation summary characterizing the degree of short-term mutations, including: The inference log is processed by sliding segmentation according to a preset window length and a preset step size to obtain multiple time windows arranged in chronological order; For any given time window, based on the log records within that time window, perform statistical processing on the abnormal output density, the proportion of high-confidence anomalies, the average confidence level, and the average inference time to generate the window statistics results for that time window. A stable baseline generation process is performed based on the window statistics corresponding to the time window that has been determined to be stable, in order to obtain a stable baseline. For any given time window, the deviation between the window statistics results of that time window and the stable baseline is calculated to obtain a mutation score for that time window. The mutation score is combined with the window statistics of the time window and the stable baseline to generate a mutation summary.

4. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 1, characterized in that, When the mutation summary meets the preset triggering conditions, key sample extraction, key log pruning, and conflict sample determination are performed from the continuous input data and inference logs within the corresponding mutation period, and then encapsulated with the mutation summary into a mutation backflow package, including: Based on the mutation summary, identify mutation periods that meet preset triggering conditions, and determine the time window range corresponding to the mutation periods; During the mutation period, high-confidence anomalous samples are extracted from the continuous input data based on the inference confidence ranking rule, and frequently predicted flipped samples are extracted based on the output instability ranking rule. At the same time, time-consuming anomalous samples are extracted based on the inference time ranking rule. After merging and deduplication, key samples are formed. During the mutation period, log records corresponding to the key samples are cropped from the inference log to form a key log. Based on the key logs, conflict rule determination processing is performed to form a conflict sample list; wherein, the conflict rule determination processing includes at least edge cloud conclusion inconsistency triggering, short neighborhood output high frequency flipping triggering, and abnormal output flooding triggering during abrupt change periods; The key samples, key logs, conflict sample list, and mutation summary are encapsulated into a mutation reflow package, and the mutation reflow package is written into the cloud reflow queue.

5. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 1, characterized in that, The mutation reflow package is processed using cloud-based cognitive write-back to generate weak labels, weak label confidence levels, and enhancement instruction sets corresponding to the key samples, forming the reflowed mutation reflow package, including: The key samples, key logs, conflict sample list, and mutation summary in the mutation backflow package are processed in a structured manner to form a cloud write-back input package; Based on the cloud-based write-back input package, weak label generation processing is performed on each key sample, and a corresponding weak label confidence score and reason summary are generated for each weak label. Based on the cloud write-back input packet, perform enhanced instruction generation processing to form an enhanced instruction set consisting of directly executable data augmentation actions and their parameter ranges; The weak label, the confidence level of the weak label, the reason summary, and the enhancement instruction set are written into the write-back slot of the mutation reflow packet to form the rewritten mutation reflow packet.

6. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 5, characterized in that, Based on the mutated reflow packet after the write-back, hierarchical conflict buffering and sample scoring calculation are performed, including: A unified sample index record is established for each key sample in the mutagenesis reflux package after writing back and aggregated into an index table; Based on the conflict sample list and the conflict or unstable markers in the unified sample index record, a hierarchical buffering and diversion process is performed to form a trusted pool, a pending pool, and a conflict pool. Perform edge-cloud consistency score calculation, time consistency score calculation, outbreak consistency score calculation, and conflict intensity score calculation on the samples in the index table, and write the score results back to the index table.

7. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 6, characterized in that, Based on the sample scoring results, a dynamic gating screening process is performed, including: Confidence calibration parameters are solved based on samples from the stable period to obtain confidence calibration parameters, and the edge prediction confidence is converted into a calibrated confidence. Dynamic gating thresholds are calculated based on mutation scores, gating screening is performed, and joint gating decision processing is performed on samples to generate a final trust set, a final undetermined set, and a final conflict pool. Among them, the samples entering the final trusted set meet the following conditions: the conflict intensity score does not exceed the dynamic conflict threshold, the edge-cloud consistency is non-negative and the time consistency is not lower than the preset threshold, and the confidence after calibration and the confidence of weak labels are not lower than the corresponding dynamic gating threshold.

8. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 1, characterized in that, Based on the dynamic gating screening results, risk constraint weighting is performed and a patch training set is constructed, including: Calculate the training weights for the samples in the final trust set; Based on the enhanced instruction set, the final trusted set is processed to generate enhanced sample sets, and the training weights are inherited or decayed according to preset rules for the enhanced samples. The final trusted set and the enhanced sample set are merged and deduplication is performed to form a patch training set; Construct conflict suppression constraints for the samples in the final conflict pool, and construct stability preservation constraints for the stable benchmark sample set.

9. The lightweight model cloud-edge collaborative self-training evolution method for industrial scenarios according to claim 8, characterized in that, Incremental training is performed on the patch training set, and a release write-back and reuse schedule is implemented, including: Incremental training is performed based on the patched training set, conflict suppression constraints, and stability preservation constraints to generate an updated version of the edge inference model; The updated edge inference model version is deployed and packaged, and a canary release is performed on the edge nodes to generate new inference logs; Based on the new inference log, window statistics and mutation score calculations are performed using the same statistical caliber as the mutation summary, and the calculation results are associated with the corresponding mutation backflow package based on the time range and model version number. The associated calculation results are written into the effect field of the mutation reflow package to form a mutation reflow package library with effect tags. Reflow priority generation processing and training scheduling strategy generation processing are then performed for subsequent mutation reflow package construction and training scheduling.

Images