Capacitive screen ITO pattern design system based on deep learning

Abstract

This invention relates to a deep learning-based capacitive touchscreen ITO pattern design system, specifically in the field of touch display technology. This solution effectively addresses the challenges of data silos and privacy leaks in industry chain collaboration through collaborative operation. Within the collaborative framework of the configuration module, the security assessment module utilizes homomorphic encryption and homomorphic computation to ensure that models and data from all parties can be securely accessed and evaluated without exposing plaintext, thus protecting core intellectual property rights. The local training module introduces differential privacy noise to ensure that original data information is not leaked when updating local model parameters. The model aggregation module intelligently integrates privacy-protected model updates from various nodes based on a dynamic weighting strategy, generating a new generation of global models that can absorb cross-domain knowledge. Ultimately, while protecting the privacy of data and models from all parties, it collaboratively optimizes high-performance ITO pattern designs, improving overall R&D efficiency and innovation quality.

Description

Technical Field

[0001] This invention relates to the field of touch display technology, and more specifically, to a deep learning-based capacitive touchscreen ITO pattern design system. Background Technology

[0002] In the R&D and manufacturing industry chain of capacitive touch screens, the design of ITO conductive patterns for high-end products is a highly complex systems engineering project, involving the deep integration of multidisciplinary knowledge and cross-domain collaboration. Panel manufacturers, as the physical implementers of the patterns, have accumulated a massive database of historical pattern designs and their corresponding key performance parameters, such as the correlation data between pattern geometry and transmittance and sheet resistance. Touch chip providers have a deep understanding of the electrical characteristics and signal processing algorithms of driver chips, and their models have the ability to accurately simulate and evaluate the electrical performance of ITO patterns, such as channel impedance and signal-to-noise ratio. Terminal device manufacturers, based on the user experience of the final product, put forward strict specifications for touch sensitivity, appearance consistency, and anti-optical interference capabilities. Ideally, if the data and model knowledge held by these three parties can be combined for joint optimization, it is expected that the design space can be systematically explored, and innovative patterns that achieve Pareto optimality in optical, electrical, and experiential dimensions can be automatically generated, thereby significantly improving product competitiveness and shortening the R&D cycle.

[0003] However, the current collaborative R&D in the industry chain faces a fundamental technological bottleneck. Due to the need to protect trade secrets and core intellectual property rights, all parties regard their key data and models as core assets, forming strict data silos. Panel manufacturers cannot share their original design drawing libraries, chip manufacturers cannot disclose the internal parameters of their sensitive electrical simulation models, and terminal manufacturers are unwilling to provide detailed user interaction data. Existing cooperation models mainly rely on limited data sample exchange after signing confidentiality agreements, or black-box model calls based on standardized interfaces. These methods are not only inefficient and lack depth of collaboration, but also pose substantial risks of data leakage and intellectual property erosion. Therefore, the industry urgently needs an innovative technical solution that enables multiple participants in the upstream and downstream of the industry chain to securely and efficiently train and optimize a global ITO pattern intelligent design model without directly exchanging or centralizing original private data. This solution needs to address how to achieve effective fusion and joint modeling of distributed knowledge under the constraints of heterogeneous data feature spaces, different model structures, and privacy and security, thereby breaking down collaboration barriers, truly realizing the co-creation of data value while keeping the original data invisible, and driving industry-level design innovation. Summary of the Invention

[0004] This invention addresses the technical problems existing in the prior art by providing a deep learning-based capacitive touchscreen ITO pattern design system. Through a configuration module, a security assessment module, a local training module, and a model aggregation module, it solves the problems mentioned in the background art.

[0005] The technical solution of this invention to solve the above-mentioned technical problems is as follows: specifically including: Configuration module: During collaborative startup, it generates initial global model parameters and homomorphic encryption key pairs based on a predefined model architecture, and distributes copies of the initial global model parameters and public keys to each client node; Security assessment module: When a client node generates a candidate pattern, it encrypts it using the public key and sends it to the designated assessment client node; it calls the local model to perform homomorphic computation and returns the generated encrypted assessment result; the client node that initiated the assessment decrypts the result using the private key to obtain the plaintext performance index. Local training module: When each client node trains a local model using local data, it calculates the gradient vector and performs pruning and differential privacy noise addition to update its local model parameters. Model aggregation module: Receives updated local model parameters from each client node, calculates weights according to a dynamic weighting strategy, performs weighted averaging, and generates and distributes a new generation of global model parameters.

[0006] In a preferred embodiment, the configuration module generates initial global model parameters based on a predefined model architecture, specifically including: Collect the local data feature dimensions and computational capability constraints declared by all client nodes, and run a dynamic architecture generation algorithm based on this. The dynamic architecture generation algorithm aims to minimize the overall cost estimate and maximize the predicted performance score. It performs Pareto front search in the set of model architectures that can be supported by all client nodes to determine the optimal global model architecture. The configuration module then randomly initializes the parameters of this global model architecture to generate initial global model parameters.

[0007] In a preferred embodiment, a homomorphic encryption key pair is generated and the public key is distributed, specifically including a secure escrow mechanism for the private key: Run a key generation function for an additive homomorphic encryption algorithm to generate a public key and a corresponding private key; distribute the public key along with a copy of the initial global model parameters to each client node; For the private key, a secure multi-party computation protocol is used to divide the private key into multiple secret shares, and these secret shares are distributed to a pre-designated group of highly trusted client nodes for joint custody, so that no single client node can hold the complete private key alone.

[0008] In a preferred embodiment, the security assessment module uses public key encryption and transmission, specifically including: When the client node acting as the designer generates a candidate ITO pattern, it serializes and encodes the data of this candidate ITO pattern, converting it into a plaintext vector that meets the requirements of the additive homomorphic encryption algorithm. The client node acting as the designer then uses the global homomorphic encryption public key obtained from the configuration module to perform encryption operations on the plaintext vector to obtain the corresponding ciphertext vector. The client node acting as the designer constructs an evaluation request packet, which includes at least a ciphertext vector, a unique identifier of the client node designated as the evaluator, and a list of performance metric types to be evaluated. The client node acting as the designer then sends the evaluation request packet to the client node designated as the evaluator.

[0009] In a preferred embodiment, calling the local model for homomorphic computation specifically includes: After receiving the evaluation request data packet, the client node designated as the evaluator extracts the ciphertext vector from it; The client node designated as the evaluator calls its private, pre-trained performance evaluation model locally. The performance evaluation model is converted into a series of combined addition and constant multiplication calculations. Without decryption, the client node designated as the evaluator takes the ciphertext vector as input and performs the corresponding addition homomorphic operations and scalar multiplication homomorphic operations in the ciphertext domain according to the combined calculation process. This generates an output ciphertext vector that carries the evaluation result but is still in an encrypted state, and the output ciphertext vector is returned to the client node designated as the designer.

[0010] In a preferred embodiment, the client node that generates the candidate pattern decrypts it using a private key, specifically through a collaborative decryption process based on secret sharing: After receiving the encrypted output ciphertext vector, the client node acting as the designer sends a collaborative decryption request to multiple highly trusted client nodes that hold a secret share of the private key. Each highly trusted client node that holds a secret share of the private key uses its own private key secret share to perform partial decryption calculation on the output ciphertext vector, obtains a partial decryption result fragment, and returns the partial decryption result fragment. As the client node of the design party, it collects partial decryption result fragments. When the number of valid fragments received reaches a predefined threshold, it uses the Lagrange interpolation method to combine the partial decryption result fragments to restore the complete plaintext performance index vector.

[0011] In a preferred embodiment, the local training module calculates gradient vectors and performs pruning and differential privacy noise addition to update its local model parameters, specifically including: Each client node calculates the original gradient vector of the local model parameters based on a multi-source loss function. The multi-source loss function consists of three weighted parts, including the local task loss, the global consistency loss, and the cross-domain evaluation feedback loss. Each component of the original gradient vector is adaptively pruned, and the pruning threshold of each component is dynamically calculated and determined based on the historical gradient magnitude corresponding to that component. Then, noise that satisfies differential privacy requirements is added to the clipped gradients. Gradient components related to cross-domain evaluation feedback loss are added with relatively stronger noise, while gradient components related to task loss and global consistency loss are added with relatively weaker noise, thereby generating perturbed gradients that satisfy privacy requirements. Finally, the perturbed gradients are used to update the local model parameters of the client node.

[0012] In a preferred embodiment, after updating its local model parameters, the method further includes the step of generating and submitting a model update summary: Each client node calculates the difference between the updated local model parameters and the global model parameters held before training to obtain the original model parameter update amount; the original model parameter update amount is sparsified, and only the parameter values ​​with the largest absolute value are retained according to the previous set proportion. The non-zero parameter values ​​retained after sparsification are quantized and encoded. The results of sparsification and quantization, along with binary identifiers indicating the positions of parameters retained during sparsification, are submitted as a model update summary.

[0013] In a preferred embodiment, the model aggregation module calculates weights according to a dynamic weighting strategy, specifically including: Calculate the dynamic weight of each client node. The dynamic weight is determined by two parts of contribution. The first part is the historical contribution score calculated based on the historical evaluation performance of the client node based on the plaintext performance index vector record obtained by the collaborative decryption process. The second part is the current update quality score calculated based on the amount of model parameter updates submitted by the client node this time. Finally, the historical contribution score and the current update quality score of each client node are weighted and combined, and then normalized to obtain the final dynamic weight for weighted averaging.

[0014] In a preferred embodiment, a weighted average is performed, specifically including robust polymerization and anomaly suppression steps: After performing a preliminary weighted average based on dynamic weights to obtain the intermediate global model update, the Mahalanobis distance between the model parameter update amount submitted by each client node this time and the intermediate global model update is further calculated. The Mahalanobis distance is compared with a preset distance threshold. For client nodes whose Mahalanobis distance exceeds the distance threshold, their current update is determined to be a potentially abnormal update. The dynamic weight corresponding to the potentially abnormal update is decayed, and the decay rate is positively correlated with the magnitude of the distance exceeding the threshold. Using the weights after decay processing, the model parameter updates submitted by all client nodes are re-weighted and averaged to generate the final net global update used to update the global model parameters, thereby suppressing the negative impact of abnormal updates on the global model.

[0015] The beneficial effects of this invention are as follows: Through collaborative operation, it effectively solves the problems of data silos and privacy leaks in industry chain collaboration; under the collaborative framework of the configuration module, the security assessment module uses homomorphic encryption and homomorphic computation to enable the models and data of all parties to be securely accessed and evaluated without exposing plaintext, thus protecting core intellectual property rights; the local training module introduces differential privacy noise to ensure that the original data information is not leaked when updating local model parameters; the model aggregation module intelligently integrates privacy-protected model updates from various nodes based on a dynamic weighting strategy, and the generated new generation of global models can absorb cross-domain knowledge. Ultimately, while protecting the data and model privacy of all parties, it collaboratively optimizes high-performance ITO pattern design, improving overall R&D efficiency and innovation quality. Attached Figure Description

[0016] Figure 1 This is a flowchart of the method of the present invention; Figure 2 This is a block diagram of the system structure of the present invention. Detailed Implementation

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

[0018] In the description of this application, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of the stated features. In the description of this application, "multiple" means two or more, unless otherwise explicitly specified.

[0019] In the description of this application, the term "for example" is used to mean "used as an example, illustration, or description." Any embodiment described as "for example" in this application is not necessarily to be construed as being more preferred or advantageous than other embodiments. The following description is provided to enable any person skilled in the art to make and use the invention. Details are set forth in the following description for purposes of explanation. It should be understood that those skilled in the art will recognize that the invention can be made without using these specific details. In other instances, well-known structures and processes will not be described in detail to avoid obscuring the description of the invention with unnecessary detail. Therefore, the invention is not intended to be limited to the embodiments shown, but is consistent with the broadest scope of the principles and features disclosed in this application.

[0020] Example 1

[0021] This embodiment provides, for example Figure 1-2 The system shown is a deep learning-based ITO pattern design system for capacitive touchscreens, specifically including: Configuration module: During collaborative startup, it generates initial global model parameters and homomorphic encryption key pairs based on a predefined model architecture, and distributes copies of the initial global model parameters and public keys to each client node; Security assessment module: When a client node generates a candidate pattern, it encrypts it using the public key and sends it to the designated assessment client node; it calls the local model to perform homomorphic computation and returns the generated encrypted assessment result; the client node that initiated the assessment decrypts the result using the private key to obtain the plaintext performance index. Local training module: When each client node trains a local model using local data, it calculates the gradient vector and performs pruning and differential privacy noise addition to update its local model parameters. Model aggregation module: Receives updated local model parameters from each client node, calculates weights according to a dynamic weighting strategy, performs weighted averaging, and generates and distributes a new generation of global model parameters.

[0022] In this embodiment, it is specifically necessary to explain that the configuration module generates initial global model parameters based on a predefined model architecture, which specifically includes: Collect the local data feature dimensions and computing power constraints declared by all client nodes, and run a dynamic architecture generation algorithm based on this. The dynamic architecture generation algorithm has two optimization objectives: minimizing the combined cost estimate of a single round of model training and communication, and maximizing the predicted performance score of the model on a reserved validation set maintained by the configuration module. It performs Pareto front search in the set of model architectures that can be supported by all client nodes to determine an optimal or near-optimal global model architecture as the basis for subsequent collaborative training. The specific operation process of the dynamic architecture generation algorithm is as follows: First, the configuration module extracts key limiting parameters based on the computing power constraints declared by each client node, including the maximum number of network layers that can be supported, the maximum number of neurons or channels in a single layer, and the upper limit of available memory. Next, the dynamic architecture generation algorithm constructs the intersection of all client node constraint parameters to form the initial feasible architecture search space. Then, a multi-objective evolutionary optimization method is adopted to quantify the overall cost estimate by the sum of the total number of network parameters and the estimated number of floating-point operations for a single forward propagation, and to quantify the predicted performance score by the classification accuracy or regression error predicted by the lightweight proxy model on the reserved validation set. In each generation of evolutionary iteration, the algorithm performs crossover and mutation operations on the architecture population to generate offspring architectures, and uses fast non-dominated sorting and crowding calculation to select architectures with high Pareto scores and dispersed distribution to enter the next generation. This process continues until the preset maximum number of evolutionary generations is reached or the architecture performance converges. Finally, from the last generation of architectures that performs best, the architecture with the best balance between overall cost and predicted performance score is selected and determined as the global model architecture used for subsequent collaborative training. The criteria for "all client nodes can support it" are: the depth of the computation graph of the architecture does not exceed the maximum number of network layers declared by any client node; the width of any layer in the architecture does not exceed the minimum value of the maximum number of neurons or channels declared by all client nodes for that layer; and the space required for the architecture to be loaded into memory does not exceed 80% of the maximum available memory declared by any client node. The preset maximum number of generations is usually set between 50 and 150 generations. The configuration module then randomly initializes the parameters of this global model architecture to generate initial global model parameters; Generate homomorphic encryption key pairs and distribute the public key, which also includes a secure escrow mechanism for the private key: The configuration module runs a key generation function for an additive homomorphic encryption algorithm to generate a public key and a corresponding private key. The additive homomorphic encryption algorithm uses the semantically safe Paillier encryption scheme. The specific calculation process of its key generation function is as follows: First, two large prime numbers of equal length are randomly generated, and their product is calculated as the modulus. The Carmichael function value is then calculated. Next, an integer is randomly selected, ensuring that the integer is coprime to the square of the modulus. The modular inverse of the integer with respect to the square of the modulus is then calculated. The final output public key contains the modulus and the random integer, and the private key contains the Carmichael function value and the modular inverse of the modulus. The public key, along with a copy of the initial global model parameters, is distributed to each client node. For the private key, a secure multi-party computation protocol is used to divide the private key into multiple secret shares, and these secret shares are distributed to a group of pre-specified, highly trusted client nodes for joint custody, so that no single client node can hold the complete private key alone. The specific process of splitting the private key using the secure multi-party computation protocol is as follows: The configuration module adopts the Shamir secret sharing scheme and sets a threshold value, which is less than or equal to the total number of trusted client nodes; First, a polynomial with the highest degree of the threshold value minus one is randomly generated over a finite field, where the constant term is the value of the private key to be split; Then, a distinct x-coordinate value is calculated for each trusted client node participating in the joint hosting, and this x-coordinate value is substituted into the aforementioned polynomial to calculate a y-coordinate value. This coordinate pair is the secret share distributed to the corresponding trusted client node. The reconstruction of the private key requires at least a threshold number of trusted client nodes to provide their secret shares. Then, the polynomial is recovered using Lagrange interpolation, and the constant term, i.e., the complete private key, is calculated. The threshold value is usually set to be greater than half of the total number of trusted client nodes to ensure security; "client nodes with high trustworthiness" are determined by the configuration module during the initialization phase based on the node's historical behavior reputation score or a preset list of trusted certificates, and their number is no less than three.

[0023] In this embodiment, it is specifically necessary to explain that the security assessment module uses public key encryption and transmission, which includes: When the client node, acting as the designer, generates a candidate ITO pattern, it serializes and encodes the data of this candidate ITO pattern, converting it into a plaintext vector that meets the requirements of the additive homomorphic encryption algorithm. The specific process of serialization and encoding is as follows: the two-dimensional or three-dimensional tensor data of the candidate ITO pattern is expanded in row-major or column-major order and converted into a one-dimensional floating-point array; then, each element in this floating-point array is linearly scaled and quantized according to the plaintext space range required by the Paillier homomorphic encryption algorithm, mapping it to an integer vector in the integer field, which is the plaintext vector; the purpose of linear scaling is to ensure that all values ​​fall within the plaintext range supported by the homomorphic encryption algorithm, and the quantization process introduces an acceptable loss of precision to meet the requirements of integer operations; The client node, acting as the designer, uses the global homomorphic encryption public key obtained from the configuration module to perform encryption operations on the plaintext vector, obtaining the corresponding ciphertext vector. The specific encryption operation process is as follows: for each integer element in the plaintext vector, the Paillier encryption algorithm is used, and the modulus in the global homomorphic encryption public key and a random integer are used to calculate the ciphertext of that integer element. This calculation process includes: first, selecting a random number, then calculating the modulus power of the random number, then multiplying it by the modulus power of the plaintext integer element, and finally taking the modulus of the square of the modulus to obtain the ciphertext of that element. This operation is performed on all elements in the plaintext vector one by one, ultimately resulting in a ciphertext vector of the same length. The client node acting as the designer constructs an evaluation request packet. The evaluation request packet contains at least a ciphertext vector, a unique identifier of the client node designated as the evaluator, and a list of performance metric types to be evaluated. The construction format of the evaluation request packet is as follows: the packet header contains the protocol version, timestamp, and unique request number; the packet body contains three fields: the first field is the binary encoding of the ciphertext vector, the second field is the identifier string registered by the evaluator client node in the network, and the third field is a list of strings used to specify the names of the metrics to be evaluated, such as "sheet resistance" and "transmittance". The client node acting as the designer sends the evaluation request data packet to the client node designated as the evaluation party. Calling the local model for homomorphic computation specifically includes: After receiving the evaluation request data packet, the client node designated as the evaluator extracts the ciphertext vector from it; The client node designated as the evaluator locally invokes its private, pre-trained performance evaluation model. This model is constructed or converted into a series of additions and constant multiplications. The specific method for constructing or converting the performance evaluation model into a series of additions and constant multiplications is as follows: For the evaluator's original local neural network or mathematical model, which may contain complex nonlinear activation functions, a polynomial approximation or piecewise linearization method is used. Within a specified input range, a set of additions and constant multiplications is used to approximate the nonlinear part of the original model. For example, for the Sigmoid activation function, its Taylor expansion of a third-order polynomial is used for approximation within a specific interval. This polynomial only contains addition and multiplication operations between constant coefficients and input values. After this conversion, the entire performance evaluation model's computational flow can be represented as a computational graph about the input vector, consisting only of additions, constant multiplications, and possible integer exponentiation operations. The client node designated as the evaluator, without decryption, takes the ciphertext vector as input and performs corresponding addition and scalar multiplication homomorphic operations within the ciphertext domain according to the combinatorial calculation process. This generates an output ciphertext vector that carries the evaluation result but remains encrypted, and the output ciphertext vector is returned to the client node acting as the designer. The specific process of performing operations within the ciphertext domain is as follows: addition homomorphic operation involves directly multiplying two ciphertexts and then taking the modulus of the square of the modulus, which corresponds to adding plaintext; scalar multiplication homomorphic operation involves performing a constant number of modular multiplications on a ciphertext, which corresponds to multiplying the plaintext by a constant. The evaluation client node, following the transformed calculation process, takes the received ciphertext vector as initial input and sequentially executes the series of homomorphic addition and homomorphic scalar multiplication operations defined in the flowchart. For example, if the process includes calculating "input multiplied by constant A and added by constant B", the node will perform A modular multiplication operations on the input ciphertext, and then perform a homomorphic addition operation with the ciphertext of constant B (which needs to be pre-calculated and stored); the final output ciphertext vector, whose decrypted plaintext is approximately equal to the original private model's evaluation value of the original candidate pattern. The client node that generates the candidate pattern decrypts it using its private key, specifically through a collaborative decryption process based on secret sharing: After receiving the encrypted output ciphertext vector, the client node acting as the designer sends a collaborative decryption request to multiple highly trusted client nodes that hold the secret share of the private key. Each highly trusted client node holding a secret share of the private key uses its own private key secret share to perform partial decryption calculations on the output ciphertext vector, obtaining a partially decrypted result fragment, and returning the partially decrypted result fragment. The specific process of partial decryption calculation is as follows: Each client node holding a secret share of the private key uses its secret share to calculate for each ciphertext element in the output ciphertext vector. Taking the Paillier algorithm as an example, the calculation process is to raise the modulus of the ciphertext element (the power is the secret share value of the node), and then take the modulus of the square of the modulus. The result is the partially decrypted fragment of the ciphertext element for that share. The same operation is performed on all ciphertext elements in the output ciphertext vector to obtain the corresponding partially decrypted fragment vector. The client node, acting as the designer, collects fragments of the returned decryption results. When the number of valid fragments received reaches a predefined threshold, it uses Lagrange interpolation to combine the fragments and reconstruct the complete plaintext performance index vector. The specific process of reconstructing the plaintext using Lagrange interpolation is as follows: The client node selects a set of valid fragments equal to the threshold from the received fragments. For each position in the output ciphertext vector, the client node substitutes the value of each selected fragment at that position, along with the corresponding node's public x-coordinate value, into the Lagrange interpolation formula for calculation. The interpolation formula uses a weighted summation method to recover the complete decryption value (i.e., the constant term of the Lagrange polynomial). This operation is repeated for each position in the vector to finally obtain the complete plaintext vector, i.e., the performance index vector. The threshold is set during system initialization and must be greater than half the total number of high-trust client nodes holding secret shares. For example, if there are five such nodes, the threshold is usually set to three or four. If the number of valid fragments received does not reach the threshold, decryption cannot be completed.

[0024] In this embodiment, it is specifically necessary to explain that in the local training module, the gradient vector is calculated and pruned, and differential privacy noise is added to update its local model parameters. This includes: Each client node calculates the original gradient vector of its local model parameters based on a multi-source loss function. This multi-source loss function consists of three weighted components: a task loss based on local private data, a global consistency loss to constrain the difference between the local model parameters and the current global model parameters received from the model aggregation module, and a cross-domain evaluation feedback loss constructed based on the plaintext performance index vector obtained through the collaborative decryption process of the security assessment module. The specific construction method for the cross-domain evaluation feedback loss is as follows: the client node compares the plaintext performance index vector obtained from the security assessment module with the target value vector preset by the node for each performance index element-by-element, calculates the mean squared error or mean absolute error between the two, and uses the result as the value of the cross-domain evaluation feedback loss. The preset target value vector is set by the client node according to product specifications. In the multi-source loss function, the weighting coefficient of the cross-domain evaluation feedback loss is positively correlated with the historical aggregation weights of the client node in the model aggregation module, calculated according to the dynamic weighting strategy. The specific implementation of "positive correlation" is as follows: before the start of each training round, the client node queries the moving average of the aggregation weights of its node in the past few rounds (e.g., the last five rounds) recorded by the model aggregation module; this moving average is input into a predefined monotonically increasing mapping function, such as the Sigmoid function, to map the value range between zero and one, and the output is used as the weighting coefficient of the cross-domain evaluation feedback loss in the current training round. This mechanism ensures that nodes with high historical contributions will focus more on optimizing the feedback target from external evaluation during the training process. Next, adaptive clipping is performed on each component of the original gradient vector. The clipping threshold for each component is dynamically calculated and determined based on the historical gradient magnitude corresponding to that component. The dynamic calculation process of the adaptive clipping threshold is as follows: For each trainable parameter in the model, a historical buffer is maintained to record the absolute values ​​of its gradients in the most recent iterations (e.g., the most recent ten iterations). The clipping threshold is set as the product of the median of the values ​​in the historical buffer and a magnification factor greater than one. The magnification factor is usually set between 1.5 and 3 to provide a certain tolerance space and avoid over-clipping. After each calculation of the current gradient, the gradient component is clipped using this dynamic threshold. That is, if the absolute value of the gradient component exceeds the current threshold, its sign is preserved and the value is scaled to the threshold size. Then, noise that satisfies differential privacy requirements is added to the pruned gradients. Gradient components related to cross-domain evaluation feedback loss are added with relatively stronger noise, while gradient components related to task loss and global consistency loss are added with relatively weaker noise, thus generating perturbed gradients that meet privacy requirements. The specific process of adding noise that satisfies differential privacy requirements is as follows: First, the base noise scale parameter is calculated based on the preset overall privacy budget parameter. For gradient components related to cross-domain evaluation feedback loss, "relatively stronger noise" refers to random noise sampled from a Gaussian distribution with a mean of zero and a standard deviation twice that of the base noise scale parameter. For gradient components related to task loss and global consistency loss, "relatively weaker noise" refers to random noise sampled from a Gaussian distribution with a mean of zero and a standard deviation equal to the base noise scale parameter. After generating the noise, the corresponding noise vectors are added to the corresponding parts of the pruned gradient vectors to complete the perturbation. Finally, the local model parameters of the client node are updated using the perturbed gradient; After updating its local model parameters, the process also includes generating and submitting a summary of the model update: Each client node calculates the difference between the updated local model parameters and the global model parameters held before training to obtain the original model parameter update amount; The original model parameter update amounts are sparsified by retaining only the parameter values ​​with the largest absolute values ​​representing a predetermined proportion, and setting the remaining parameter values ​​to zero. The "predetermined proportion" in the sparsification process is typically set to 1% to 5%. The specific steps are as follows: calculate the absolute values ​​of all components in the original model parameter update amounts and sort them from largest to smallest; then, based on the total number of parameters and the predetermined proportion, calculate the number of parameters to be retained; finally, retain the parameter components with the largest absolute values ​​and set the values ​​of all other parameter components to zero. The non-zero parameter values ​​retained after sparsification are quantized and encoded, mapping them to a finite set of discrete values. The specific quantization process is as follows: First, determine the number of quantization bits, usually two to four bits, corresponding to four to sixteen discrete levels; then, find the maximum and minimum values ​​among all the non-zero parameter values ​​to be quantized, and divide this range of values ​​evenly into intervals equal to the number of discrete levels; next, map each non-zero parameter value to the discrete level value corresponding to its interval, for example, taking the median of the interval as the representative value after quantization; this process converts floating-point values ​​into low-bit integer indices. The results of sparsification and quantization encoding, along with binary identifiers indicating the positions of parameters retained during sparsification, are submitted together as a model update summary. The binary identifier is a binary vector with the same length as the total number of model parameters, where a value of "one" corresponds to a parameter position retained during sparsification, and a value of "zero" corresponds to a parameter position set to zero. The submission format of the model update summary consists of three parts: the first part is the sequence of quantized parameter values, arranged in the original order of the parameters in the model, but containing only non-zero values; the second part is binary identification information; and the third part is the metadata of the quantized parameters, including the maximum and minimum values ​​used during quantization, as well as the number of quantization bits, for the aggregator to use for dequantization.

[0025] In this embodiment, it is specifically necessary to explain that in the model aggregation module, the weights are calculated according to the dynamic weighting strategy, which specifically includes: Calculate the dynamic weight of each client node. The dynamic weight is determined by two parts of contribution. The first part is the historical contribution score calculated based on the historical evaluation performance of the client node based on the plaintext performance index vector record obtained by the collaborative decryption process. The second part is the current update quality score calculated based on the amount of model parameter update submitted by the client node this time after sparsification and quantization encoding. The historical contribution score is calculated as follows: For each client node, the model aggregation module retrieves the plaintext performance index vector obtained through collaborative decryption in the past few rounds (e.g., the most recent ten rounds), as well as the preset performance target vector for the corresponding round. For each round, the evaluation deviation is calculated, which is the sum of the absolute differences of each dimension between the performance index vector and the target vector. Then, the historical contribution score of the node is calculated, specifically as the negative value of the exponential function of the time-decay weighted average of the evaluation deviations of these rounds. The time-decay weighted average means that the more recent the round, the greater the weight is given to the evaluation deviation when calculating the average value. This weight decreases by a preset decay rate (e.g., 0.9) in powers of each other. Finally, the calculated exponential function value is used as the historical contribution score of the node, with a value between zero and one. The larger the value, the better the historical evaluation performance. The calculation of the historical contribution score depends on the plaintext performance index vectors of the candidate ITO patterns generated by the client node through the collaborative decryption process in the past multiple training rounds. By comparing these plaintext performance index vectors with the performance target vectors preset by the client node or the system, and giving higher weight to the recent evaluation results, the historical contribution score reflecting the long-term cross-domain collaborative value of the node is calculated. The current update quality score is calculated by combining the magnitude of the updated model parameters, the consistency of the update direction with the average update direction of all client nodes, and the degree of non-sparseness of the information contained in the update. The specific formula for calculating the current update quality score is as follows: Divide the L2 norm of the updated model parameters by the square root of the total number of model parameters to obtain the magnitude term; calculate the cosine similarity between the updated model parameters and the average vector of the updated model parameters of all client nodes to obtain the direction consistency term. The cosine similarity value is between -1 and 1, and is mapped to between 0 and 1 by adding one and dividing by two; calculate the proportion of non-zero elements in the updated model parameters as the degree of non-sparseness term; finally, multiply the magnitude term, the direction consistency term, and the degree of non-sparseness term to obtain the current update quality score. The larger the value, the higher the quality of the current update. Finally, the historical contribution score and current update quality score of each client node are weighted and combined, and then normalized to obtain the final dynamic weight for weighted averaging. The specific process of weighted combination and normalization is as follows: an adjustable positive coefficient is set for each of the historical contribution score and the current update quality score, for example, the coefficient for the historical contribution score is set to 0.6 and the coefficient for the current update quality score is set to 0.4; the historical contribution score of each client node is multiplied by the corresponding coefficient, and then the current update quality score is multiplied by the corresponding coefficient to obtain a combined score; then, the exponential function value is calculated for the combined scores of all client nodes; finally, the exponential function value of each node is divided by the sum of the exponential function values ​​of all nodes to obtain the final dynamic weight of that node, and the sum of all weights is one. The weighted average is performed, specifically including robust aggregation and anomaly suppression steps: After obtaining the intermediate global model update through preliminary weighted averaging based on dynamic weights, the Mahalanobis distance between the model parameter updates submitted by each client node and the intermediate global model update is further calculated. The Mahalanobis distance calculation process is as follows: First, using the dynamic weights of each client node as weights, the weighted average vector of all model parameter updates is calculated as the center of the distribution; next, the weighted covariance matrix is ​​calculated, specifically the outer product matrix of the differences between each model parameter update and the weighted average vector, and then summed using dynamic weights; then, for each client node's model parameter update, the difference vector between it and the weighted average vector is calculated; next, the product of this difference vector and the inverse of the weighted covariance matrix is ​​calculated; finally, the inner product of this product vector and the original difference vector is calculated, and the square root of this inner product value is the Mahalanobis distance corresponding to that node. The Mahalanobis distance is compared with a preset distance threshold. For client nodes whose Mahalanobis distance exceeds the threshold, their current update is considered a potentially anomalous update. The preset distance threshold is dynamically determined based on the distribution of Mahalanobis distances among all client nodes. One specific method is to calculate the median of all Mahalanobis distances and set the distance threshold as a fixed multiple of this median, typically between two and three, such as 2.5. This means that updates with a Mahalanobis distance exceeding 2.5 times the median will be considered potentially anomalous. The dynamic weights corresponding to potential anomaly updates are decayed, and the degree of decay is positively correlated with the extent to which the distance exceeds the threshold. The specific method of weight decay is as follows: for client nodes identified as potential anomalies, the portion of their Mahalanobis distance that exceeds the distance threshold is calculated; then, a decay strength parameter greater than zero is set; the decayed weight is equal to the original dynamic weight multiplied by a decay coefficient, which is the product of the negative decay strength parameter of the natural constant and the excess portion raised to the power of the power of the product; for example, if the excess portion is larger, the decay strength parameter is larger, the decay coefficient is smaller, and the weight is reduced more severely. Using the weights after decay processing, the model parameter updates submitted by all client nodes are re-weighted and averaged to generate the final net global update used to update the global model parameters, thereby suppressing the negative impact of abnormal updates on the global model.

[0026] It should be noted that the descriptions of each embodiment in the above embodiments have different focuses. For parts that are not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0027] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0028] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0029] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0030] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0031] Although preferred embodiments of the invention have been described, those skilled in the art, upon learning the basic inventive concept, can make other changes and modifications to these embodiments. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the invention.

[0032] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A deep learning-based capacitive touchscreen ITO pattern design system, characterized in that, Specifically, it includes: Configuration module: During collaborative startup, it generates initial global model parameters and homomorphic encryption key pairs based on a predefined model architecture, and distributes copies of the initial global model parameters and public keys to each client node; Security assessment module: When a client node generates a candidate pattern, it encrypts it using a public key and sends it to the designated assessment client node; The local model is invoked to perform homomorphic computation and return the generated encrypted evaluation results; the client node that initiated the evaluation decrypts the results using its private key to obtain the plaintext performance metrics. Local training module: When each client node trains a local model using local data, it calculates the gradient vector and performs pruning and differential privacy noise addition to update its local model parameters. Model aggregation module: Receives updated local model parameters from each client node, calculates weights according to a dynamic weighting strategy, performs weighted averaging, and generates and distributes a new generation of global model parameters.

2. The deep learning-based capacitive touchscreen ITO pattern design system according to claim 1, characterized in that: In the configuration module, initial global model parameters are generated based on a predefined model architecture, specifically including: Collect the local data feature dimensions and computational capability constraints declared by all client nodes, and run a dynamic architecture generation algorithm based on this. The dynamic architecture generation algorithm aims to minimize the overall cost estimate and maximize the predicted performance score. It performs Pareto front search in the set of model architectures that can be supported by all client nodes to determine the optimal global model architecture. The configuration module then randomly initializes the parameters of this global model architecture to generate initial global model parameters.

3. The deep learning-based capacitive touchscreen ITO pattern design system according to claim 2, characterized in that: Generate homomorphic encryption key pairs and distribute the public key, which also includes a secure escrow mechanism for the private key: Run a key generation function for an additive homomorphic encryption algorithm to generate a public key and a corresponding private key; distribute the public key along with a copy of the initial global model parameters to each client node; For the private key, a secure multi-party computation protocol is used to divide the private key into multiple secret shares, and these secret shares are distributed to a pre-designated group of highly trusted client nodes for joint custody, so that no single client node can hold the complete private key alone.

4. The deep learning-based capacitive touchscreen ITO pattern design system according to claim 3, characterized in that: The security assessment module uses public key encryption for transmission, specifically including: When the client node acting as the designer generates a candidate ITO pattern, it serializes and encodes the data of this candidate ITO pattern, converting it into a plaintext vector that meets the requirements of the additive homomorphic encryption algorithm. The client node acting as the designer then uses the global homomorphic encryption public key obtained from the configuration module to perform encryption operations on the plaintext vector to obtain the corresponding ciphertext vector. The client node acting as the designer constructs an evaluation request packet, which includes at least a ciphertext vector, a unique identifier of the client node designated as the evaluator, and a list of performance metric types to be evaluated. The client node acting as the designer then sends the evaluation request packet to the client node designated as the evaluator.

5. The deep learning-based capacitive touchscreen ITO pattern design system according to claim 4, characterized in that: Calling the local model for homomorphic computation specifically includes: After receiving the evaluation request data packet, the client node designated as the evaluator extracts the ciphertext vector from it; The client node designated as the evaluator calls its private, pre-trained performance evaluation model locally. The performance evaluation model is converted into a series of combined addition and constant multiplication calculations. Without decryption, the client node designated as the evaluator takes the ciphertext vector as input and performs the corresponding addition homomorphic operations and scalar multiplication homomorphic operations in the ciphertext domain according to the combined calculation process. This generates an output ciphertext vector that carries the evaluation result but is still in an encrypted state, and the output ciphertext vector is returned to the client node designated as the designer.

6. The deep learning-based capacitive touchscreen ITO pattern design system according to claim 5, characterized in that: The client node that generates the candidate pattern decrypts it using its private key, specifically through a collaborative decryption process based on secret sharing: After receiving the encrypted output ciphertext vector, the client node acting as the designer sends a collaborative decryption request to multiple highly trusted client nodes that hold a secret share of the private key. Each highly trusted client node that holds a secret share of the private key uses its own private key secret share to perform partial decryption calculation on the output ciphertext vector, obtains a partial decryption result fragment, and returns the partial decryption result fragment. As the client node of the design party, it collects partial decryption result fragments. When the number of valid fragments received reaches a predefined threshold, it uses the Lagrange interpolation method to combine the partial decryption result fragments to restore the complete plaintext performance index vector.

7. A deep learning-based capacitive touchscreen ITO pattern design system according to claim 6, characterized in that: In the local training module, gradient vectors are calculated and pruned, and differential privacy noise is added to update the local model parameters. Specifically, this includes: Each client node calculates the original gradient vector of the local model parameters based on a multi-source loss function. The multi-source loss function consists of three weighted parts, including the local task loss, the global consistency loss, and the cross-domain evaluation feedback loss. Each component of the original gradient vector is adaptively pruned, and the pruning threshold of each component is dynamically calculated and determined based on the historical gradient magnitude corresponding to that component. Then, noise that satisfies differential privacy requirements is added to the clipped gradients. Gradient components related to cross-domain evaluation feedback loss are added with relatively stronger noise, while gradient components related to task loss and global consistency loss are added with relatively weaker noise, thereby generating perturbed gradients that satisfy privacy requirements. Finally, the perturbed gradients are used to update the local model parameters of the client node.

8. A deep learning-based capacitive touchscreen ITO pattern design system according to claim 7, characterized in that: After updating its local model parameters, the process also includes generating and submitting a summary of the model update: Each client node calculates the difference between the updated local model parameters and the global model parameters held before training to obtain the original model parameter update amount; the original model parameter update amount is sparsified, and only the parameter values ​​with the largest absolute value are retained according to the previous set proportion. The non-zero parameter values ​​retained after sparsification are quantized and encoded. The results of sparsification and quantization, along with binary identifiers indicating the positions of parameters retained during sparsification, are submitted as a model update summary.

9. A deep learning-based capacitive touchscreen ITO pattern design system according to claim 8, characterized in that: In the model aggregation module, weights are calculated using a dynamic weighting strategy, specifically including: Calculate the dynamic weight of each client node. The dynamic weight is determined by two parts of contribution. The first part is the historical contribution score calculated based on the historical evaluation performance of the client node based on the plaintext performance index vector record obtained by the collaborative decryption process. The second part is the current update quality score calculated based on the amount of model parameter updates submitted by the client node this time. Finally, the historical contribution score and the current update quality score of each client node are weighted and combined, and then normalized to obtain the final dynamic weight for weighted averaging.

10. A deep learning-based capacitive touchscreen ITO pattern design system according to claim 9, characterized in that: The weighted average is performed, specifically including robust aggregation and anomaly suppression steps: After performing a preliminary weighted average based on dynamic weights to obtain the intermediate global model update, the Mahalanobis distance between the model parameter update amount submitted by each client node this time and the intermediate global model update is further calculated. The Mahalanobis distance is compared with a preset distance threshold. For client nodes whose Mahalanobis distance exceeds the distance threshold, their current update is determined to be a potentially abnormal update. The dynamic weights corresponding to potential abnormal updates are decayed, and the degree of decay is positively correlated with the magnitude of exceeding the distance threshold. Using the weights after decay processing, the model parameter updates submitted by all client nodes are re-weighted and averaged to generate the final net global update used to update the global model parameters, thereby suppressing the negative impact of abnormal updates on the global model.

Images