## 4 Results and Discussion
### Experiment IV: The Performance of Classifier Trees Based on Various Models  
The three experiments conducted above aim to train each classifier in the classifier tree from different perspectives, enabling the identification of the best model and method for each direction. Experiment IV in this section, however, focuses on the classification scenario of PGT by treating the classifier tree, whose purpose is to evaluate various models and methods using the final classification results to determine the optimal one. This experiment is based on the results of the training stages of all classifiers obtained from the previous three experiments. It requires all 27 classifiers to be trained independently using the model as a unit to be assembled according to a multi-label tree, which associates labels with classifiers and converts the label tree into an instance of the classifier tree. The detailed process is shown in Algorithm 1. ```
\(N\) # the number of classifiers in a classifier tree. Input: The classifier information set of classifier tree \(ClassifierTree\) is composed of classifiers instances set \(Classifiers\) and the class-classifier relationship collection of all classifiers \(RCs\) (Note: All classifiers are named as classifier no. above). Output: The root classifier \(rootClassifier\) of the classifier tree contains the structure of a complete classifier tree instance, which can be used to calculate the leaf node labels for PGT. 1: Classifiers = ClassifierTree.Classifiers
2:\(RCs\) = ClassifierTree.RCs
3:\(For\)\(j=1\) to \(N\) Do
4: classifier = Classifiers[j]
5: classifier.load checkpoint() # load model checkpoint from.tar file. 6:\(rc\) = \(RCs\)[classifier.name] # get class-classifier relationship for this classifier. 7: classifier.rc = \(rc\) # rc is a dictionary, the keys of which are classes of the classifier, and the values are the collection of the corresponding classifier no
8: Return rootClassifier = ClassifierTree.getClassifier (\"C00000\") # C00000 is the name of the root node classifier in the classifier tree. Figure 9: Comparison of training advantages of the model XLNet + BiLSTM + HA + FC using TL or not (design concept is identical to Figure 7). In the classifier tree, the test samples start from the root node classifier individually and turn to the corresponding classifier based on the classification results of each classifier they experience until they reach the leaf node of the label tree (this process is shown in Algorithm 2). Theoretically, in the prediction process of all test samples, a maximum of four classifiers are loaded for each test sample. However, the prediction of all samples requires the loading of 27 classifiers. The memory required for each classifier's checkpoint after loading is 632 MB; therefore, the total memory required for the testing program is approximately 17 GB, much larger than the graphics memory size used in this experiment. We preload all models into memory during the experimental process to solve this problem and wait until a specific classifier is needed for prediction before loading the classifier and data into the graphics memory. After use, we promptly migrate them to memory. In this manner, the time cost of the model's spatial migration in graphics and memory is exchanged for the computational performance of the classifier model in graphics, and the average prediction time for each sample is reduced to 0.8 s.
```
1:\(M\) # the number of examples. 2:Input: rootClassifier is the root node of the classifier tree; P is the set of examples; L is the set of labels. 3:Output: Y is the leaf label predicted. 4:For i = 1 to M Do
5:\(p=Pl[i]\)
6:\(l=L[i]\)
7:\(y=rootClassifier.predict(text=p,\,tralabel=l)\)
8:\(Yappend(y)\)
9:Return Y
```

**Algorithm 2** The prediction of the classifier tree for PGT

We use the above algorithm to construct the corresponding classifier trees for the eight models involved in this study and conduct classification performance tests using the same set of test samples.