Data Processing Method and System Based on AD-TSK

Abstract

This invention relates to the field of TSK fuzzy classifier technology, and particularly to an AD-TSK-based data processing method and system. The method includes training a training set containing active adversarial examples using a TSK fuzzy classifier to generate an ATSK fuzzy classifier; training ATSK layer by layer to obtain latent class information; generating an output error gradient matrix based on attack labels using dropout, and adding it to the corresponding sample features to update the selected input sample features, which are then used as input for the next layer of ATSK; repeating this process until the maximum number of layers is reached, resulting in an AD-TSK model. This invention addresses the problem that embedding gradient information in all sample features in existing DSA-FC methods may lead to a decrease in model generalization performance, and that the inversion operations involved cause significant computational overhead during training.

Description

Technical Field

[0001] This invention relates to the field of TSK fuzzy classifier technology, and in particular to a data processing method and system based on AD-TSK. Background Technology

[0002] Over the past decade, neural networks have been a hot research topic in machine learning due to their powerful data learning and feature representation capabilities. Numerous scholars both domestically and internationally have conducted extensive research and promoted their application. However, conventional deep neural networks are deterministic models and cannot handle the uncertainty in raw data. Consequently, the decision results of conventional deep neural networks have limited interpretability. In particular, their internal structure is like a "black box," making it difficult for users to fully understand the state changes of all node parameters in their hidden layers.

[0003] To address the aforementioned issues, researchers have designed fuzzy deep learning models with stacked structures based on the Takagi-Sugeno-Kang (TSK) fuzzy system, which boasts good interpretability and classification performance. For example, based on the stacked structure principle, the TSK fuzzy classifier is used as a sub-classifier. Through parallel learning, the sub-classifier output is expanded to sample features, fuzzy rule semantic labels are shared, the sub-classifier output error gradient is embedded into sample features, and sample features are randomly noise-added, etc., the sub-classifiers are cascaded and stacked to form different fuzzy deep learning models.

[0004] Existing DSA-FC methods utilize the TSK fuzzy classifier to form a fuzzy deep system with good interpretability and excellent performance based on the stack structure principle. However, embedding gradient information in all sample features may lead to a decrease in the model's generalization performance, and the inversion operation involved causes the system to generate significant computational overhead during training. Summary of the Invention

[0005] To address the shortcomings of existing methods, this invention effectively handles noisy samples in the dataset through active adversarial example learning. Based on dropout, the error gradients of the sub-classifier outputs are randomly added to the input sample features, thereby updating the input samples layer by layer and constructing a novel stacked structure to form AD-TSK. Furthermore, by leveraging the Sherman-Morrison formula and Schur complement, the fuzzy rule consequents in each layer of the fuzzy deep system are solved without requiring inverse operations, forming the F-AD-TSK model. This enables rapid training of the AD-TSK model and search for the optimal number of fuzzy rules, while ensuring high interpretability of AD-TSK.

[0006] The technical solution adopted in this invention is: the data processing method based on AD-TSK includes the following steps:

[0007] Step 1: Use the TSK fuzzy classifier to train a training set containing active adversarial examples to learn from active adversarial examples and generate the ATSK fuzzy classifier.

[0008] Step 2: Train ATSK layer by layer to obtain latent category information. Based on the attack label, generate the output error gradient matrix using dropout and add it to the corresponding sample features to update the selected input sample features, which are then used as the input for the next layer of ATSK.

[0009] Step 3: Repeat the process until the maximum number of layers is reached, then stop to obtain the AD-TSK model.

[0010] Furthermore, it also includes: using the Sherman-Morrison formula, Schur complement, and minimum learning machine to solve for the fuzzy rule consequent parameters in each sub-classifier layer of AD-TSK without requiring inverse operations, thereby ensuring the fast training and interpretability of AD-TSK and obtaining the F-AD-TSK model.

[0011] Furthermore, building the AD-TSK module includes:

[0012] Generate ATSK_ m The antecedent matrix U of all fuzzy rules m Among them, ATSK_ m For the first m Layer ATSK;

[0013] Furthermore, the antecedent matrix U m The formula is:

[0014] (15)

[0015] in, N The number of input samples. , They are ATSK_ m The first and second of the input dataset N One sample, , They are ATSK_ m Article 1 and Article 2 R m The corresponding fuzzy rules The normalized membership function value, , They are ATSK_ m Article 1 and Article R m The corresponding fuzzy rules The normalized membership function value, , They are respectively , Construct a vector.

[0016] The consequent parameters of all fuzzy rules are calculated using a minimal learning machine. ;

[0017] Furthermore, consequent parameters The formula is:

[0018] (16)

[0019] in, U represents the regularization parameter. m , and They represent ATSK_ m Antecedent moments, consequent parameters, and active adversarial examples for all fuzzy rules in the dataset. The corresponding tag set, where I represents the identity matrix.

[0020] The output error gradient of each layer is randomly determined between two ATSK sub-classifiers using dropout.

[0021] Furthermore, the output error gradient The formula is:

[0022] (18)

[0023] (19)

[0024] in, For AD-TSK's first m The first in the layer i The first input sample j One characteristic, for r Fuzzy rules The corresponding output value, and The first The center and width kernel of the membership function of a fuzzy rule. and Representing the first r The membership values ​​and consequent parameters of the fuzzy rules after normalization.

[0025] ATSK_ m The output error gradient is multiplied by the sample feature learning rate and added to the selected sample features to update the selected samples. The updated samples are then used as the input to the next layer.

[0026] Furthermore, the partial pseudo-inverse expression of the consequent parameters of the fuzzy rules in the F-AD-TSK model is as follows:

[0027]

[0028] in, and Each represents a component The two block matrices, Representative based on Partial pseudo-inverse expression, represent continuously increasing i A matrix of rows, Representing the ( r +1) The (+1)th fuzzy rule antecedent matrix corresponds to the ()th i +1) row, Represents the identity matrix. represent The square root of.

[0029] Furthermore, the AD-TSK-based data processing system includes: a memory for storing instructions executable by a processor; and a processor for executing the instructions to implement the AD-TSK-based data processing method.

[0030] Furthermore, a computer-readable medium stores computer program code that, when executed by a processor, implements an AD-TSK-based data processing method.

[0031] The beneficial effects of this invention are:

[0032] 1. Active adversarial examples are generated by actively changing the true label type of some samples, and active adversarial examples are learned by each sub-classifier, which improves AD-TSK's ability to learn from noisy samples.

[0033] 2. A novel stacked structure is constructed based on active adversarial example learning for each sub-classifier. For the sub-classifiers in the two layers of this novel stacked structure, the output error gradient information of the previous sub-classifier is randomly selected by dropout and added to the corresponding sample features. The updated sample is then used as the input of the next sub-classifier, which improves the generalization performance of AD-TSK.

[0034] 3. Based on the Sherman-Morrison formula and Schur complement, the fast training method of AD-TSK is improved to obtain F-AD-TSK. Without the need for inverse operations, the consequents of all fuzzy rules in each sub-classifier of AD-TSK can be solved, thereby realizing the fast training of AD-TSK model. The effectiveness of F-AD-TSK is verified using real datasets. Attached Figure Description

[0035] Figure 1 This is a flowchart of the AD-TSK-based data processing method of the present invention;

[0036] Figure 2 This is a schematic diagram of the AD-TSK-based structure of the present invention. Detailed Implementation

[0037] The present invention will be further described below with reference to the accompanying drawings and embodiments. The drawings are simplified schematic diagrams, which only illustrate the basic structure of the present invention in a schematic manner, and therefore only show the components related to the present invention.

[0038] For the TAKA-Sugeno-Kang fuzzy classifier, the fuzzy rules are represented as follows:

[0039] With the first r Fuzzy rules Ru r For example:

[0040]

[0041] in, R Represents the number of fuzzy rules. For dimension Input samples, Representing the r The antecedent of the fuzzy rule, i.e., the one related to the first... i The fuzzy subset corresponding to each input feature This represents a fuzzy combination operator.

[0042] The output of the TSK fuzzy classifier can be viewed as a consequent of the fuzzy rules. The weighted average is:

[0043] (2)

[0044] in, Representative and the r The membership function corresponding to the fuzzy rule, for The normalized value; in addition, and This can be further expressed as:

[0045] (3)

[0046] (4)

[0047] If the membership function is a Gaussian function, then:

[0048] (5)

[0049] Among them, parameters and Representing the first r The center of each cluster and the kernel width of the Gaussian kernel function are collectively referred to as the antecedent parameters of the fuzzy rule.

[0050] If fuzzy c -means (FCM) clustering algorithm, and These can be expressed as:

[0051] (6)

[0052] (7)

[0053] Once the antecedents of all fuzzy rules in the TSK fuzzy classifier are determined, the following can be set:

[0054] (8)

[0055] (9)

[0056] (10)

[0057] (11)

[0058] The output of the TSK fuzzy classifier in equation (2) can be further expressed as:

[0059] (12)

[0060] The Sherman-Morrison formula is described as follows: For invertible matrices... and vectors with appropriate dimensions ,when hour, This can be expressed as:

[0061]

[0062] Schur complement provides a method for finding the inverse matrix through block decomposition, specifically when matrices A, B, C, and D all have invertible matrices:

[0063] (14)

[0064] Among them, A, B, C, and D have suitable dimensions, and .

[0065] like Figure 1 As shown, the fast training method based on adversarial deep TSK blurring includes the following steps:

[0066] like Figure 2 As shown, for a given dataset, a portion of training samples are randomly selected, and their true label types are artificially altered to form adversarial examples. The TSK fuzzy classifier is then used to train the training set containing these adversarial examples to learn the adversarial examples, generating an adversarial TSK fuzzy classifier (ATSK). The ATSK is trained layer by layer to obtain latent class information. The first layer of the ATSK uses the original data as input data, generates an output error gradient matrix based on the attack label using dropout, and adds it to the corresponding sample features to update the selected input sample features as input for the next layer of the ATSK. This error gradient matrix is ​​denoted as G. This process is repeated until the maximum number of layers is reached. M When the time stops, the adversarial deep Takagi-Sugeno-Kang fuzzy system (AD-TSK) is obtained.

[0067] Given an input dataset in, N Represents the total number of samples. d Represents the sample dimension; and with Corresponding real tag set And used as the input of the first layer of AD-TSK The input samples with a random proportion of λ are used to attack their true label type to generate active adversarial examples, that is... The label types of the selected samples are replaced with other label types; active adversarial learning is performed using a dataset containing active adversarial examples trained with the TSK fuzzy classifier to generate the ATSK fuzzy classifier ATSK_1; then the first-order gradient of the output error of ATSK_1 with respect to all input samples is determined. The determined output error gradient information is randomly selected using dropout and added to the corresponding sample features to update the sample features. The updated samples are then... ; The gradient learning rate; The input is fed into the next layer of AD-TSK, and in this way, based on the stack structure principle, the preceding and following layers of AD-TSK are cascaded until the first layer of AD-TSK is formed. M Layers are used to form a novel stacked structure for AD-TSK.

[0068] For each layer of AD-TSK, ATSK_ m Assuming its input set is ,and The corresponding tag set is ,in, N This represents the number of input samples. d This represents the dimension of the input sample. When the proportion of active attacks is... After inputting the true labels of the sample, It will contain active adversarial examples, and its label set Will become The antecedent of each fuzzy rule is determined using the TSK fuzzy classifier, with a fixed number of fuzzy partitions set to 5, and the center of the membership function in equation (5) is randomly selected from a fixed range of {0, 0.25, 0.5, 0.75, 1}; ATSK_ is generated using equations (3) to (10). m The antecedent matrix U of all fuzzy rules m ,Right now:

[0069] (15)

[0070] in, N This represents the number of input samples. R m Represents ATSK_ m The number of fuzzy rules in and They represent ATSK_ m The first and second of the input dataset N One sample, , They represent ATSK_ m Article 1 and Article R m The corresponding fuzzy rules The normalized membership function value, , They represent ATSK_ m Article 1 and Article R mThe corresponding fuzzy rules The normalized membership function value, , They represent ATSK_ m The first and second of the input dataset N One sample, Each element in can be determined by equations (3) to (10).

[0071] When ATSK_ m Once the antecedents of all fuzzy rules are determined, the consequents of all fuzzy rules can be calculated using a minimal learning machine, i.e.:

[0072] (16)

[0073] in, U represents the regularization parameter. m , and They represent ATSK_ m Antecedent moments, consequent parameters, and active adversarial examples for all fuzzy rules in the dataset. The corresponding tag set, where I represents the identity matrix.

[0074] Furthermore, when cascading the ATSK subclassifiers before and after AD-TSK, it is necessary to determine the output error gradient information of each layer. For the AD-TSK... In the ATSK layer, a random proportion of input samples (λ) are selected to attack their real label types to generate adversarial examples. The set of real labels corresponding to all input samples is then... Become .

[0075] in, The proportion of active adversarial examples is formed by randomly selecting a portion of training samples from each layer and artificially changing their true label types. Representative of active adversarial samples The corresponding tag set.

[0076] Once all the antecedents of the fuzzy rules in ATSK are determined, the first... i Input Samples The output error can be expressed as:

[0077] (17)

[0078] in, Representing AD-TSK m ATSK in the layer i Input Samples The output, After representing the input sample to form an active adversarial example. The labels; where the input sample The Middle j The output error gradient of each feature can be expressed as:

[0079] (18)

[0080] in, For AD-TSK's first m The first in the layer i The first input sample j One characteristic, for r Fuzzy rules The corresponding output value, and The first The center and width kernel of the membership function of a fuzzy rule. and Representing the first r The membership values ​​and consequent parameters of the fuzzy rules after normalization.

[0081] Equation (18) is used to determine the gradient information of the ATSK output error with respect to each input sample feature in each layer of AD-TSK. ( ),Right now:

[0082] (19)

[0083] Based on equation (19), the output error gradient matrix of each ATSK layer in the novel AD-TSK stack structure can be formed. .

[0084] The AD-TSK deep learning algorithm includes:

[0085] Step 1: Input the training set The real label set corresponding to the training set test set The number of fuzzy rules in each layer of AD-TSK R m Active adversarial sample ratio dropout ratio Sample feature learning rate Regularization parameters and the maximum number of AD-TSK layers M .

[0086] Training phase:

[0087] Step 2: Order and

[0088] Step 3: Proactive Attack The proportion is The sample's true label is obtained and active adversarial examples are generated.

[0089] Step 4: For the training set containing active adversarial examples generate R m fuzzy rules are used to generate ATSK_ active adversarial examples through TSK learning. m Meanwhile, equations (15) and (16) are used to determine the antecedent matrices of all fuzzy rules respectively. and subsequent matters .

[0090] Step 5: Output ATSK_ using equation (12) m For all input samples Prediction results .

[0091] Step 6: Randomly select from Select ratio The sample is selected, and the output error gradient corresponding to the selected sample is calculated using Equation (18), and ATSK_ is determined using Equation (19). m Output error gradient matrix .

[0092] Step 7: Transfer ATSK_ m The output error gradient is multiplied by the sample feature learning rate and added to the selected sample features to update the selected samples. The updated samples are then used as the input to the next layer. .

[0093] Step 8: Output ATSK_ m Training accuracy and determining whether it meets the requirements. If not satisfied, then m = m +1 and return to Step 3.

[0094] Testing phase:

[0095] Step 9: Use the K-nearest neighbor algorithm to initially predict all test samples. tags , and as The real tag set.

[0096] Step 10: Order and .

[0097] Step 11: Proactive Attack The proportion is The sample's true label is obtained and active adversarial examples are generated.

[0098] Step 12: Targeting ATSK_ m Using the generated in Step 4 R m The fuzzy rules and formula (15) are determined. All fuzzy rule antecedent matrices .

[0099] Step 13: Utilize all the fuzzy rule consequents determined in Step 4 Output ATSK_ according to formula (12) m For all test samples Prediction results .

[0100] Step 14: Randomly select from Select ratio The test samples are selected, and the output error gradient corresponding to the selected test samples is calculated using equation (18), and ATSK_ is determined using equation (19). m Output error gradient matrix .

[0101] Step 15: Transfer ATSK_ m The output error gradient information is added to the features of the selected test samples to update the selected test samples, and the updated test samples are used as the test samples for the next layer. .

[0102] Step 16: Output ATSK_ m Test accuracy and determine if it meets the requirements. If not satisfied, then m = m +1 and return to Step 11.

[0103] The AD-TSK deep learning algorithm shows that its algorithm complexity is similar to... , and N A linear relationship exists, where, N , d and These represent the input sample size, sample dimension, and the number of fuzzy rules in each layer of AD-TSK, respectively. Therefore, when ATSK in each layer of AD-TSK uses a large number of fuzzy rules or the sample dimension is large, the complexity of the AD-TSK algorithm will increase significantly. In addition, during the search for the optimal number of fuzzy rules in each layer of AD-TSK, whenever a fuzzy rule is added, the ATSK model will be repeatedly trained and all fuzzy rule consequents will be solved according to Equation (16). The inversion operation involved in Equation (16) will make the complexity of the AD-TSK model with a stack structure obvious. To address the aforementioned issues, the Sherman-Morrison formula and Schur complement are used to achieve the search for the optimal number of fuzzy rules in each layer of the ATSK model without retraining the ATSK model parameters or requiring inverse operations for solving the fuzzy rule consequents. This results in fast training of the adversarial deep Takagi-Sugeno-Kang(TSK) fuzzy system (F-AD-TSK), while maintaining the high interpretability of AD-TSK. The specific implementation process is described below:

[0104] Regarding AD-TSK m ATSK_ in the layer m When using r m ( When defining fuzzy rules, the antecedent and consequent matrices of all fuzzy rules determined using equations (15) and (16) are denoted as follows: , .

[0105] in, r m ( ) represents AD-TSK No. m ATSK_ in the layer m The number of fuzzy rules used represent r m The antecedent matrix corresponding to the fuzzy rule, represent r m The consequent parameters corresponding to the fuzzy rule.

[0106] For the sake of simplicity in the derivation process, ATSK_ will be used here. m In r m Simplified to r Correspondingly and Simplified to and and utilize represent The transpose, i.e.

[0107] (20)

[0108] in, r represent r m Simplified expression, represent r The antecedent matrix corresponding to the fuzzy rule, represent r The consequent parameters corresponding to the fuzzy rule.

[0109] When the number of fuzzy rules is r Increase to ( r When +1), the antecedent matrices of all fuzzy rules will be obtained from... become Accordingly, become ;Will and By comparing with equation (12), it can be seen that if the previous... r The fuzzy rules remain unchanged. Then you can On the basis of continuous increase ( d +1) column implementation, correspondingly, Then you can On the basis of continuous increase ( d +1) line implementation, i.e.:

[0110]

[0111] in, represent r The antecedent matrix corresponding to the fuzzy rule, represent( r +1) Antecedent matrices corresponding to fuzzy rules, d The dimension representing the input sample. represent transpose, represent transpose, Representing the ( r +1) The antecedent of the fuzzy rule can be expressed as:

[0112]

[0113] in, Representing the ( r +1) The first fuzzy rule's antecedent OK.

[0114] According to equations (21) and (22), each direction When adding a line, note:

[0115]

[0116] in, , represent Continuous increase ( i +1) rows of matrix, represent continuously increasing i A matrix of rows, Representing the ( r +1) The (+1)th fuzzy rule antecedent matrix corresponds to the ()th i +1) row.

[0117] Based on equation (20), juxtaposed Let part of the expression in equation (16) be:

[0118] (twenty four)

[0119] in, Representative based on Partial pseudo-inverse expression, represent Continuous increase ( i +1) rows of matrix, Represents the identity matrix. represent The square root of.

[0120] For equation (24), an auxiliary matrix is ​​introduced:

[0121]

[0122] in, Representative based on Constructed auxiliary matrix, Represents the identity matrix. represent The square root of.

[0123] Its pseudo-inverse matrix is ​​expressed as:

[0124]

[0125] in, Represents based on auxiliary matrix Partial pseudo-inverse expression, Representative based on Constructed auxiliary matrix.

[0126] According to equation (26), equation (24) can be further expressed as

[0127]

[0128] in, Representative based on Partial pseudo-inverse expression, Represents based on auxiliary matrix Partial pseudo-inverse expression, Represents the identity matrix. This represents a matrix where all elements are 0; similarly, This can be expressed as follows:

[0129]

[0130] in, Representative based on Partial pseudo-inverse expression, Represents based on auxiliary matrix Partial pseudo-inverse expression, Represents the identity matrix. This represents a matrix where all elements are 0.

[0131] Therefore, by solving equation (26), equation (23) can be solved, and correspondingly, equation (16) can also be solved; at this time, in equation (26) This can be further expressed as:

[0132]

[0133] in, Representative based on and Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix, and Expressed as

[0134]

[0135] in, represent continuously increasing i A matrix of rows, A matrix representing all elements equal to 0. Represents the identity matrix. represent The square root of.

[0136] Substituting equation (29) into equation (26) yields

[0137]

[0138] in, Represents based on auxiliary matrix Partial pseudo-inverse expression, Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix.

[0139] Based on the Schur complement in equation (14), we can obtain:

[0140]

[0141] in, , , and They are expressed as follows:

[0142]

[0143] in, , , , This represents the block matrix determined by the Schur complement. Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix.

[0144] Substituting equation (33) into equation (32), we get:

[0145]

[0146] in, Represents based on auxiliary matrix Partial pseudo-inverse expression, , , , This represents the block matrix determined by Schurcomplement. and Each represents a component The two block matrices, Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix.

[0147] Therefore, when the two element blocks in equation (38) , Once determined, the solution in equation (27) can be obtained. ,Right now

[0148]

[0149] in, and Each represents a component Two block matrices.

[0150] , They are expressed as follows:

[0151]

[0152] in, and Each represents a component The two block matrices, and Each represents a component The two block matrices, This represents a matrix where all elements are 0. Represents the identity matrix.

[0153] Furthermore, based on the Sherman-Morrison formula in equation (13) and assuming In equation (34) This can be further expressed as:

[0154]

[0155] in, This represents the block matrix determined by the Schur complement. Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix.

[0156] Based on the two block elements in equations (40) and (41) , This can be further expressed as:

[0157]

[0158] in, and Each represents a component The two block matrices, Represents the middle matrix. Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix.

[0159] intermediate matrix This can be expressed as:

[0160]

[0161] in, Represents based on auxiliary matrix Partial pseudo-inverse expression, This represents a matrix where all elements are 0.

[0162] According to equations (24), (26), (30), (31), and (45), we can obtain:

[0163]

[0164] in, Represents the middle matrix. Representative based on Partial pseudo-inverse expression, represent continuously increasing i A matrix of rows, Representing the ( r +1) The (+1)th fuzzy rule antecedent matrix corresponds to the ()th i +1) row, Representative based on Constructed auxiliary matrix, Representative based on Constructed auxiliary matrix, A matrix representing all elements equal to 0. Represents the identity matrix. represent The square root of.

[0165] According to equations (40), (41), and (46) to (52), we can obtain:

[0166]

[0167] in, and Each represents a component The two block matrices, Representative based on Partial pseudo-inverse expression, represent continuously increasing i A matrix of rows, Representing the ( r +1) The (+1)th fuzzy rule antecedent matrix corresponds to the ()th i +1) row, Represents the identity matrix. represent The square root of.

[0168] At this point, the two block elements in equation (39) , The solution can be obtained by determining the equations (53) and (54) respectively. .

[0169] Experiments and Analysis:

[0170] Dataset

[0171] The performance of AD-TSK and F-AD-TSK will be validated based on real datasets from the UCI and KEEL machine learning databases. A detailed description of the real datasets used is shown in Table 1.

[0172] Table 1 Real Dataset

[0173]

[0174] AD-TSK is built from the TSK fuzzy classifier based on the stack structure principle; therefore, in the experiment, the 1-order TSK fuzzy classifier and DSA-FC are used as comparison algorithms; in order to further verify the effectiveness of AD-TSK, a neural network based on continuous dropout technology (CD-NN) will also be selected as a comparison algorithm; for the datasets involved, 80% of the samples in each dataset are used as training samples, and the rest are used as test samples, and all experimental results are the average results obtained after running the algorithm 10 times.

[0175] Experimental results

[0176] Table 2 shows the actual classification performance of all algorithms on real datasets.

[0177] Here, "Acc" represents the average test accuracy. R "Represents the number of fuzzy rules.

[0178] According to Table 2, we can observe that:

[0179] 1) AD-TSK achieves the best classification performance on the vast majority of real datasets, effectively verifying the effectiveness of AD-TSK; in particular, AD-TSK achieves better average test accuracy than 1-order TSK on the vast majority of real datasets with fewer fuzzy rules, indicating that AD-TSK's novel stack structure can guarantee its good classification performance and interpretability.

[0180] 2) Compared with AD-TSK, F-AD-TSK can maintain comparable classification performance on most real datasets, indicating that the method of solving fuzzy rule consequents without inverse operations in each sub-classifier of AD-TSK through Sherman-Morrison formula and Schur complement does not significantly affect the classification performance of AD-TSK.

[0181] Table 2. Classification performance of all comparison algorithms on real datasets.

[0182]

[0183] Note: "-" indicates that the comparison algorithm does not involve fuzzy rule parameters. R And "--" indicates that the standard deviation is less than 10. -4 .

[0184] Table 3 lists the average training times for AD-TSK and F-AD-TSK on all real-world datasets. To maintain fairness in the comparison, AD-TSK and F-AD-TSK use the same parameter settings, i.e. The training time was calculated for 5 layers and 2 to 20 rules, respectively. Table 3 shows that when the real dataset contains a small number of samples, the training time of the AD-TSK model is comparable to that of F-AD-TSK, such as the real dataset LIV. As the number of samples increases, the training time of the AD-TSK model is significantly longer than that of F-AD-TSK. This observation strongly validates the effectiveness of the proposed fast AD-TSK training algorithm F-AD-TSK based on the Sherman-Morrison formula and Schur complement.

[0185] Table 3 Comparison of training times (seconds) between AD-TSK and F-AD-TSK

[0186]

[0187] Based on the above-described preferred embodiments of the present invention, and through the foregoing description, those skilled in the art can make various changes and modifications without departing from the inventive concept. The technical scope of this invention is not limited to the contents of the specification, but must be determined according to the scope of the claims.

Claims

1. A data processing method based on AD-TSK, characterized in that, Includes the following steps: Step 1: Train the ATSK fuzzy classifier using a training set containing active adversarial examples to generate the ATSK fuzzy classifier. Step 2: Train ATSK layer by layer to obtain potential category information. Based on the attack label, generate the output error gradient matrix in the form of dropout and add it to the corresponding sample features to update the selected input sample features, and use it as the input for the next layer of ATSK. Step 3: Repeat the process until the maximum number of layers is reached, then stop to obtain the AD-TSK model; By utilizing the Sherman-Morrison formula, Schur complement, and minimum learning machine, the fuzzy rule consequent parameters are solved without the need for inverse operations in each sub-classifier layer of AD-TSK, thus ensuring the fast training and interpretability of AD-TSK and obtaining the F-AD-TSK model. The construction of the AD-TSK model includes: Generate ATSK_ m The antecedent matrix U of all fuzzy rules m ATSK_ m For the first m Layer ATSK; Using a minimum learning machine to calculate the consequent parameters of fuzzy rules ; The output error gradient of each layer is randomly determined between two ATSK layers using dropout. Output error gradient The formula is: （18） （19） in, For AD-TSK's first m The first in the layer i The first input sample j One characteristic, for r Fuzzy rules The corresponding output value, and The first The center and width kernel of the membership function of a fuzzy rule. , The first r The normalized membership values ​​and consequent parameters of a fuzzy rule; ATSK_ m The output error gradient is multiplied by the sample feature learning rate and added to the selected sample features to update the selected samples. The updated selected samples are then used as the input to the next layer.

2. The data processing method based on AD-TSK according to claim 1, characterized in that, Antecedent matrix U m The formula is: （15） in, N The number of input samples. , They are ATSK_ m The first and second of the input dataset N One sample, , They are ATSK_ m Article 1 and Article 2 R m The corresponding fuzzy rules The normalized membership function value, , They are ATSK_ m Article 1 and Article R m The corresponding fuzzy rules The normalized membership function value, , They are respectively , Construct a vector.

3. The data processing method based on AD-TSK according to claim 1, characterized in that, Successor parameters The formula is: （16） in, U is the regularization parameter. m and They are ATSK_ m Antecedent moments and active adversarial samples of all fuzzy rules The corresponding tag set, where I represents the identity matrix.

4. The data processing method based on AD-TSK according to claim 1, characterized in that, The partial pseudo-inverse expression of the consequent parameters of the fuzzy rule is as follows: in, and Each represents a component The two block matrices, Representative based on Partial pseudo-inverse expression, represent continuously increasing i A matrix of rows, Representing the r +1 fuzzy rule antecedent matrix corresponding to the first i +1 line, Represents the identity matrix. represent The square root of.

5. A data processing system based on AD-TSK, characterized in that, include: Memory is used to store instructions that can be executed by the processor; A processor for executing instructions to implement the AD-TSK-based data processing method as described in any one of claims 1-4.

6. A computer-readable medium storing computer program code, characterized in that, The computer program code, when executed by a processor, implements the AD-TSK-based data processing method as described in any one of claims 1-4.

Images