A method and system for remote control of a ceramic capacitor lamination machine

Abstract

The present application belongs to the field of remote control, and discloses a kind of ceramic capacitor laminating machine remote control method and system;Through distributed data acquisition interface, micron level alignment accuracy data and crack gap detection data in the process of multilayer ceramic stacking are obtained from the automatic feeding system and defect detection module of ceramic capacitor laminating machine;Redundant records and outliers are removed using data cleaning algorithm, if the comprehensive score of data quality is lower than the preset threshold, then trigger data repair mechanism, generate standardized ceramic lamination dataset;Based on the feature vector of multilayer ceramic stacking, calculate the ceramic lamination complexity weight coefficient, if it exceeds the preset threshold, then start the high-performance computing resource pool containing graphics processing unit cluster and distributed storage, generate ceramic lamination complexity analysis result;According to the ceramic lamination complexity analysis result, generate load prediction value;Generate optimized ceramic lamination production resource configuration state, realize remote control.

Description

Technical Field

[0001] This invention belongs to the field of remote control, and discloses a remote control method and system for a ceramic capacitor stacking machine. Background Technology

[0002] The production of ceramic capacitor stacks faces a complex technical challenge: how to improve production efficiency while ensuring high precision and high quality. This problem involves several aspects: First, micron-level alignment accuracy and crack / void detection require extremely high precision, but large-scale production requires rapid processing of massive amounts of data, creating a contradiction between the two.

[0003] Secondly, the varying complexity of ceramic laminated structures presents a significant challenge: how to flexibly allocate computing resources based on different product characteristics while ensuring processing efficiency and avoiding resource waste. Furthermore, achieving real-time monitoring, rapid response, and intelligent decision-making to address various anomalies during multi-device collaborative production is also a major hurdle.

[0004] Furthermore, optimizing production parameters involves multiple interrelated factors. Finding the optimal balance point in a dynamically changing production environment to improve product yield is equally challenging. These interconnected issues constitute the core technological challenges of intelligent and digital transformation in ceramic capacitor multilayer production. Solving these digital economy transformation issues not only affects the production efficiency and product quality of individual enterprises but also impacts the technological progress and competitiveness of the entire industry.

[0005] Therefore, there is an urgent need to design a remote control method and system for ceramic capacitor stacking machines. Summary of the Invention

[0006] To overcome the aforementioned deficiencies of the prior art and to achieve the above objectives, the present invention provides the following technical solution: a remote control method for a ceramic capacitor stacking machine, comprising:

[0007] Micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process are obtained from the automated feeding system and defect detection module of the ceramic capacitor stacking machine through a distributed data acquisition interface.

[0008] Data cleaning algorithms are used to remove redundant records and outliers. The dataset is verified based on the evaluation criteria of completeness (missing rate less than 5%), consistency (format uniformity rate greater than 95%), and accuracy (error rate less than 2%). If the overall data quality score is lower than the preset threshold T1=0.85, the data repair mechanism is triggered to generate a standardized ceramic stacked dataset.

[0009] The standardized ceramic stack dataset is segmented and processed in parallel using a memory computing engine. The ceramic stack complexity weight coefficient W=Σ(ai×xi) is calculated based on the feature vector of the multi-layer ceramic stack, where ai is the feature importance coefficient calculated based on information gain, ranging from [0,1], and xi is the normalized micron-level alignment accuracy and crack and void detection feature value, ranging from [0,1]. If W exceeds the preset threshold T2=0.7, a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage is started to generate the ceramic stack complexity analysis results.

[0010] Based on the analysis results of ceramic stack complexity, the task allocation ratio of computing nodes is dynamically adjusted by an adaptive load balancing algorithm. The support vector machine algorithm is used to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, and the load prediction value R is generated in units of tasks per second.

[0011] Based on R and the current system utilization U, within the range [0,1], calculate the expansion factor S=R×(1+U) / 1000, where 1000 is the preset baseline load value, in units of tasks per second. If S exceeds the preset threshold T3=1.2, the elastic expansion mechanism is triggered to generate an optimized ceramic stack production resource configuration state.

[0012] Preferably, the acquisition of micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine via a distributed data acquisition interface specifically includes:

[0013] The alignment accuracy data is obtained from the feeding system of the ceramic capacitor stacking machine via the OPCUA protocol, and the crack and void data are obtained from the defect detection module. The two data are then combined to generate the original dataset.

[0014] The Pandas drop_duplicates function was used to remove duplicate records from the original dataset, and the quantile function was used to remove outliers outside the upper and lower 1% quantiles, resulting in a cleaned dataset.

[0015] If the missing value rate of the cleaned dataset is higher than a preset threshold of 15%, the missing values ​​are filled in using linear interpolation to generate a complete dataset.

[0016] Based on pre-established format rules, verify the consistency of field types and units in the completed dataset to determine the format consistency rate.

[0017] Preferably, the step of performing fragmented storage and parallel processing of the standardized ceramic stacked dataset using a memory computing engine specifically includes:

[0018] The Apache Spark in-memory computing framework was used to process the standardized ceramic stack dataset;

[0019] The data output from Spark is sharded using consistent hashing via the libketama library and stored in 64 data shards of the HDFS distributed file system.

[0020] Based on the piecewise distribution structure, 16 computing nodes are started using the MPI parallel framework. Each node calls the SIFT algorithm of OpenCV to extract micron-level alignment coordinate features and calls the ResNet50 pre-trained model to extract crack and void probability features, generating a 256-dimensional feature vector set.

[0021] Input the feature vector set into the scikit-learn's mutual_info_classif function to calculate the information gain of each feature and generate a set of feature importance coefficients;

[0022] The MinMaxScaler is used to perform linear normalization on the feature vector set, compressing all feature values ​​to the interval between 0 and 1, and generating a normalized feature value set.

[0023] Preferably, the step of dynamically adjusting the task allocation ratio of computing nodes through an adaptive load balancing algorithm specifically includes:

[0024] The weighted round-robin algorithm is used to calculate the allocation weight of each computing node. The weight formula is 1 / (1+the current load rate of the node), and the node task allocation table is obtained.

[0025] Real-time temperature and humidity data are obtained from the ambient temperature and humidity sensor. Equipment fault codes are parsed from the cutting device log. If the temperature and humidity exceed the preset range, a compensation coefficient is generated. If the fault code appears three times in a row, an abnormal node is marked.

[0026] The compensation coefficient, the fault marker, and the node CPU utilization rate are combined into an input vector. A support vector machine algorithm is used to train the load prediction model, and the load prediction value for the next 5 minutes is output.

[0027] Preferably, the configuration status of ceramic laminate production resources and the results of ceramic laminate complexity analysis adopt a remote control data encryption protocol and real-time command transmission function. The functional modules of hot pressing molding process and high-speed cutting device are decoupled through microservice architecture. Application programming interface gateway is used to uniformly manage data interaction and user permission verification of multi-device collaborative management. Asynchronous production requests are processed through message queue. If the service response time exceeds the delay threshold T4 determined by the ceramic laminate complexity analysis results, within the range of [100, 300] milliseconds, a service degradation mechanism is initiated to generate a highly available ceramic laminate production platform.

[0028] Preferably, the remotely controlled data encryption protocol and real-time command transmission function specifically include:

[0029] The configuration status of ceramic laminate production resources is obtained through AES-256-CBC encryption, and the configuration status is parsed to obtain the production task allocation table.

[0030] The task instructions from the production task allocation table are distributed to the hot pressing module and the cutting device module using a RabbitMQ message queue, and the execution status of the modules is obtained.

[0031] The real-time production request sequence of the module execution status is processed through the Kafka message queue. The processing time of each module request is counted. If the processing time exceeds the preset latency threshold T4, it is marked as a high latency module, and a list of high latency modules is obtained.

[0032] A weighted round-robin algorithm is used to adjust the task ratio of the high-latency module and generate an optimized task allocation table.

[0033] Preferably, the high-availability ceramic stack production platform collects operational status data and production indicators of multi-layer ceramic stacks through a real-time monitoring module and status feedback mechanism. It uses time series analysis algorithms to predict trends and detect anomalies in central processing unit utilization, memory usage, and environmental temperature and humidity control data, generating an automated operation and maintenance instruction set that includes parameter adjustment and resource reallocation. If any performance indicator deviates from the normal range by more than the preset tolerance T5=10%, an automatic optimization program is triggered to adjust the ceramic stack production parameters. Through remote fault diagnosis and log auditing functions, a stable digital service capability for ceramic capacitor stacks is generated.

[0034] Preferably, the step of collecting operational status data of the high-availability ceramic laminate production platform through a real-time monitoring module and a status feedback mechanism specifically includes:

[0035] The real-time monitoring module collects data on central processing unit usage, memory usage, and ambient temperature and humidity from the ceramic laminate production platform and writes it to the InfluxDB database at minute intervals to generate a structured state dataset.

[0036] The ARIMA algorithm is used to perform 7-day rolling training on the structured state dataset to obtain a trend prediction model and output a prediction dataset.

[0037] If any indicator in the predicted data set exceeds the dynamic threshold calculated based on the 3σ principle, the PID controller is triggered to calculate the adjustment value of the ceramic laminate production parameters and generate a parameter adjustment instruction set containing temperature compensation value and pressure correction value.

[0038] The parameter adjustment instruction set is distributed to the temperature control execution module and the pressure regulation module via the MQTT protocol to obtain the updated operating status dataset.

[0039] Preferably, the step of using a time series analysis algorithm to predict the trend of central processing unit utilization specifically includes:

[0040] The real-time monitoring module collects central processing unit (CPU) usage data, writes it to the InfluxDB time-series database, extracts the most recent 24-hour data from the database, and uses the Prophet algorithm to predict the usage trend for the next hour.

[0041] If the predicted value exceeds the preset threshold of 85%, the decision tree-based rule engine is triggered to calculate the temperature adjustment value and pressure correction value of the ceramic stack production parameters and write them to the RabbitMQ message queue.

[0042] Historical operating status data from the past 30 days is extracted from InfluxDB and merged with the latest collected central processing unit (CPU) utilization data. K-means clustering algorithm is used to match similar operating conditions to generate a set of digital service instructions, which are then transmitted to the control terminal via Modbus TCP protocol to update the production parameters.

[0043] A remote control system for a ceramic capacitor stacking machine includes:

[0044] The distributed data acquisition module is used to acquire micron-level alignment accuracy data and crack and void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine. The data cleaning algorithm is used to remove redundant records and outliers. The dataset is verified according to the evaluation criteria of completeness (missing rate less than 5%), consistency (format uniformity rate greater than 95%), and accuracy (error rate less than 2%). If the overall data quality score is lower than the preset threshold T1=0.85, the data repair mechanism is triggered to generate a standardized ceramic stacking dataset.

[0045] The in-memory computing module is used to perform fragmented storage and parallel processing of the standardized ceramic stack dataset. It calculates the ceramic stack complexity weight coefficient W=Σ(ai×xi) based on the feature vector of the multi-layer ceramic stack, where ai is the feature importance coefficient calculated based on information gain, ranging from [0,1], and xi is the normalized micron-level alignment accuracy and crack and void detection feature value, ranging from [0,1]. If W exceeds the preset threshold T2=0.7, a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage is started to generate the ceramic stack complexity analysis results.

[0046] The load balancing module is used to dynamically adjust the task allocation ratio of computing nodes based on the ceramic stack complexity analysis results and an adaptive load balancing algorithm. It uses a support vector machine algorithm to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, and generates a load prediction value R, in units of tasks per second.

[0047] The expansion control module is used to calculate the expansion factor S=R×(1+U) / 1000 based on R and the current system utilization U, in the range [0,1]. Here, 1000 is the preset baseline load value, and the unit is tasks per second. If S exceeds the preset threshold T3=1.2, the elastic expansion mechanism is triggered to generate an optimized ceramic stack production resource configuration state.

[0048] The technical effects and advantages of the remote control method for a ceramic capacitor stacking machine of the present invention are as follows:

[0049] Through distributed data acquisition interfaces and data cleaning algorithms, we ensure data integrity, consistency, and accuracy. We have set clear evaluation criteria (missing rate <5%, format uniformity rate >95%, error rate <2%) to guarantee data quality. We also have a data repair mechanism to handle abnormal data in a timely manner.

[0050] It employs an in-memory computing engine for sharded storage and parallel processing, utilizes a high-performance computing resource pool including a GPU cluster and distributed storage, and achieves efficient management of 64 data shards through the HDFS distributed file system.

[0051] The system dynamically adjusts task allocation based on an adaptive algorithm, predicts load trends using a support vector machine algorithm, and designs a reasonable expansion mechanism to ensure optimal allocation of system resources. AES-256-CBC encryption is used to protect data transmission, and a complete access control and user management mechanism is implemented, along with remote fault diagnosis and log auditing capabilities.

[0052] It supports real-time monitoring of multi-dimensional data, uses multiple algorithms (ARIMA, Prophet, K-means) for trend prediction, has anomaly detection and automatic optimization capabilities, supports multi-device collaborative management, has an elastic expansion mechanism, realizes automatic optimization of ceramic laminate production parameters, provides complete digital service capabilities, and supports real-time monitoring and adjustment of the production process.

[0053] It reduces resource waste through intelligent resource allocation, lowers equipment failure risk through predictive maintenance, has a high degree of automation, reduces human intervention, accurately controls micron-level alignment precision, effectively monitors and controls cracks and voids, achieves precise adjustment of production parameters, provides a set of automated operation and maintenance instructions, supports remote control and fault diagnosis, and has a complete status feedback mechanism. Attached Figure Description

[0054] Figure 1 : A schematic diagram of the method of the present invention. Detailed Implementation

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

[0056] Example 1

[0057] Please see Figure 1 As shown in this embodiment, a remote control method for a ceramic capacitor stacking machine includes:

[0058] S101,1 acquires micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine through a distributed data acquisition interface. Redundant records and outliers are removed using a data cleaning algorithm. The dataset is verified based on the evaluation criteria of completeness (missing rate less than 5%), consistency (format uniformity rate greater than 95%), and accuracy (error rate less than 2%). If the overall data quality score is lower than the preset threshold T1=0.85, the data repair mechanism is triggered to generate a standardized ceramic stacking dataset.

[0059] S102,2 The standardized ceramic stack dataset is segmented and stored and processed in parallel by the memory computing engine. The ceramic stack complexity weight coefficient W=Σ(ai×xi) is calculated based on the feature vector of the multi-layer ceramic stack, where ai is the feature importance coefficient calculated based on information gain, ranging from [0,1], and xi is the normalized micron-level alignment accuracy and crack and void detection feature value, ranging from [0,1]. If W exceeds the preset threshold T2=0.7, a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage is started to generate the ceramic stack complexity analysis results.

[0060] S103,3 Based on the analysis results of ceramic stack complexity, the task allocation ratio of computing nodes is dynamically adjusted through an adaptive load balancing algorithm. The support vector machine algorithm is used to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, and a load prediction value R is generated in units of tasks per second. Based on R and the current system utilization rate U, in the range [0,1], the expansion factor S=R×(1+U) / 1000 is calculated, where 1000 is the preset baseline load value in units of tasks per second. If S exceeds the preset threshold T3=1.2, the elastic expansion mechanism is triggered to generate an optimized ceramic stack production resource configuration status.

[0061] S104,4 uses a remote control data encryption protocol and real-time command transmission function. Based on the optimized ceramic laminate production resource configuration status and ceramic laminate complexity analysis results, it decouples the functional modules of hot pressing molding process and high-speed cutting device through microservice architecture. It adopts an application programming interface gateway to uniformly manage data interaction and user permission verification for multi-device collaborative management. It processes asynchronous production requests through message queues. If the service response time exceeds the delay threshold T4 determined by the ceramic laminate complexity analysis results, within the range of [100, 300] milliseconds, it initiates a service degradation mechanism to generate a highly available ceramic laminate production platform.

[0062] S105 collects the operating status data of the high-availability ceramic stack production platform and the production indicators of multi-layer ceramic stacks through the real-time monitoring module and status feedback mechanism. It uses time series analysis algorithm to predict trends and detect anomalies in the central processing unit utilization, memory usage and environmental temperature and humidity control data, and generates a set of automated operation and maintenance instructions, including parameter adjustment and resource reallocation. If any performance indicator deviates from the normal range by more than the preset tolerance T5=10%, the automatic optimization program is triggered to adjust the ceramic stack production parameters. Through remote fault diagnosis and log auditing functions, it generates stable digital service capabilities for ceramic capacitor stacks.

[0063] Step S101: 1. Obtain micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine through a distributed data acquisition interface. Use a data cleaning algorithm to remove redundant records and outliers. Verify the dataset based on the evaluation criteria of completeness (missing rate less than 5%), consistency (format uniformity rate greater than 95%), and accuracy (error rate less than 2%). If the overall data quality score is lower than the preset threshold T1=0.85, trigger the data repair mechanism to generate a standardized ceramic stacking dataset.

[0064] Alignment accuracy data is obtained from the feeding system of the ceramic capacitor stacking machine via the OPCUA protocol, and crack and void data are obtained from the defect detection module. These are then merged to generate the original dataset. The `drop_duplicates` function of Pandas is used to remove duplicate records from the original dataset, and the `quantile` function is used to remove outliers outside the upper and lower 1% quantiles, generating a cleaned dataset. If the missing value rate of the cleaned dataset exceeds a preset threshold of 15%, linear interpolation is used to fill in the missing values, generating a complete dataset. Based on pre-established format rules, the field types and unit consistency of the complete dataset are verified to determine the format consistency rate.

[0065] Specifically, alignment accuracy data is obtained from the feeding system of the ceramic capacitor stacking machine via the OPCUA protocol, and crack and void data are obtained from the defect detection module. These are then merged to generate the original dataset. The `drop_duplicates` function of Pandas is used to remove duplicate records from the original dataset, and the `quantile` function is used to remove outliers outside the upper and lower 1% quantiles, generating a cleaned dataset. If the missing value rate of the cleaned dataset exceeds a preset threshold of 15%, linear interpolation is used to fill in the missing values, generating a complete dataset. Based on pre-established format rules, the field types and unit consistency of the complete dataset are verified to determine the format consistency rate.

[0066] Alignment accuracy data was obtained from the feeding system of the ceramic capacitor stacking machine via the OPCUA protocol, and crack and void data were obtained from the defect detection module, and merged into the original dataset. The `drop_duplicates` function of Pandas was used to remove duplicate records, and the `quantile` function was used to remove outliers outside the upper and lower 1% quantiles, generating a cleaned dataset. The missing rate of the cleaned dataset was calculated as the number of missing records divided by the total number of records multiplied by 100.

[0067] If the missing value rate exceeds a preset threshold of 15%, linear interpolation is used to fill in the missing values, generating a complete dataset. Based on pre-established formatting rules, the field types and unit uniformity of the complete dataset are verified; the format uniformity rate is equal to the number of records conforming to the format divided by the total number of records multiplied by 100. If the format uniformity rate is below a preset threshold of 98%, Z-score standardization is used to adjust the numeric fields, generating a standardized dataset.

[0068] Calculate the error rate of the standardized dataset, which is equal to the number of outliers divided by the total number of samples multiplied by 100. If the error rate exceeds a preset threshold of 2%, the outlier values ​​are recalculated using the K-nearest neighbor algorithm (k=5) based on Euclidean distance to generate a repaired dataset. Calculate the overall quality score of the repaired dataset, which is equal to 0.3 multiplied by the completeness rate plus 0.7 multiplied by the accuracy rate.

[0069] If the overall score is lower than the preset threshold of 95%, the K-nearest neighbor repair process is repeated until the final ceramic laminate dataset is output. When acquiring data from the automated feeding system and defect detection module of the ceramic capacitor laminate machine, micron-level alignment accuracy data with an accuracy of ±1μm is obtained from the servo motor encoder of the feeding system via a distributed data acquisition interface using the MQTT protocol at a sampling frequency of 100Hz. Simultaneously, crack and void detection data are acquired from the CCD camera of the defect detection module at a resolution of 0.5μm / pixel. The data is transmitted in JSON format via a Kafka message queue, processing 1000 records per second. The data cleaning algorithm uses an outlier detection method based on Z-scores, setting a threshold Z=3 to remove records with alignment accuracy deviations exceeding 3μm or crack width outliers exceeding 5μm. Redundant records are also removed through timestamp synchronization checks, retaining data with a time difference of less than 10ms. Data integrity is assessed by calculating the missing rate; scanning 1 million records, a missing rate below 5% (i.e., fewer than 50,000 missing records) is considered acceptable.

[0070] Consistency assessment uses regular expressions to verify the JSON format uniformity rate, which must be higher than 95% (i.e., fewer than 5000 records with format errors). Accuracy assessment compares the data with a standard template, with an error rate lower than 2% (i.e., fewer than 20000 error records). The comprehensive score is calculated as S = 0.4 × Completeness + 0.3 × Consistency + 0.3 × Accuracy. If S < 0.85, a data repair mechanism is triggered, using the KNN algorithm (K=5) to fill in missing values ​​based on nearest neighbor interpolation and replacing outliers with the mean. This generates a standardized ceramic laminate dataset containing alignment accuracy, crack width, and timestamps, stored in Parquet format. Each batch of data is approximately 1GB, supporting subsequent analysis. Alignment accuracy data is used to optimize the servo control of the feeding system, and crack data is used to adjust the pressing parameters to ensure the stability of the ceramic laminate quality.

[0071] The micron-level alignment accuracy and crack / void detection data of the ceramic capacitor stacking machine are acquired through a distributed data acquisition interface. The integrity, consistency and accuracy of the dataset are verified according to the evaluation criteria of missing rate, format uniformity rate and error rate. If the comprehensive score is lower than the preset threshold, a data repair mechanism is adopted to obtain a standardized ceramic stacking dataset.

[0072] Micrometer-level alignment accuracy data is obtained from the automated feeding system of the ceramic capacitor stacking machine, and crack / void data is obtained from the defect detection module. These are combined to generate an initial dataset. For the initial dataset, the mean imputation method is used to complete missing records, generating a complete dataset. For the complete dataset, regular expressions are used to verify that the alignment accuracy field is a floating-point number in micrometers and the crack / void field is an integer in square micrometers, generating a formatted dataset. For the formatted dataset, a random forest classifier is used to repair outliers, generating a repaired dataset. Based on the repaired dataset, the completeness rate, format consistency rate, and accuracy rate are calculated. If the overall score is lower than a preset threshold, outliers are iteratively repaired to generate an optimized dataset.

[0073] Specifically, micron-level alignment precision data is acquired from the automated feeding system of the ceramic capacitor stacking machine via a distributed data acquisition interface, and crack and void data are acquired from the defect detection module. These are then combined to generate an initial dataset. The missing rate of the initial dataset is calculated, which is equal to the number of missing records divided by the total number of records. If the missing rate exceeds a preset threshold, the mean imputation method is used to impute missing records based on the mean of the non-missing values ​​of the fields, generating a complete dataset.

[0074] For the completed dataset, regular expressions are used to validate the format of each field. Format consistency is equal to the number of records conforming to predefined format rules divided by the total number of records. These predefined format rules include setting the alignment precision field to floating-point type with units of micrometers, and the crack gap field to integer type with units of square micrometers. If the format consistency is below a preset threshold, the field types are converted to generate a formatted dataset. For the formatted dataset, an error rate is calculated, equal to the number of outlier records divided by the total number of records. Outlier criteria include alignment precision exceeding ±3 standard deviations or a negative crack gap value.

[0075] If the error rate exceeds a preset threshold, a random forest classifier is used to repair outliers based on feature importance ranking, generating a repaired dataset. Based on the repaired dataset, the completeness rate, format consistency rate, and accuracy rate are calculated. The completeness rate equals the proportion of records without missing data, the format consistency rate follows the previous definition, and the accuracy rate equals the proportion of records without outliers. The overall score equals completeness rate × weight a plus format consistency rate × weight b plus accuracy rate × weight c. If the overall score is below a preset threshold, the outlier repair steps are iteratively executed to generate an optimized dataset. For the optimized dataset, it is verified whether each field meets the business specifications, which are that the alignment accuracy error does not exceed a specified range and the crack void area does not exceed a specified value, generating a standardized ceramic laminate dataset.

[0076] When acquiring data from the automated feeding system and defect detection module of the ceramic capacitor stacking machine, the distributed data acquisition interface can adopt a RESTful API approach. Micrometer-level alignment accuracy data is obtained from the servo motor of the feeding system, with accuracy controlled within ±1.5 micrometers. Simultaneously, crack and void data are acquired from the high-resolution CCD camera of the defect detection module, with an accuracy of 0.8 square micrometers. The initial dataset is stored in JSON format, containing alignment accuracy, crack and void area, and timestamp fields. Missing rate calculation is based on scanning 500,000 records. If more than 25,000 records are missing, i.e., the missing rate is higher than 5%, the imputation mechanism is triggered. The Pandas `fillna` function is used to imput missing records based on the mean of non-missing values ​​in the alignment accuracy field, for example, 2.3 micrometers, ensuring data integrity. This method effectively reduces the impact of missing data on subsequent analysis.

[0077] Specifically, format consistency verification uses regular expressions to validate field formats.

[0078] For example, the alignment precision field must be a floating-point number in micrometers, such as 1.234; the crack gap field must be an integer in square micrometers, such as 45. If the format consistency is less than 95%, meaning there are more than 5000 records with format errors, then use Pandas' astype function to convert the non-conforming fields to a standard type, such as converting the string "1.234um" to the floating-point number 1.234. This format standardization operation helps ensure the standardization of the dataset, facilitating subsequent processing.

[0079] In one embodiment, the error rate is calculated by counting the number of outlier records.

[0080] For example, if the alignment accuracy exceeds ±3 times the standard deviation (e.g., a mean of 2 micrometers and a standard deviation of 0.5 micrometers), the outlier range is values ​​outside the 0.5 to 3.5 micrometer range. Negative crack pore values ​​(e.g., -10 square micrometers) are also considered outliers. If the error rate exceeds 3%, meaning there are more than 15,000 outlier records, RandomForestClassifier is used to prioritize and correct alignment accuracy anomalies based on feature importance. This method uses a machine learning model to identify key features, effectively improving data accuracy.

[0081] Understandably, the overall score calculation combines completeness rate, format consistency rate, and accuracy rate.

[0082] For example, if the completeness rate is 98%, the format consistency rate is 96%, and the accuracy rate is 95%, then the overall score is 0.3×0.98 + 0.2×0.96 + 0.5×0.95 = 0.961. If the score is below 90%, outlier repair is repeated, with a maximum of 5 iterations, to ensure dataset quality. Optimizing the dataset requires verifying business specifications, such as alignment accuracy error not exceeding ±2 micrometers and crack void area not exceeding 50 square micrometers. This verification ensures the data meets the requirements of ceramic lamination processes.

[0083] For example, when generating standardized ceramic laminate datasets, the data is stored in CSV format, with each batch approximately 500MB. Alignment accuracy data can be used to optimize the servo motor control logic of the feeding system, while crack and void data can guide adjustments to the pressing process parameters. The high quality of this dataset supports the stability of subsequent process optimization.

[0084] Step S102,2: The standardized ceramic stack dataset is segmented and stored in parallel using a memory computing engine. The ceramic stack complexity weight coefficient W=Σ(ai×xi) is calculated based on the feature vectors of the multi-layer ceramic stack, where ai is the feature importance coefficient calculated based on information gain, ranging from [0,1], and xi is the normalized micron-level alignment accuracy and crack and void detection feature value, ranging from [0,1]. If W exceeds the preset threshold T2=0.7, a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage is started to generate the ceramic stack complexity analysis results.

[0085] The Apache Spark in-memory computing framework was used to process the standardized ceramic stacked dataset. The data output from Spark was sharded using consistent hashing via the libketama library and stored across 64 data shards in the HDFS distributed file system.

[0086] Based on the sharded distribution structure, 16 computing nodes are launched using the MPI parallel framework. Each node calls OpenCV's SIFT algorithm to extract micrometer-level alignment coordinate features and calls the ResNet50 pre-trained model to extract crack and void probability features, generating a 256-dimensional feature vector set. The feature vector set is input into the scikit-learn function `mutual_info_classif` to calculate the information gain of each feature, generating a set of feature importance coefficients. MinMaxScaler is used to linearly normalize the feature vector set, compressing all feature values ​​to the interval between 0 and 1, generating a normalized feature value set. The ceramic stack complexity weight coefficient W is calculated using the formula W = the sum of the feature importance coefficients ai multiplied by the normalized feature values ​​xi. If the complexity weight coefficient W exceeds a preset threshold T2, a GPU cluster consisting of 8 NVIDIA Tesla V100 GPUs and HDFS storage resources are allocated. The GPU cluster uses PyTorch's convolutional neural network to process the feature data, outputting a 3D complexity distribution map of the ceramic stack, which is then stored in a designated shard of HDFS.

[0087] Specifically, processing ceramic laminated datasets involves multiple technical topics, including distributed computing, feature extraction, feature selection, normalization, and complexity analysis. The following analysis and examples address each technical topic, focusing on the business domain of ceramic laminated quality analysis and closely integrating the historical data collection and cleaning context to ensure logical rigor and mutual support.

[0088] For example, when processing standardized ceramic laminated datasets, the Apache Spark in-memory computing framework can efficiently handle large-scale data through its distributed computing capabilities. Spark loads the data into memory and uses the resilient distributed dataset RDD to process alignment accuracy and crack void data in parallel.

[0089] In one possible implementation, assuming the dataset contains 10 million records, each including micrometer-level alignment coordinates and crack widths, Spark uses the DataFrame API to group and aggregate the data, calculating the mean alignment deviation and crack width distribution for each batch. This approach can quickly process datasets up to 1GB in size, significantly improving computational efficiency. For data sharding and storage, the libketama library implements consistent hashing sharding, evenly distributing data across 64 shards in HDFS.

[0090] For example, 10 million records are hashed using positional precision values, with each shard storing approximately 156,000 records. HDFS ensures data reliability through a multi-replica mechanism, making it suitable for the high availability requirements of ceramic stacked data. After sharding, data can be quickly retrieved by timestamp or batch number, facilitating subsequent feature extraction.

[0091] Specifically, the MPI parallel framework initiates 16 computing nodes to extract features. OpenCV's SIFT algorithm is used to analyze the alignment coordinate image, generate 128-dimensional keypoint descriptors, and capture micrometer-level alignment deviation features.

[0092] For example, the servo motor of the feeding system provides coordinate images with an accuracy of ±1μm. The SIFT algorithm identifies key points and generates feature descriptors for analyzing alignment stability. The ResNet50 pre-trained model processes crack and void images and outputs the crack probability distribution.

[0093] For example, a CCD camera provides images with a resolution of 0.5 μm / pixel, and ResNet50 extracts crack edge features, forming a 256-dimensional feature vector. This feature extraction method can accurately characterize the quality of ceramic stacks. In feature selection, the scikit-learn function `mutual_info_classif` calculates the information gain and evaluates the importance of features.

[0094] For example, in a 256-dimensional feature vector set, the information gain of the alignment deviation feature is 0.8, while that of the crack width feature is 0.6. High-gain features are preferentially retained. This method ensures that subsequent analysis focuses on key features and reduces redundant computation.

[0095] For example, MinMaxScaler normalization compresses feature values ​​into the range of 0 to 1. Assuming a alignment deviation range of -3μm to 3μm, normalization maps it to 0 to 1, facilitating the unification of feature data with different dimensions. This process improves model input consistency and optimizes subsequent complexity analysis.

[0096] In one possible implementation, the complexity weight coefficient W is calculated by weighted summation of the feature importance coefficient and the normalized eigenvalues.

[0097] For example, the alignment deviation feature weight is 0.5, the crack width is 0.3, the normalized values ​​are 0.8 and 0.6 respectively, and the W value is 0.58. If W exceeds the threshold T2, for example, 0.7, then GPU cluster resources are allocated. The GPU cluster consisting of 8 NVIDIA Tesla V100s runs a PyTorch convolutional neural network to process the feature data and generate a three-dimensional complexity distribution map.

[0098] For example, the distribution map shows areas of concentrated alignment deviation and areas with high incidence of cracks, and stores them in a specified HDFS partition to facilitate subsequent optimization of ceramic stacking process parameters.

[0099] Understandably, this multi-layered processing approach, from data sharding to feature extraction, selection, normalization, and complexity analysis, forms a complete technical chain, ensuring efficient processing and high-quality analysis of ceramic laminated datasets to support process optimization needs.

[0100] A standardized ceramic stack dataset is obtained through an in-memory computing engine. Feature vectors of multi-layer ceramic stacks are calculated using sharding storage and parallel processing techniques. The decision to activate the high-performance computing resource pool is made by comparing the complexity weight coefficient with a preset threshold.

[0101] By batch reading distributed storage shards using Spark, principal component analysis is employed to generate a multi-layered ceramic stacked feature vector set, resulting in feature vector data. Based on this feature vector data, scikit-learn is used to calculate the information gain of each feature, generating a set of feature importance coefficients, thus obtaining feature weight data. The feature weight data is then combined with the feature vector data after MinMax normalization using the weighted summation formula W=Σ(ai×xi), where ai is the feature importance coefficient and xi is the normalized feature value, to calculate the complexity weight coefficient, yielding the weight coefficient value. If the weight coefficient value exceeds a preset threshold, the YARN resource manager is used to allocate GPU computing nodes to generate complexity distribution data.

[0102] Specifically, a standardized ceramic stack dataset is obtained from a multi-layer ceramic stack using the Spark in-memory computing engine. This dataset is then sharded and stored in HDFS, with three replicas created, resulting in a sharded dataset. HDFS sharding technology is used to manage the sharded dataset, and a consistent hashing algorithm is used to distribute the data across multiple DataNodes, resulting in distributed storage shards. Spark is used to batch read the distributed storage shards, and principal component analysis is employed to generate a feature vector set for the multi-layer ceramic stack, resulting in feature vector data. Based on the feature vector data, scikit-learn is used to calculate the information gain of each feature, generating a set of feature importance coefficients, resulting in feature weight data.

[0103] By combining the feature weight data with the feature vector data normalized by MinMax, a weighted summation formula W=Σ(ai×xi) is used, where ai is the feature importance coefficient and xi is the normalized feature value, to calculate the complexity weight coefficient. If the weight coefficient value exceeds a preset threshold of 0.75, the YARN resource manager allocates GPU computing nodes, and ResNet18 is used to process the feature vector data, generating a ceramic stack complexity distribution. Based on this complexity distribution data, the results are saved to a specified column family using HBase with row key hash values, yielding the final storage result.

[0104] Processing ceramic laminate datasets involves multiple technical topics, including distributed storage, feature extraction, feature selection, normalization, and complexity analysis. The following analysis, focusing on the business domain of ceramic laminate quality analysis and incorporating historical data collection and cleaning context, provides examples for each technical topic, ensuring logical rigor and mutual support.

[0105] For example, when processing standardized ceramic laminate datasets, the Apache Spark in-memory computing engine can leverage its distributed computing capabilities to efficiently load data. Spark accelerates data processing through in-memory computing, making it suitable for large-scale alignment accuracy and crack detection data in ceramic laminates.

[0106] In one possible implementation, the dataset contains 5 million records, each including micrometer-level alignment coordinates and crack depth. Spark uses the DataFrame API to perform batch reading and preprocessing of the data, such as grouping by batch number and extracting alignment deviation statistical features. This approach is suitable for rapidly processing large-scale datasets. For data sharding and storage, HDFS uses a consistent hashing algorithm to distribute data across multiple DataNodes.

[0107] For example, 5 million records are hashed and distributed across 32 shards with bitwise precision, with each shard storing approximately 156,000 records. HDFS generates three replicas to ensure high data availability, suitable for the high reliability requirements of ceramic stacked data. After sharding, the data can be quickly retrieved by timestamp, facilitating subsequent analysis.

[0108] Understandably, feature extraction generates a set of feature vectors through principal component analysis.

[0109] For example, the PCA algorithm is used to process alignment coordinates and crack depth data to generate a 64-dimensional feature vector, capturing the main quality features.

[0110] In one embodiment, the feeding system provides coordinate data with an accuracy of ±2μm. PCA analysis is used to extract the principal components of alignment deviations, forming a low-dimensional feature representation. This approach effectively reduces data dimensionality while retaining key information. In feature selection, the scikit-learn function `mutual_info_classif` calculates the information gain and generates a set of feature importance coefficients.

[0111] For example, in the 64-dimensional feature vector, the information gain of the alignment deviation feature is 0.75, and that of the crack depth feature is 0.55; features with higher gain are preferentially retained. This method focuses on key features and improves analysis efficiency.

[0112] For example, MinMax normalization maps eigenvalues ​​to the interval between 0 and 1. Assuming a alignment deviation range of -5μm to 5μm, normalization maps it to 0 to 1, unifying feature data with different dimensions. This process ensures consistency of model input. In complexity analysis, the weight coefficient W is calculated by weighted summation of the feature importance coefficients and the normalized eigenvalues.

[0113] For example, with a alignment deviation feature weight of 0.6, a crack depth of 0.4, normalized values ​​of 0.7 and 0.5 respectively, and a W value of 0.62. If W exceeds the threshold of 0.75, the YARN resource manager allocates a GPU node. ResNet18 processes the feature vector data, generates a complexity distribution map, and displays the alignment deviation and crack distribution areas.

[0114] Understandably, complexity distribution data is stored in a specified column family via HBase using row key hash values.

[0115] For example, the distribution chart is stored by batch number, the row key is a timestamp, and the column family stores the complexity distribution characteristics, facilitating quick retrieval. This storage method supports subsequent process optimization analysis.

[0116] In one possible implementation, from the core solution to the extended solution, the data processing link goes from fragmented storage to feature extraction, selection, normalization, and then to complexity analysis and storage, forming a complete technical process to support the needs of ceramic laminate quality analysis.

[0117] Step S103, 3: Based on the ceramic stack complexity analysis results, the task allocation ratio of computing nodes is dynamically adjusted through an adaptive load balancing algorithm. The support vector machine algorithm is used to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, generating a load prediction value R, in units of tasks per second. Based on R and the current system utilization rate U, in the range [0,1], the expansion factor S = R × (1 + U) / 1000 is calculated, where 1000 is the preset baseline load value, in units of tasks per second. If S exceeds the preset threshold T3 = 1.2, the elastic expansion mechanism is triggered to generate an optimized ceramic stack production resource configuration state.

[0118] The weighted round-robin algorithm is used to calculate the assigned weights of each computing node, with the weight formula being 1 / (1 + the current load rate of the node), resulting in a node task allocation table. Real-time temperature and humidity data are obtained from environmental temperature and humidity sensors, and equipment fault codes are parsed from the cutting device logs. If the temperature and humidity exceed a preset range, a compensation coefficient is generated; if a fault code appears three times consecutively, an abnormal node is marked. The compensation coefficient, the fault mark, and the node CPU utilization rate are combined into an input vector, and a support vector machine algorithm is used to train a load prediction model, outputting the load prediction value for the next 5 minutes.

[0119] Specifically, the task allocation ratio is obtained from the ceramic stack complexity analysis results. A weighted round-robin algorithm is used to calculate the allocation weight of each computing node, with the weight formula being 1 / (1 + current node load rate), resulting in a node task allocation table. Based on this table, real-time temperature and humidity data are obtained from environmental temperature and humidity sensors, and equipment fault codes are parsed from the cutting device logs. When the temperature and humidity exceed a preset range, a compensation coefficient is generated. When a fault code appears three times consecutively, an abnormal node is marked. The compensation coefficient, fault markers, and node CPU utilization are combined into an input vector. A support vector machine algorithm is used to train a load prediction model, outputting the load prediction value for the next 5 minutes. The load prediction value and the real-time CPU utilization are weighted and summed at a ratio of 0.6:0.4 to obtain the expansion factor. If the expansion factor exceeds 1.2, the number of new nodes is ceil(current node count × expansion factor / 2). Computing resources are allocated from the resource pool, and the IP address and memory capacity of the new nodes are recorded in the resource configuration status table.

[0120] The task scheduling strategy of the ceramic laminated production system is adjusted based on the resource configuration status table to generate an optimized task allocation scheme. The new scheme is then input into a weighted round-robin algorithm to update node weights, generating a new node task allocation table. The production system's operating status is monitored using this new node task allocation table to obtain real-time CPU utilization and fault code data. Combined with temperature and humidity compensation coefficients, this data is input into a linear regression algorithm to obtain updated load prediction values.

[0121] For example, in a ceramic laminated production system, when calculating the allocation weights of each computing node using a weighted round-robin algorithm, task allocation can be dynamically adjusted based on the node's current load rate. The weight formula 1 / (1 + node's current load rate) ensures that nodes with higher loads are allocated fewer tasks. Assuming the system has 10 computing nodes, a node with a current CPU utilization of 80% has a weight of 1 / (1 + 0.8) = 0.56, while a node with a CPU utilization of 20% has a weight of 0.83. Nodes with higher weights are assigned tasks first, generating a node task allocation table that records each node's IP address and task load. This method achieves dynamic task balancing and improves resource utilization efficiency.

[0122] In one possible implementation, when acquiring real-time data from an ambient temperature and humidity sensor, a DHT22 sensor can be used to monitor the temperature and humidity in the production workshop. Assuming a preset temperature range of 20-25°C and humidity of 40-60%, if the real-time data is 27°C and 65%, a compensation coefficient is generated.

[0123] For example, the compensation factor is 1.1 when the temperature exceeds 2°C, and 1.05 when the humidity exceeds 5%. The compensation factor is used to adjust the input to the load forecasting model to ensure that the impact of environmental factors on computing resource requirements is fully considered.

[0124] Specifically, when parsing equipment fault codes from the cutting device logs, fault information can be extracted using log analysis tools. For example, if the logs show that a cutting device displays an "E101" fault code three times consecutively, indicating tool wear, then that node is marked as abnormal. The task priority of the abnormal node is reduced, and the task is reassigned to other nodes. This mechanism quickly identifies equipment problems and ensures production continuity.

[0125] For example, a three-dimensional vector can be constructed by combining compensation coefficients, fault markers, and CPU utilization as input vectors.

[0126] For example, if a node has a compensation coefficient of 1.1, a fault flag of 0 (no fault), and a CPU utilization of 70%, then the input vector is [1.1, 0, 0.7]. The Support Vector Machine (SVM) algorithm is trained based on historical data to predict the load value for the next 5 minutes. The predicted value is combined with the real-time CPU utilization (weighted at 0.6:0.4) to calculate the scaling factor. Assuming the predicted load is 85% and the real-time utilization is 75%, the scaling factor is 0.6 × 85% + 0.4 × 75% = 0.81. If the scaling factor exceeds 1.2, for example, 1.3, then the number of new nodes is ceil(10 × 1.3 / 2) = 7. New nodes are allocated from the resource pool, and their IP address and memory capacity (e.g., 16GB) are recorded in the resource configuration status table.

[0127] In one possible implementation, when adjusting the task scheduling strategy based on the resource configuration status table, production tasks can be reallocated through the task scheduler.

[0128] For example, after adding 7 nodes, high-load tasks are prioritized for allocation to the new nodes, generating an optimized task allocation scheme. This scheme is then input into a weighted round-robin algorithm to update node weights and generate a new task allocation table. This new table is used to monitor system operating status, combining real-time CPU utilization and temperature / humidity compensation coefficients to predict updated load values ​​using a linear regression algorithm.

[0129] For example, if a node's real-time CPU utilization is 90%, the compensation coefficient is 1.2, and the predicted load is 92%, this will guide subsequent resource adjustments.

[0130] Understandably, the above method forms a complete technical chain from weight calculation, environmental data collection, fault detection to load prediction and resource expansion, ensuring the efficient operation of the ceramic laminated production system and optimizing the dynamics and stability of task allocation.

[0131] Based on the complexity analysis results of ceramic stacking, an adaptive load balancing algorithm is adopted to obtain an optimized load allocation scheme by dynamically adjusting the task allocation ratio of computing nodes. Based on the environmental temperature and humidity control data and the operating status of the high-speed cutting device, a support vector machine algorithm is used to predict the load trend of the ceramic stacking production system and obtain the load prediction value. Based on the load prediction value and the current system utilization rate, the expansion factor is calculated to determine whether it exceeds the preset threshold. If it exceeds the threshold, the elastic expansion mechanism is triggered to determine the optimized ceramic stacking production resource allocation status.

[0132] Historical production data is obtained from the ceramic laminate production database, and the number of layers, pattern type, and sintering temperature are extracted as features. A random forest regression model is used to output a ceramic laminate complexity score. Based on the complexity score and a preset task time comparison table, the total computational requirement for each production task is calculated, and an initial allocation ratio table is generated according to the task type proportion. Based on the initial allocation ratio table, a weighted round-robin algorithm is used to dynamically allocate computing node tasks, updating the node weights every 5 minutes. When the weights are updated, CPU utilization and memory usage are obtained from the computing node monitoring service; if the current node load exceeds 80%, its weight is reduced by 10%. Real-time data is obtained from temperature and humidity sensors at a sampling frequency of 1 time / second, synchronized with the data in the PLC status register of the cutting device. The average temperature and humidity, cutting motor current, and tool vibration amplitude are combined into a 16-dimensional feature vector, which is input into a pre-trained scikit-learn SVC model, outputting the system load prediction value R (tasks / second) for the next 15 minutes.

[0133] The current utilization rate U (actual percentage value) of the compute node cluster is read, and combined with the preset baseline load value B (set according to historical peak load), the expansion factor S = R × (1 + U / 100) / B is calculated. When S exceeds the threshold T = 1.2, the Kubernetes cluster management API is called to add 2 compute nodes and generate a new resource configuration table. Based on the latest resource configuration table, the weighted round-robin algorithm is re-run to generate a node task allocation scheme, and the updated task instructions are issued to the execution units of each compute node.

[0134] Specifically, the ceramic laminated production database stores a large amount of historical production data, including key features such as the number of layers, pattern type, and sintering temperature, which can be used to analyze production complexity.

[0135] For example, data on a batch of ceramic laminates is extracted from a database. The laminates consist of 32 layers with complex geometric patterns, and the sintering temperature is 1200°C. A random forest regression model is used to process these features. The model is trained on historical data and outputs a complexity score of 8.5 (out of 10). Referring to a pre-defined task time table, a score of 8.5 corresponds to a task time of approximately 2 hours, with a calculated total requirement of 5000 task units. An initial allocation ratio table is generated for different task types, such as printing, cutting, and sintering, assuming printing accounts for 40%, cutting for 35%, and sintering for 25%. This allocation method ensures that tasks are allocated on demand, balancing the resource needs of each production stage.

[0136] In one possible implementation, the weighted round-robin algorithm dynamically allocates tasks based on an initial allocation ratio table.

[0137] For example, the system has 8 compute nodes, and the initial allocation table shows that pruning tasks account for 35%. Every 5 minutes, the CPU utilization and memory usage of each node are retrieved from the monitoring service. Assuming a node has a CPU utilization of 85% and a memory usage of 70%, its weight is reduced by 10%, from 1.0 to 0.9. Nodes with lower weights have lower priority, and more tasks are allocated to other low-load nodes. This dynamic adjustment method optimizes resource allocation efficiency.

[0138] Specifically, data acquisition from temperature and humidity sensors is crucial for load forecasting.

[0139] For example, using an AM2302 sensor to collect data at a frequency of 1 time per second, at a certain moment the workshop temperature is 26°C and the humidity is 62%, exceeding the preset range (20-25°C, 40-60%). Synchronized with the data in the PLC status register of the cutting device, the motor current is obtained as 5A and the tool vibration amplitude as 0.2mm, combined into a 16-dimensional feature vector. Inputted into a trained SVC model, the predicted load value R for the next 15 minutes is 600 tasks / second. This high-frequency data acquisition and multi-dimensional feature combination improves prediction accuracy.

[0140] For example, when calculating the scaling factor, assuming the current system utilization U is 75%, the preset baseline load B is 1000 tasks / second, and the predicted load R is 600 tasks / second, the scaling factor S = 600 × (1 + 0.75) / 1000 = 1.05. If S does not exceed the threshold T = 1.2, scaling is not performed. When S reaches 1.3, the Kubernetes API is called to add two nodes, generating a resource configuration table that records the new node IPs and 16GB of memory capacity. After the new nodes are added, the weighted round-robin algorithm is run again to generate a new task allocation scheme.

[0141] For example, high-load pruning tasks are preferentially assigned to new nodes, reducing the pressure on older nodes. This mechanism responds quickly to load changes.

[0142] In one possible implementation, after the task instruction is issued to the execution unit of the computing node, the system monitors the execution status in real time.

[0143] For example, the new allocation plan distributed 40% of the cut-off tasks to new nodes, and the execution unit reported a task completion rate of 95%, indicating that the allocation plan was reasonable. Monitoring data, combined with average temperature and humidity and motor status, was input into a linear regression model to predict the load value for the next cycle, guiding subsequent resource adjustments. This closed-loop mechanism ensures the continuity of production tasks and a dynamic balance in resource utilization.

[0144] Step S104, 4: Through remote control data encryption protocol and real-time command transmission function, based on the optimized ceramic laminate production resource configuration status and ceramic laminate complexity analysis results, the functional modules of hot pressing molding process and high-speed cutting device are decoupled through microservice architecture. Application programming interface gateway is used to uniformly manage data interaction and user permission verification for multi-device collaborative management. Asynchronous production requests are processed through message queue. If the service response time exceeds the delay threshold T4 determined by the ceramic laminate complexity analysis results, within the range of [100, 300] milliseconds, the service degradation mechanism is activated to generate a highly available ceramic laminate production platform.

[0145] The configuration status of ceramic laminate production resources is obtained through AES-256-CBC encryption, and the configuration status is parsed to obtain a production task allocation table. The task instructions from the production task allocation table are distributed to the hot pressing module and the cutting device module using a RabbitMQ message queue, and the execution status of these modules is obtained. The real-time production request sequence of the module execution status is processed through a Kafka message queue, and the processing time of each module's request is statistically analyzed. If the processing time exceeds a preset latency threshold T4, it is marked as a high-latency module, resulting in a list of high-latency modules. A weighted round-robin algorithm is used to adjust the task proportion of the high-latency modules, generating an optimized task allocation table.

[0146] Specifically, the configuration status of ceramic laminate production resources, encrypted with AES-256-CBC, is obtained from the data encryption protocol and transmitted to the application programming interface gateway via a TLS 1.3 secure channel. The configuration status is parsed to obtain the production task allocation table. The hot-pressing module and the cutting device module are decoupled using a microservice architecture. Task instructions for each module are extracted from the production task allocation table and distributed to the corresponding modules using a RabbitMQ message queue, obtaining the module execution status. The module execution status triggers the interface gateway to collect data interaction logs. Combined with the permission verification results based on a MAC address whitelist, legitimate device records are filtered to obtain the real-time production request sequence. The real-time production request sequence is processed through a Kafka message queue. The processing time of each module's request is statistically analyzed. If the processing time exceeds a preset latency threshold T4, it is marked as a high-latency module, and a list of high-latency modules is obtained. A weighted round-robin algorithm is used to adjust the task ratio of high-latency modules, generating an optimized task allocation table. The module task instructions are updated from the optimized task allocation table and redistributed via RabbitMQ, obtaining the updated module execution status. The updated module execution status is managed and monitored through the interface gateway, and production platform operation logs are generated using AES-256-CBC encryption.

[0147] For example, in a ceramic laminated production system, the AES-256-CBC encryption protocol is used to ensure the security of resource configuration status. AES-256-CBC is a symmetric encryption algorithm that uses a 256-bit key and processes configuration status data in blocks using block encryption. Each block of data is combined with an initialization vector to enhance encryption strength.

[0148] For example, the production task allocation table contains node IP addresses, task quantity, and priority. After encryption, it generates a ciphertext file of approximately 2MB in size, which is transmitted to the application programming interface gateway via a TLS 1.3 secure channel. TLS 1.3 uses elliptic curve cryptography to ensure that the data is not intercepted during transmission. After receiving the data, the gateway decrypts and parses it to extract the task instructions for the hot pressing module in the task allocation table, such as "Node 192.168.1.10 executes 1000 hot pressing tasks".

[0149] In one possible implementation, the microservice architecture decouples the hot-pressing module and the cutting device module, deploying them in independent containers using Docker containerization technology. The hot-pressing module handles temperature control tasks, while the cutting device module manages cutting accuracy. The task allocation table distributes tasks via a RabbitMQ message queue, with queue configurations persistently stored to ensure no task instructions are lost.

[0150] For example, the hot pressing module receives the instruction "Temperature set to 230°C, for 30 minutes", and the cutting module receives the instruction "Cutting speed 500mm / s". The module execution status is fed back through the message queue, such as "Hot pressing completion rate 95%".

[0151] Specifically, the interface gateway manages and collects interaction logs, combining them with a MAC address whitelist to verify device legitimacy. The whitelist stores the MAC addresses of legitimate devices, such as "00:1A:2B:3C:4D:5E". If a device with an unknown MAC address is detected, it is recorded as illegitimate, and its task requests are blocked. Production request sequences generated by legitimate devices are processed through a Kafka message queue, with Kafka partitions storing request data from different modules.

[0152] For example, the hot-press module partition records 1000 requests, and the trimming module partition records 800 requests. The request processing time is statistically analyzed. If the average processing time of the hot-press module is 2 seconds, exceeding the preset latency threshold T4 = 1.5 seconds, it is marked as a high-latency module.

[0153] For example, a weighted round-robin algorithm adjusts the proportion of high-latency module tasks, reducing the hot-press module's task allocation to 30%, and allocating more tasks to the trimming module. The optimized task allocation table is regenerated, containing updated task instructions, such as "hot-press module task volume reduced to 800 pieces." These are redistributed via RabbitMQ, and the hot-press module adjusts its running parameters upon receiving the new instructions. The interface gateway monitors the updated execution status, such as "hot-press module completion rate increased to 98%", and generates running logs using AES-256-CBC encryption. These logs record module running time, task volume, etc., and are stored in a distributed database for subsequent auditing.

[0154] In one possible implementation, the list of high-latency modules is updated periodically, and resource allocation strategies are dynamically adjusted in conjunction with real-time production request sequence analysis.

[0155] For example, the processing time of the trimming module increased to 1.8 seconds due to equipment aging, triggering a task ratio adjustment to optimize the overall system response speed. Encrypted logs are transmitted to the management platform via TLS 1.3 to ensure data integrity.

[0156] Based on the analysis of ceramic stack complexity, a latency threshold T4 is determined. If the service response time exceeds this threshold, a service degradation mechanism is initiated. By decoupling the functional modules of the hot pressing process and the high-speed cutting device through a microservice architecture, and by adopting a remote control data encryption protocol and real-time command transmission function, a highly available ceramic stack production platform is obtained.

[0157] The number of layers and sintering temperature parameters are extracted from the ceramic stack complexity analysis results and input into a linear regression model to obtain the delay threshold T4. Based on the high-latency module list, degradation weights are calculated inversely proportional to the delay factor, generating a JSON-formatted task allocation table containing module names and weight fields. Instructions for the hot-pressing and high-speed cutting device modules are extracted from the task allocation table via the gRPC protocol and distributed to the corresponding Kafka message queues. Based on the deviation of the abnormal module's indicators, its weight coefficient in the new allocation table is dynamically adjusted, and the updated task allocation table is distributed via the gRPC protocol to obtain the stable state determination result.

[0158] Specifically, the number of layers and sintering temperature parameters are extracted from the ceramic layer complexity analysis results and input into a linear regression model to calculate the latency threshold T4. HTTP request response times for each module are collected using Prometheus, and modules exceeding T4 are marked as high-latency modules and stored in a Redis list. Based on the list of high-latency modules, degradation weights are calculated inversely proportional to the latency, generating a JSON-formatted task allocation table containing module names and weight fields. Instructions for the hot pressing and high-speed cutting device modules are extracted from the allocation table via the gRPC protocol and distributed to the corresponding Kafka message queues.

[0159] The status data returned by the modules is transmitted to the central control unit via TLS 1.3 encryption and used to generate log files using AES-256 encryption. CPU utilization and memory usage data are parsed from the logs and compared with preset thresholds to obtain a list of abnormal modules. Based on the deviation of the abnormal modules' metrics, their weight coefficients in the new allocation table are dynamically adjusted. The updated allocation table is distributed via gRPC, and after collecting encrypted status data, the weighted average of the error rate and latency rate over 5 minutes is calculated. If it is below 0.1, the platform is considered to have entered a stable state.

[0160] The complexity analysis and resource optimization of ceramic laminated production systems involve multi-dimensional technical implementation. The following analysis and examples are based on key themes, focusing on the field of ceramic laminated production, ensuring that the logic is rigorous and the content is closely related.

[0161] For example, when analyzing the complexity of ceramic stacks and extracting parameters such as the number of layers and sintering temperature, the number of layers reflects the complexity of the stack structure, while the sintering temperature determines the process stability. Assuming the analysis shows that a batch of ceramics has 10 layers and a sintering temperature of 1200°C, a delay threshold T4 is calculated using a linear regression model. The model is input with the number of layers and temperature, and combined with historical data, such as a T4 of 150 milliseconds for a 5-layer stack and 250 milliseconds for a 15-layer stack, it is deduced that the T4 for a 10-layer stack is approximately 200 milliseconds. This method ensures a dynamic match between the delay threshold and the process complexity.

[0162] In one possible implementation, Prometheus collects the HTTP request response time of the modules. For example, if the hot-press module's response time is 250 milliseconds, exceeding the T4 threshold of 200 milliseconds, it is marked as a high-latency module and stored in a Redis list. Redis stores this as key-value pairs, such as the key "high_latency_modules" corresponding to the value "hot_press_module:250ms". Compared to traditional databases, Redis's in-memory storage accelerates data access, making it suitable for real-time marking of high-latency modules.

[0163] Specifically, the degradation weight is calculated inversely proportional to the latency factor. The hot press module has a latency of 250 milliseconds, exceeding T4 by approximately 1.25 times, and its weight is set to 0.8; the trimming module has a response time of 180 milliseconds, which does not exceed the threshold, and its weight is 1.0. A JSON format task allocation table is generated, containing fields such as "module_name:hot_press,weight:0.8". The workload of modules with lower weights is reduced to ensure that system resources are tilted towards low-latency modules. The gRPC protocol is highly efficient in distributing task instructions and is suitable for scenarios with high real-time requirements.

[0164] For example, the hot press module retrieves the instruction "Temperature set to 220°C for 25 minutes" from the allocation table and transmits it to the Kafka queue via gRPC. Kafka uses partitioned storage; for example, the hot press module partition stores 500 instructions, and the pruning module partition stores 300 instructions, ensuring orderly and traceable instruction distribution. Status data is transmitted to the central control unit using TLS 1.3 encryption, and log files are generated using AES-256 encryption.

[0165] For example, the logs show that the hot-press module has a CPU utilization of 80% and memory usage of 2GB. The preset thresholds are 85% CPU and 2.5GB memory. Since the hot-press module's CPU usage is close to the threshold, it is marked as an abnormal module. The weight coefficient of the abnormal module is adjusted to 0.7, and after updating the allocation table, tasks are distributed via gRPC, reducing the number of hot-press module tasks to 600.

[0166] For example, by collecting error rate and latency rate data over a 5-minute period, assuming an error rate of 0.03 and a latency rate of 0.05, the weighted average is 0.04. A value below 0.1 indicates the platform is stable. This monitoring mechanism dynamically optimizes resource allocation through real-time data analysis, ensuring production efficiency.

[0167] In one possible implementation, the list of abnormal modules is updated periodically, and the weights are adjusted based on the deviation of CPU and memory metrics.

[0168] For example, due to equipment aging, the memory usage of the trimming module increased to 2.8GB, the trigger weight was reduced to 0.6, the task load was reduced to 400 pieces, and priority was given to assigning tasks to modules with better performance. This dynamic adjustment mechanism effectively balances the system load.

[0169] Step S105,5: The operating status data of the high-availability ceramic stack production platform and the production indicators of multi-layer ceramic stacks are collected through the real-time monitoring module and status feedback mechanism. The time series analysis algorithm is used to predict the trend and detect anomalies in the central processing unit utilization, memory occupancy and environmental temperature and humidity control data, and generate an automated operation and maintenance instruction set, including parameter adjustment and resource reallocation. If any performance indicator deviates from the normal range by more than the preset tolerance T5=10%, the automatic optimization program is triggered to adjust the ceramic stack production parameters. Stable digital service capabilities for ceramic capacitor stacks are generated through remote fault diagnosis and log auditing functions.

[0170] The real-time monitoring module collects CPU usage, memory occupancy, and ambient temperature and humidity data from the ceramic laminate production platform and writes them to the InfluxDB database at minute intervals to generate a structured status dataset. The ARIMA algorithm is used to perform 7-day rolling training on this structured status dataset to obtain a trend prediction model and output a prediction dataset. If any indicator in the prediction dataset exceeds a dynamic threshold calculated based on the 3σ principle, the PID controller is triggered to calculate the ceramic laminate production parameter adjustment values, generating a parameter adjustment instruction set containing temperature compensation values ​​and pressure correction values. This parameter adjustment instruction set is distributed to the temperature control execution module and the pressure regulation module via the MQTT protocol to obtain the updated operating status dataset.

[0171] Specifically, the real-time monitoring module collects data on central processing unit (CPU) usage, memory occupancy, and ambient temperature and humidity from the ceramic laminated production platform, writing this data to the InfluxDB database at minute intervals to form a structured state dataset. The ARIMA algorithm is used for 7-day rolling training of the structured state dataset to generate a trend prediction model and output a predicted data set. When any indicator in the predicted data set exceeds a dynamic threshold calculated based on the 3σ principle, the PID controller is triggered to calculate the adjustment values ​​for the ceramic laminated production parameters, generating a parameter adjustment instruction set containing temperature compensation values ​​and pressure correction values. The remote fault diagnosis module reads the compensation values ​​from the parameter adjustment instruction set and, combined with the measured kiln temperature values ​​from the current operating status data, generates an adjusted set of ceramic laminated production parameters.

[0172] The optimized parameter set is distributed to the temperature control execution module and pressure regulation module of the production platform via the MQTT protocol. After execution, the updated operating status dataset is returned. The log auditing module retrieves 30 days of historical operating status data from InfluxDB, compares it with the current updated dataset, and generates a digital service instruction set containing temperature calibration instructions and pressure maintenance instructions. The Kong gateway extracts key instructions with a priority greater than 90 from the instruction set, verifies them via JWT, and sends them to the production platform control terminal to obtain platform operating logs and update stable operating status data.

[0173] For example, in a ceramic laminate production platform, the real-time monitoring module collects data on CPU usage, memory occupancy, and ambient temperature and humidity using sensors. This data is written to the InfluxDB database every minute, forming a structured state dataset. As a time-series database, InfluxDB is suitable for storing high-frequency time-series data, ensuring that the data is stored in an ordered manner according to timestamps.

[0174] For example, the CPU utilization rate of a certain production node is recorded as 75%, memory usage rate as 60%, ambient temperature as 28°C, and humidity as 45%. This data is stored in JSON format for easy subsequent analysis.

[0175] It should be noted that the real-time monitoring module communicates with the sensors via the Modbus protocol to ensure the stability and real-time nature of data acquisition.

[0176] In one possible implementation, the ARIMA algorithm is trained on a structured state dataset over a 7-day rolling period to generate a trend prediction model. ARIMA predicts changes in indicators over the next 24 hours by analyzing trends and seasonality in historical data.

[0177] For example, the model predicts that the memory utilization rate of a certain node may rise to 85% in the next 6 hours, exceeding the normal range. Based on the 3σ principle, the system calculates a dynamic threshold. Assuming the mean memory utilization rate is 60% and the standard deviation is 10%, the threshold is 90%. When the predicted value exceeds the threshold, the PID controller is activated to calculate the temperature compensation value and the pressure correction value.

[0178] For example, the controller generates instructions such as: decrease the temperature by 2°C and increase the pressure by 0.5 MPa, forming a set of parameter adjustment instructions.

[0179] Specifically, the remote fault diagnosis module reads the compensation values ​​from the instruction set and combines them with the measured kiln temperature (e.g., 230°C) to generate an optimized parameter set, such as an adjusted temperature of 228°C and a pressure of 5.5 MPa. These parameters are distributed to the temperature control execution module and the pressure regulation module via the MQTT protocol. MQTT, with its lightweight and low-bandwidth characteristics, is suitable for rapid instruction transmission in production environments.

[0180] For example, after receiving the command "Temperature set to 228°C", the temperature control module adjusts the power of the heating element, while the pressure module regulates the hydraulic system. After execution, the module returns to the operating status, such as "Temperature stabilized at 228°C, pressure reached 5.5MPa".

[0181] For example, the log auditing module extracts 30 days of historical data from InfluxDB, compares it with the current operating status, and generates a set of digital service instructions. Assuming historical data shows a temperature fluctuation range of ±3°C, and current data shows ±1°C, the auditing module generates a "temperature calibration" instruction to ensure long-term stability. The Kong gateway extracts instructions with a priority greater than 90, such as "emergency temperature calibration," and issues them after verifying the device's identity via JWT. JWT uses the HMAC-SHA256 algorithm to verify the legitimacy of the control terminal.

[0182] For example, if the terminal MAC address is 00:1A:2B:3C:4D:5E, after successful verification, the terminal receives instructions and returns the operation log, updating the stable operation status data.

[0183] In one possible implementation, the extension scheme can further optimize instruction generation by analyzing abnormal patterns in historical data.

[0184] For example, if the audit module detects frequent pressure fluctuations at a certain node, it generates a "pressure maintenance" command, suggesting that the hydraulic valve status be checked. This multi-faceted analysis, from real-time monitoring to predictive adjustments, command distribution, and audit optimization, forms a complete closed loop, ensuring the efficient operation of the production platform.

[0185] Based on the operational status data of the high-availability ceramic stack production platform collected by the real-time monitoring module, the utilization rate of the central processing unit is predicted by the time series analysis algorithm. If any performance indicator deviates from the normal range and exceeds the preset tolerance, the automatic optimization program is triggered to adjust the ceramic stack production parameters, thereby obtaining a stable digital service capability for ceramic capacitor stacks.

[0186] The real-time monitoring module collects CPU utilization data and writes it to the InfluxDB time-series database. It then extracts the most recent 24-hour data from this database and uses the Prophet algorithm to predict the utilization trend for the next hour. If the predicted value exceeds a preset threshold of 85%, a decision tree-based rule engine is triggered to calculate the temperature adjustment and pressure correction values ​​for the ceramic laminate production parameters, and writes them to the RabbitMQ message queue. The module also extracts historical operating status data from the past 30 days from InfluxDB, merges it with the latest collected CPU utilization data, uses a K-means clustering algorithm to match similar operating conditions, generates a set of digital service instructions, and transmits them to the control terminal via the Modbus TCP protocol to update the production parameters.

[0187] Specifically, the real-time monitoring module collects CPU utilization data from the high-availability ceramic laminate production platform and writes it to the InfluxDB time-series database. It extracts CPU utilization data for the most recent 24 hours from InfluxDB and uses the Prophet algorithm to predict the utilization trend for the next hour. If the predicted value exceeds a preset threshold of 85%, a decision tree-based rule engine is triggered to calculate adjustment values ​​for the ceramic laminate production parameters. The rule engine outputs temperature adjustment values ​​and pressure correction values, writing them to the RabbitMQ message queue. The temperature control module retrieves the temperature adjustment value from RabbitMQ, and the pressure adjustment module retrieves the pressure correction value, executing parameter updates accordingly.

[0188] The updated CPU utilization data is collected by the real-time monitoring module and rewritten into InfluxDB. Historical operating status data from the past 30 days is extracted from InfluxDB and merged with the latest CPU utilization data. A K-means clustering algorithm is then used to match similar operating conditions. Based on the clustering results, a set of digital service instructions containing optimal parameters is generated. This set of digital service instructions is transmitted to the production platform control terminal via the Modbus TCP protocol. Upon receiving the instructions, the control terminal updates the ceramic laminate production parameters. The real-time monitoring module continuously collects the updated CPU utilization data, forming a closed-loop control process.

[0189] The real-time monitoring module continuously collects CPU utilization data from the high-availability ceramic stack production platform through sensors and writes it into the InfluxDB time-series database.

[0190] For example, the CPU utilization of a production node is recorded every minute over the past 24 hours, with data points including 70%, 72%, 75%, etc., forming an ordered time series. InfluxDB, with its high throughput and timestamped indexing features, ensures efficient data storage and fast retrieval. The data acquisition process is implemented via the ModbusTCP protocol, ensuring stable communication between the sensors and the monitoring module, with data transmission latency below 50 milliseconds.

[0191] It should be noted that the ModbusTCP protocol transmits data over a TCP / IP network, making it suitable for highly reliable data exchange in industrial environments. CPU utilization data for the most recent 24 hours is extracted from InfluxDB, and the Prophet algorithm is used for prediction.

[0192] For example, Prophet analyzes periodic fluctuations in historical data to predict that usage may rise from 75% to 86% within the next hour. The Prophet algorithm generates a smooth prediction curve by decomposing trends, seasonality, and noise. If the predicted value exceeds a preset threshold of 85%, a decision tree-based rule engine is triggered. The rule engine generates parameter adjustment values ​​based on historical data and current conditions.

[0193] For example, the engine infers that the temperature needs to be lowered by 1.5°C and the pressure needs to be increased by 0.3 MPa to reduce the CPU load. These adjustments are written to the RabbitMQ message queue. RabbitMQ, with its high concurrency capabilities, ensures rapid command distribution.

[0194] For example, the queue stores the commands "temperature set to 27.5°C" and "pressure set to 5.3MPa", which are then sent to the temperature control module and the pressure regulation module, respectively. After obtaining the temperature regulation value from RabbitMQ, the temperature control module adjusts the power of the heating element.

[0195] For example, if the current kiln temperature is 230°C, it will be adjusted to 228.5°C upon receiving the command. The pressure regulation module will then adjust the hydraulic system to 5.3 MPa according to the command. After execution, the real-time monitoring module will collect updated central processing unit (CPU) utilization data, such as a drop to 78%, and rewrite it into InfluxDB, forming a feedback loop.

[0196] It should be noted that this closed-loop control reduces the risk of system overload through rapid response. Historical data from the past 30 days is extracted from InfluxDB, merged with the latest data, and K-means clustering algorithm is used to match similar operating conditions.

[0197] For example, the algorithm categorizes data into three operating conditions: normal, high load, and abnormal. The current utilization rate of 78% is classified as normal, matching historical data records of 228°C temperature and 5.2 MPa pressure. Based on the clustering results, a set of digital service instructions is generated, such as "maintain current parameters" or "check cooling system." These instructions are transmitted to the control terminal via the Modbus TCP protocol.

[0198] For example, after receiving the "maintain parameters" command, the terminal retains the existing settings and returns a status log.

[0199] In one possible implementation, the extended scheme can generate preventative instructions by analyzing abnormal operating conditions in the clustering results.

[0200] For example, if historical data reveals significant temperature fluctuations at a certain node under high load conditions, a "check temperature control sensor" command is generated. This multi-dimensional analysis, from real-time monitoring to predictive adjustments, command distribution, and operating condition matching, forms a complete closed loop, ensuring the stable operation of the production platform.

[0201] Example 2

[0202] This embodiment discloses an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the operation mode of the remote control method for a ceramic capacitor stacking machine described above.

[0203] Since the electronic device described in this embodiment is the electronic device used to implement the remote control method for a ceramic capacitor stacking machine in this application embodiment, those skilled in the art can understand the specific implementation method and various variations of the electronic device in this embodiment based on the remote control method for a ceramic capacitor stacking machine described in this application embodiment. Therefore, how the electronic device implements the method in this application embodiment will not be described in detail here. Any electronic device used by those skilled in the art to implement the remote control method for a ceramic capacitor stacking machine in this application embodiment falls within the scope of protection of this application.

[0204] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters and thresholds in the formulas are set by those skilled in the art according to the actual situation.

[0205] The above description is merely a preferred embodiment of the present invention, and the scope of protection of the present invention is not limited to the above embodiments. All technical solutions falling within the scope of the present invention's concept are within the scope of protection of the present invention. It should be noted that for users of ordinary technical skills, any improvements and modifications made without departing from the principles of the present invention should also be considered within the scope of protection of the present invention.

Claims

1. A remote control method for a ceramic capacitor stacking machine, characterized in that, include: Micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process are obtained from the automated feeding system and defect detection module of the ceramic capacitor stacking machine through a distributed data acquisition interface. Data cleaning algorithms are used to remove redundant records and outliers. The dataset is verified based on the following evaluation criteria: completeness (missing rate is lower than expected), consistency (format uniformity rate is higher than expected), and accuracy (error rate is lower than expected). If the overall data quality score is lower than the preset threshold, the data repair mechanism is triggered to generate a standardized ceramic stacked dataset. The standardized ceramic stack dataset is segmented and processed in parallel using an in-memory computing engine. The ceramic stack complexity weight coefficient W is calculated based on the feature vectors of the multi-layer ceramic stack. If W exceeds a preset threshold, a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage is activated to generate ceramic stack complexity analysis results. Based on the analysis results of ceramic stack complexity, the task allocation ratio of computing nodes is dynamically adjusted by an adaptive load balancing algorithm. The support vector machine algorithm is used to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, and the load prediction value R is generated in units of tasks per second. Based on R and the current system utilization rate U, the expansion factor S is calculated. If S exceeds the preset threshold, the elastic expansion mechanism is triggered to generate an optimized ceramic laminate production resource allocation state.

2. The remote control method for a ceramic capacitor stacking machine according to claim 1, characterized in that, The acquisition of micron-level alignment accuracy data and crack / void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine via a distributed data acquisition interface specifically includes: The alignment accuracy data is obtained from the feeding system of the ceramic capacitor stacking machine via the OPCUA protocol, and the crack and void data are obtained from the defect detection module. The two data are then combined to generate the original dataset. The Pandas drop_duplicates function was used to remove duplicate records from the original dataset, and the quantile function was used to remove outliers outside the quantile range, generating a cleaned dataset. If the missing rate of the cleaned dataset is higher than a preset threshold, the missing values ​​are filled in using linear interpolation to generate a complete dataset. Based on pre-established format rules, verify the consistency of field types and units in the completed dataset to determine the format consistency rate.

3. The remote control method for a ceramic capacitor stacking machine according to claim 2, characterized in that, The specific steps of using a memory computing engine to perform fragmented storage and parallel processing of the standardized ceramic stacked dataset include: The Apache Spark in-memory computing framework was used to process the standardized ceramic stack dataset; The data output by Spark is sharded using consistent hashing via the libketama library and stored in A_O data shards of the HDFS distributed file system; Based on the piecewise distribution structure, A_R computing nodes are started using the MPI parallel framework. Each node calls the SIFT algorithm of OpenCV to extract micron-level alignment coordinate features and calls the ResNet50 pre-trained model to extract crack and void probability features, generating a 256-dimensional feature vector set. Input the feature vector set into the scikit-learn's mutual_info_classif function to calculate the information gain of each feature and generate a set of feature importance coefficients; The MinMaxScaler is used to perform linear normalization on the feature vector set, compressing all feature values ​​to the interval between 0 and 1, and generating a normalized feature value set.

4. The remote control method for a ceramic capacitor stacking machine according to claim 3, characterized in that, The dynamic adjustment of task allocation ratios for computing nodes using an adaptive load balancing algorithm specifically includes: The weights of each computing node are calculated using a weighted round-robin algorithm to obtain the node task allocation table. Real-time temperature and humidity data are obtained from the ambient temperature and humidity sensor. Equipment fault codes are parsed from the cutting device log. If the temperature and humidity exceed the preset range, a compensation coefficient is generated. If the fault code appears N times in a row, an abnormal node is marked. The compensation coefficient, the fault code, and the node CPU utilization rate are combined into an input vector. A support vector machine algorithm is used to train the load prediction model, and the load prediction value for the next M minutes is output.

5. The remote control method for a ceramic capacitor stacking machine according to claim 4, characterized in that, The configuration status of ceramic laminate production resources and the results of ceramic laminate complexity analysis adopt remote control data encryption protocol and real-time command transmission function. The functional modules of hot pressing molding process and high-speed cutting device are decoupled through microservice architecture. Application programming interface gateway is used to uniformly manage data interaction and user permission verification of multi-device collaborative management. Asynchronous production requests are processed through message queue. If the service response time exceeds the delay threshold determined by the ceramic laminate complexity analysis results, the service degradation mechanism is activated to generate a highly available ceramic laminate production platform.

6. The remote control method for a ceramic capacitor stacking machine according to claim 5, characterized in that, The remotely controlled data encryption protocol and real-time command transmission function specifically include: The configuration status of ceramic laminate production resources is obtained through AES-256-CBC encryption, and the configuration status is parsed to obtain the production task allocation table. The task instructions from the production task allocation table are distributed to the hot pressing module and the cutting device module using a RabbitMQ message queue, and the execution status of the modules is obtained. The real-time production request sequence of the module execution status is processed through the Kafka message queue. The request processing time of each module is counted. If the processing time exceeds the preset latency threshold, it is marked as a high latency module, and a list of high latency modules is obtained. A weighted round-robin algorithm is used to adjust the task ratio of the high-latency module and generate an optimized task allocation table.

7. The remote control method for a ceramic capacitor stacking machine according to claim 6, characterized in that, The high-availability ceramic stack production platform collects operational status data and production indicators of multi-layer ceramic stacks through a real-time monitoring module and status feedback mechanism. It uses time series analysis algorithms to predict trends and detect anomalies in CPU utilization, memory usage, and environmental temperature and humidity control data, generating a set of automated operation and maintenance instructions, including parameter adjustment and resource reallocation. If any performance indicator deviates from the normal range beyond the preset tolerance, an automatic optimization program is triggered to adjust the ceramic stack production parameters. Through remote fault diagnosis and log auditing functions, it generates stable digital service capabilities for ceramic capacitor stacks.

8. The remote control method for a ceramic capacitor stacking machine according to claim 7, characterized in that, The collection of operational status data of the high-availability ceramic laminate production platform through the real-time monitoring module and status feedback mechanism specifically includes: The real-time monitoring module collects data on central processing unit usage, memory usage, and ambient temperature and humidity from the ceramic laminate production platform and writes it to the InfluxDB database at minute intervals to generate a structured state dataset. The ARIMA algorithm is used to perform X_P daily rolling training on the structured state dataset to obtain a trend prediction model and output a prediction dataset. If any indicator in the predicted data set exceeds the dynamic threshold calculated based on the 3σ principle, the PID controller is triggered to calculate the adjustment value of the ceramic laminate production parameters and generate a parameter adjustment instruction set containing temperature compensation value and pressure correction value. The parameter adjustment instruction set is distributed to the temperature control execution module and the pressure regulation module via the MQTT protocol to obtain the updated operating status dataset.

9. A remote control method for a ceramic capacitor stacking machine according to claim 8, characterized in that, The method of using time series analysis algorithms to predict the trend of central processing unit utilization specifically includes: The real-time monitoring module collects CPU usage data and writes it into the InfluxDB time series database. It then extracts the most recent X_V hour data from the database and uses the Prophet algorithm to predict the future X_G hour usage trend. If the predicted value exceeds the preset threshold of 85%, the decision tree-based rule engine is triggered to calculate the temperature adjustment value and pressure correction value of the ceramic stack production parameters and write them to the RabbitMQ message queue. Historical operating status data is extracted from InfluxDB and merged with the latest collected central processing unit utilization data. K-means clustering algorithm is used to match similar operating conditions to generate a set of digital service instructions, which are transmitted to the control terminal via Modbus TCP protocol to update the production parameters.

10. A remote control system for a ceramic capacitor stacking machine, applied to the remote control method for a ceramic capacitor stacking machine as described in any one of claims 1-9, characterized in that, include: The distributed data acquisition module is used to acquire micron-level alignment accuracy data and crack and void detection data during the multi-layer ceramic stacking process from the automated feeding system and defect detection module of the ceramic capacitor stacking machine. The data cleaning algorithm is used to remove redundant records and outliers. The dataset is verified according to the evaluation criteria of completeness (missing rate lower than expected), consistency (format uniformity rate higher than expected), and accuracy (error rate lower than expected). If the overall data quality score is lower than the preset threshold, the data repair mechanism is triggered to generate a standardized ceramic stacking dataset. The in-memory computing module is used to perform fragmented storage and parallel processing of the standardized ceramic stack dataset. It calculates the ceramic stack complexity weight coefficient W based on the feature vectors of the multi-layer ceramic stack. If W exceeds the preset threshold, it starts a high-performance computing resource pool containing a graphics processing unit cluster and distributed storage to generate ceramic stack complexity analysis results. The load balancing module is used to dynamically adjust the task allocation ratio of computing nodes based on the ceramic stack complexity analysis results and an adaptive load balancing algorithm. It uses a support vector machine algorithm to predict the load trend of the ceramic stack production system based on environmental temperature and humidity control data and the operating status of the high-speed cutting device, and generates a load prediction value R, in units of tasks per second. The expansion control module is used to calculate the expansion factor S based on R and the current system utilization rate U. If S exceeds the preset threshold, the elastic expansion mechanism is triggered to generate an optimized ceramic stack production resource configuration state.

Images