Causal Multi-Label Feature Selection
in Federated Setting

In this paper, we simulate a federated environment using a client-server architecture, and propose the FedCMFS algorithm for causal multi-label feature selection in federated setting. FedCMFS is a horizontal federated learning algorithm, which uses a central server and multiple clients to perform causal feature selection on standard multi-label data. Specifically, FedCMFS sequentially executes the following three subroutines to select causal features: (1) Federated Causal Feature Learning algorithm (FedCFL); (2) Federated Causal Feature Retrieval algorithm (FedCFR); and (3) Federated Causal Feature Correction algorithm (FedCFC).

FedCFL treats both labels and features as ordinary variables, and it independently computes local causal variables for each label on each client. Throughout local causal structure learning, the clients interact with the server, ultimately obtaining causally relevant feature sets for all label variables: $PC\left(Y\right)=\{CPC\left(Y_{1}\right),CPC\left(Y_{2}\right),...,CPC\left(Y_{q}\right)\}$ for all labels on the server.

To tackle the issue of missing true relevant features, in FedCFR, the server communicate with each client to selectively identify potentially missing true relevant features, obtaining an updated causally relevant feature sets for all label variables: $PC_{SR}=\{PC\left(Y_{1}\right),PC\left(Y_{2}\right),\ldots,PC\left(Y_{q}\right)\}$.

Due to the data quality issue, utilizing the symmetry property of causal neighbors, FedCFC selectively corrects false causally relevant features in $PC_{SR}$ and achieves the final feature set $sel=PC\left(Y_{1}\right)\cup PC\left(Y_{2}\right)\cup\ldots\cup PC\left(Y_{q}\right)$.

HITON-PC [26] is a widely used algorithm for learning a PC set of a given variable from a single-label dataset, which adopts a forward-backward strategy, exhibiting notable performance in causal feature learning. In this paper, we extend HITION-PC to the learn PC set of a label variable for multi-label data in federated setting and propose the federated causal feature learning algorithm, FedCFL, to address the causal multi-label feature selection problem in federated setting.

A simple strategy for applying the HITON-PC algorithm to multi-label feature selection in federated setting is that each client learns a PC set independently for each label variable, and then aggregates the PC sets at the service. However, due to the different quality of samples from different clients, the PC sets of a given label variable learned from different clients are often different. To deal with this issue, we design the FedCFL algorithm consisting of two learning phases, as shown in Alg. 1.

In Phase I of FedCFL, we initially identify potential PC variables for each class label, where the variables contain both features and labels, so that correlations between not only label-features, feature-features, but also label-labels can be learned in the process of learning the local causal structure. The computation for this phase is carried out at each client and ultimately converges at the server. Assuming that there are $N$ clients (denoted as client 1, client 2, …, client N) and one server. At the beginning of phase I, upon the server’s request, each client independently computes the correlation value $C_{n<Y_{i},V_{k},\emptyset>}$ and the P value $P_{n<Y_{i},V_{k},\emptyset>}$ between each class label $Y_{i}$ and the other variables $V_{k}\in V\setminus Y_{i}$ on a local client, using the empty set as the condition set via conditional independence tests. The node $V_{k}$, correlation value $C_{n<Y_{i},V_{k},\emptyset>}$ and P value $P_{n<Y_{i},V_{k},\emptyset>}$ are then added to the initial correlation set $M_{ni}^{\prime}$ (where $n$ represents the client number $n\ \in 1,2,\ldots,N$, and $i$ represents the label number $i\ \in 1,2,\ldots,q$). After computing the correlations of all labels and all features, each client obtains a local initial correlation set $M_{n}^{\prime}=\{M_{n1}^{\prime},M_{n2}^{\prime},\ldots,M_{nq}^{\prime}\}$, which includes the initial correlation sets $M_{ni}^{\prime}$ for all class labels. Each client sends the learned local initial correlation set $M_{n}^{\prime}$ to the server.

The server receives the local initial correlation sets $M_{1}^{\prime},M_{2}^{\prime},\ldots,M_{N}^{\prime}$ learned by all clients, merges and prunes them according to Eq. 1 to obtain the global initial correlation set $M=\{M_{1},M_{2},\ldots,M_{q}\}$. Specifically, for each node $V_{k}$ that may be dependent with the target label $Y_{i}$, the server computes the weighted average $P_{<Y_{i},V_{k},\emptyset>}$ of the P value $P_{n<Y_{i},V_{k},\emptyset>}$ of the pair of variables $Y_{i}$ and $V_{k}$ across all clients. Assuming that a client with a large number of data samples may have a higher probability of representing the true statistical patterns, we assign the weight of each client, $W_{n}$, based on the proportion of data with regard to the total data samples across all clients.

If the weighted P value $P_{<Y_{i},V_{k},\emptyset>}$ is less than the significance level $\alpha$, the server determines that $Y_{i}$ and $V_{k}$ are not independent given the empty set as the condition set and computes the weighted average $C_{<Y_{i},V_{k},\emptyset>}$ of the correlation value $C_{n<Y_{i},V_{k},\emptyset>}$ of the pair of variables $Y_{i}$ and $V_{k}$ across all clients according to Eq. 2. Subsequently, the server adds $C_{<Y_{i},V_{k},\emptyset>}$, $P_{<Y_{i},V_{k},\emptyset>}$, and $V_{k}$ to $M_{i}$.

After the global initial correlation set $M_{i}$ for each label is completed, the server sorts the variables in $M_{i}$ by the weighted correlation value $C_{<Y_{i},V_{k},\emptyset>}$ in descending order. Finally, the global initial correlation set $M=\{M_{1},M_{2},\ldots,M_{q}\}$ is obtained at the server.

In Phase II of FedCFL, we utilize a forward-backward strategy to progressively update the variables in the candidate parent and children set $CPC\left(Y_{i}\right)$ (initially $CPC\left(Y_{i}\right)$ is an empty set $\emptyset$) until a complete local causal structure is learned. To reduce the number of conditional independence tests, the computation performed by each client in Phase II is uniformly controlled by the server. The server sequentially adds the variable with the highest weighted correlation value in $M_{i}$, along with its corresponding weighted correlation value $C_{<Y_{i},V_{k},\emptyset>}$ and weighted P value $P_{<Y_{i},V_{k},\emptyset>}$, to the candidate set $CPC\left(Y_{i}\right)$. Whenever a new variable $X$ is added to $CPC\left(Y_{i}\right)$, the server needs to determine whether each variable $V_{k}$ in the current $CPC\left(Y_{i}\right)$ will be independent of the target label $Y_{i}$ under the condition that the new variable is added, and prune the $CPC\left(Y_{i}\right)$ based on the above result. Therefore, the server sends the triplet $<Y_{i},V_{k},CS>$ (where $Y_{i}$, $V_{k}$ are the variables to be tested, and $CS$ is the conditional set, $CS\subset CPC\left(Y_{i}\right)\setminus V_{k})$ to all clients, requesting each to conduct the corresponding conditional independence tests.

Once receiving the triplet $<Y_{i},V_{k},CS>$, each client independently conducts conditional independence tests between $Y_{i}$ and $V_{k}$ given the condition set $CS$, and subsequently returns the P value $P_{n<Y_{i},V_{k},CS>}$ between $Y_{i}$ and $V_{k}$ to the server.

Subsequently, the server receives the results from all clients and computes the weighted average $P_{<Y_{i},V_{k},CS>}$ of the P value $P_{n<Y_{i},V_{k},CS>}$ under $<Y_{i},V_{k},CS>$ across all clients according to Eq. 1 (the weight of each client is the proportion of data contained in that client out of the total data volume of all clients.). If the weighted P value $P_{<Y_{i},V_{k},CS>}$ exceeds the significance level $\alpha$, $Y_{i}$ is independent of $V_{k}$, and $V_{k}$ along with its corresponding $C_{<Y_{i},V_{k},\emptyset>}$ and $P_{<Y_{i},V_{k},\emptyset>}$ are removed from $CPC\left(Y_{i}\right)$, otherwise they are retained.

The server and each client interact to execute the aforementioned steps, and the server achieves the $PC$ set $PC\left(Y\right)=\{CPC\left(Y_{1}\right),CPC\left(Y_{2}\right),...,CPC\left(Y_{q}\right)\}$, which is a collection that not only contains the causal feature sets of each class label, but also includes the weighted correlation of the variables with their corresponding labels with an empty conditioning set. The completion of this step signifies the ending of the FedCFL algorithm.

In FedCFL, all labels and features are treated as ordinary variables to simultaneously consider three types of correlations among variables in a multi-label dataset: feature-label, feature-feature, and label-label correlations. However, due to the correlation among labels, some true PC features may become independent of the labels, resulting in missing true PC features.

Taking the structure shown in the Figure 4 as an example, suppose the PC set of the class label C consists of ${A,B,E}$. Due to the correlation between class label C and class label D, feature E, which serves as a parent node of the class label C, is not selected to the PC set of C. Therefore, to tackle this issue, we design the Federated Causal Feature Retrieval algorithm (FedCFR) and its pseudocodes are shown in Alg. 2.

The initial step of Phase I in FedCFR involves identifying potential missed PC features from all discarded features. From Steps 3 to 15, the FedCFR subroutine determines whether each label $Y_{i}\in Y$ needs to selectively retrieve missed PC features by judging whether its $PC\left(Y_{i}\right)$ contains other class labels. If $PC\left(Y_{i}\right)$ contains the label $Y_{k}$ ($k=1,\ldots,q$ and $k\neq i$), the possible missed PC features are searched for in discarded variables other than the selected features (i.e., $F_{j}\in F\setminus PC\left(Y_{i}\right)$). The judgment rule is: if $F_{j}\in F\setminus PC\left(Y_{i}\right)$ and $F_{j}\mathbin{\mathchoice{\hbox to0.0pt{\hbox{$\displaystyle\perp$}\hss}\kern 3.46875pt{\not}\kern 3.46875pt\hbox{$\displaystyle\perp$}}{\hbox to0.0pt{\hbox{$\textstyle\perp$}\hss}\kern 3.46875pt{\not}\kern 3.46875pt\hbox{$\textstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptstyle\perp$}\hss}\kern 2.36812pt{\not}\kern 2.36812pt\hbox{$\scriptstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptscriptstyle\perp$}\hss}\kern 1.63437pt{\not}\kern 1.63437pt\hbox{$\scriptscriptstyle\perp$}}}Y_{i}\mid\emptyset$, it is considered to be a possible missed PC feature and added to the candidate feature set $sel\left(Y_{i}\right)$.

To aggregate the conditional independence test results among all clients in federated setting, the server sequentially sends the triplet $<Y_{i},F_{j},\emptyset>$ to all clients, requesting each client to perform the conditional independence tests with the empty set as the conditioning set and returning their results $C_{n<Y_{i},F_{j},\emptyset>}$ and $P_{n<Y_{i},F_{j},\emptyset>}$. Upon receiving the returned results from all clients, the server performs the calculations according to Eq. 1 and Eq. 2. If the weighted average of the returned results from all clients $P_{<Y_{i},F_{j},\emptyset>}$ is less than the significance level $\alpha$, it is considered dependent. The variable and its corresponding $C_{<Y_{i},F_{j},\emptyset>}$ and $P_{<Y_{i},F_{j},\emptyset>}$, are then added to $sel\left(Y_{i}\right)$. Otherwise, it is considered independent.

Recent research has shown that a causal structure in real-world scenarios is often relatively sparse [27, 28]. For instance, in a dataset containing 1000 features, a class variable may only have 10 PC features. This implies that the discarded set $sel\left(Y\right)$ contains very few missed PC features. If all variables in $sel\left(Y\right)$ are tested, it would cost a significant amount of time. Among those candidate variables, the variables with high correlations to a class variable are most likely to be the missed PC features. Thus in Step 8, FedCFR addresses this issue by sorting the candidate feature set in descending order according to the weighted correlation value $C_{<Y_{i},F_{j},\emptyset>}$ with the empty conditioning set, then selects the top $k_{1}$% variables.

In the second phase, FedCFR utilizes the available structural information to determine candidate features that may have been missed by FedCFL. Taking Figure 4 as an example, supposing the learned PC set of label C is $PC(C)=\{A,B,D\}$, and E has not been correctly added to the PC set. After the first phase of FedCFR, feature E is added to the candidate feature set $sel(C)$. In this case, there must exist a set $S$ containing the class label D such that $C\mathbin{\mathchoice{\hbox to0.0pt{\hbox{$\displaystyle\perp$}\hss}\kern 3.46875pt{}\kern 3.46875pt\hbox{$\displaystyle\perp$}}{\hbox to0.0pt{\hbox{$\textstyle\perp$}\hss}\kern 3.46875pt{}\kern 3.46875pt\hbox{$\textstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptstyle\perp$}\hss}\kern 2.36812pt{}\kern 2.36812pt\hbox{$\scriptstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptscriptstyle\perp$}\hss}\kern 1.63437pt{}\kern 1.63437pt\hbox{$\scriptscriptstyle\perp$}}}E\mid S$. If the class label D is removed from $S$, C will be dependent of E.

Therefore, the server traverses $\forall Y_{i},Y_{j}\in Y$, and when class label $Y_{j}$ appears in $PC\left(Y_{i}\right)$ of the class label $Y_{i}$, it examines the top $k_{1}$% variables in the candidate feature set $sel\left(Y_{i}\right)$. If a set $S:Y_{j}\subset S\subset PC\left(Y_{i}\right)$ is found such that $X\in sel\left(Y_{i}\right)$ and $X\mathbin{\mathchoice{\hbox to0.0pt{\hbox{$\displaystyle\perp$}\hss}\kern 3.46875pt{}\kern 3.46875pt\hbox{$\displaystyle\perp$}}{\hbox to0.0pt{\hbox{$\textstyle\perp$}\hss}\kern 3.46875pt{}\kern 3.46875pt\hbox{$\textstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptstyle\perp$}\hss}\kern 2.36812pt{}\kern 2.36812pt\hbox{$\scriptstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptscriptstyle\perp$}\hss}\kern 1.63437pt{}\kern 1.63437pt\hbox{$\scriptscriptstyle\perp$}}}Y_{i}\mid S$, and $X\mathbin{\mathchoice{\hbox to0.0pt{\hbox{$\displaystyle\perp$}\hss}\kern 3.46875pt{\not}\kern 3.46875pt\hbox{$\displaystyle\perp$}}{\hbox to0.0pt{\hbox{$\textstyle\perp$}\hss}\kern 3.46875pt{\not}\kern 3.46875pt\hbox{$\textstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptstyle\perp$}\hss}\kern 2.36812pt{\not}\kern 2.36812pt\hbox{$\scriptstyle\perp$}}{\hbox to0.0pt{\hbox{$\scriptscriptstyle\perp$}\hss}\kern 1.63437pt{\not}\kern 1.63437pt\hbox{$\scriptscriptstyle\perp$}}}Y_{i}\mid S\setminus Y_{j}$, then $X$ is considered a missed PC feature. $X$ and its corresponding $C_{<X,Y_{i},\emptyset>}$ and $P_{<X,Y_{i},\emptyset>}$ are added to $PC\left(Y_{i}\right)$.

To coordinate all clients to complete the above operations in federated setting, the server sends the triplet $<X,Y_{i},S>$ to all clients and receives the results returned by each client. It then uses Eq. 1 to obtain the weighted P value $P_{<X,F_{j},S>}$. If the weighted P value $P_{<X,F_{j},S>}$ exceeds the significance level $\alpha$, it is considered independent. The server then sends the triplet $<X,Y_{i},S\setminus Y_{j}>$ to each client and confirms whether the $P_{<X,F_{j},S\setminus Y_{j}>}$ results are dependent. After the successful completion of both tests, $X$, $C_{<X,Y_{i},\emptyset>}$ and $P_{<X,Y_{i},\emptyset>}$ are added to $PC\left(Y_{i}\right)$. When all operations against $Y_{j}$ in $sel\left(Y_{i}\right)$ are completed, the label $Y_{j}$ is removed from $PC\left(Y_{i}\right)$. After the execution of the FedCFR algorithm, the set of the missed PC features is obtained, denoted as $PC_{SR}=\{PC\left(Y_{1}\right),PC\left(Y_{2}\right),\ldots,PC\left(Y_{q}\right)\}$.

In the first two subroutines of FedCMFS, the uneven quality of data across clients may lead to erroneous aggregation results using the conditional independence tests. It means that both FedCFL and FedCFR may learn false PC variables. To remove these false PC variables in $PC\left(Y_{i}\right)$ (obtained by FedCFL and FedCFR), by the symmetry property of a parent and its children in a DAG (if A is a parent of B, then B must be a child of A), we design the FedCFC subroutine which examines whether the PC of a variable in $PC\left(Y_{i}\right)$ includes $Y_{i}$, to eliminate false PC features in $PC\left(Y_{i}\right)$. The pseudocodes of the FedCFC algorithm is provided below.

Given that the true $PC\left(Y_{i}\right)$ contains fewer false features, the features with the smaller correlation to the class variable are more likely to be mistakenly selected. To avoid calculating the PC of all variables in $PC\left(Y_{i}\right)$, the server initially sorts the weighted correlation value with an empty set and store them in ascending order. It then selects the top $k_{2}\%$ features with the smallest correlations to the class label $Y_{i}$ to be included in the correction set $CanF\left(Y_{i}\right)$.

In Steps 3 to 9, the FedCFC Algorithm applies the FedCFL algorithm to the feature in $F_{j}\in CanF\left(Y_{i}\right)$ and obtains the result at the server. It then determines whether the set $PC\left(F_{j}\right)$ of the feature $F_{j}$ contains the label $Y_{i}$. If not, $F_{j}$ is removed from the set $PC\left(Y_{i}\right)$ of $Y_{i}$. After the correction process for all labels is completed, the finally selected feature set $sel=PC\left(Y_{1}\right)\cup PC\left(Y_{2}\right)\cup\ldots\cup PC\left(Y_{q}\right)$ is obtained.

The three subroutines of FedCMFS all involve conditional independence tests (CI tests). Thus the time complexity of FedCMFS can be measured by the number of CI tests performed by a single client. The time complexity of FedCMFS is relatively high, with the time complexity of the subroutine FedCFL being $O((m+q)q2^{|PC(V)|})$, the time complexity of the subroutine FedCFR being $O(mq^{2}2^{|PC(V)|})$, and the time complexity of the subroutine FedCFC being $O(|PC|mq2^{|PC(V)|})$. This indicates that the number of CI tests performed is exponentially related to the size of the learned PC set. As the dimensionality of the dataset increases, the learned PC set may become larger, and the number of tests correspondingly increases. Therefore, to improve the execution speed of FedCMFS, this paper proposes the following three strategies to accelerate CI tests by leveraging the parallel computing ability of GPU.

The first strategy involves data-level parallel processing for two types of CI tests: the G² test [29] for discrete data and the Fisher’s Z test [29] for continuous data. A brief introduction to these two CI testing methods is provided below.

Assuming that variables $X_{i}$ and $X_{j}$ are conditionally independent given $X_{k}$, the formula for the G² test algorithm is as follows:

$G^{2}$ is a statistic, $S_{ijk}^{abc}$ is a random variable, whose value is the number of times $X_{i}=a$, $X_{j}=b$, and $X_{k}=c$ simultaneously occur in a data sample. The null hypothesis of independence is rejected by calculating the p-value of the $G^{2}$ statistic and comparing it to a predetermined level of significance.

Assuming that variables $X_{i}$ and $X_{j}$ are conditionally independent given $S$, the formula for the Fisher’s Z test algorithm is as follows:

$Z$ is a statistic, $M$ is the sample size, and $R$ denotes a random variable whose value is the partial correlation coefficient of $X_{i}$ and $X_{j}$ given the condition set $S$. The null hypothesis of independence is rejected by calculating the p-value of the $Z$ statistic and comparing it to a predetermined level of significance.

GPUs have many processing cores that can handle multiple data streams simultaneously, enabling massively parallel computing. In this paper, we fully utilize the parallel computing capabilities of GPUs to implement the parallel computation of the G² test and Fisher’s Z test. Next, we will take the calculation of $S_{ijk}^{abc}$ as an example to explain in detail.

When calculating $S_{ijk}^{abc}$, for each sample in the dataset, all possible combinations of $S_{ijk}$ are traversed to determine whether $X_{i}=a$, $X_{j}=b$, and $X_{k}=c$ are satisfied, and the count is updated accordingly. Assuming $X_{i}$, $X_{j}$, and $X_{k}$ each have 100 values, in the worst case, $10^{6}$ conditional judgments need to be performed to ensure that all possible combinations are considered.

On the GPU, $S_{ijk}$ is organized as a three-dimensional tensor, with each dimension corresponding to $X_{i}$, $X_{j}$, and $X_{k}$ respectively. For the dimension of the variable $X_{i}$, the task of finding an index with the value $a$ is assigned in parallel to multiple processing units. Each processing unit is responsible for determining whether a value in the $X_{i}$ dimension is equal to $a$, and if so, returning the index. Similarly, the indexes with values $b$ and $c$ are found in the $X_{j}$ and $X_{k}$ dimensions using the same method. After obtaining the indexes, $S_{ijk}^{abc}$ is updated by incrementing the corresponding count. Using this parallelization method, only three parallel operations on the GPU are required to perform a task that would otherwise take $10^{6}$ operations on the CPU, resulting in a significant increase in computational speed.

The second strategy is the vectorized parallelization of Fisher’s Z test. Function vectorization involves applying a function to each element of a vector, allowing multiple data elements to be processed simultaneously. For example, consider the simple function $f(x)=x^{2}$. If this function is vectorized, then for a vector $x$ containing multiple elements, the square of each element can be computed directly without the need for an explicit loop to compute them one by one.

In this paper, Fisher’s Z test is treated as a function and its vectorized parallelism is implemented on GPUs. When dealing with continuous data, the execution process of the FedCMFS algorithm is optimized such that the server sends all CI test requests of the current phase to the client in batches. The client then executes all test requests in parallel, instead of using an explicit loop to perform the tests sequentially, and returns all the results to the server at once. Next, the first phase of the FedCFL subroutine is described in detail as an example.

In the first phase of FedCFL, the server sends requests to the clients to perform tests on $Y_{i}$ and $V_{k}$ under the empty set ($\emptyset$) one at a time. Clients perform these tests sequentially, with each client needing to conduct $q\times(m+q-1)$ CI tests.

After using the vectorized parallelization of Fisher’s Z test, as shown in Algorithm 4, the server records all triples $(Y_{i},V_{k},\emptyset)$ into $vecinput$ and sends $vecinput$ to all clients. Upon receiving it, clients perform CI tests in batches. The tests within the same batch are executed in parallel on the GPU, and the results are recorded into $vecoutput$. Subsequently, clients extract $C_{n<Y_{i},V_{k},\emptyset>}$ and $P_{n<Y_{i},V_{k},\emptyset>}$ from $vecoutput$ and add them to $M^{\prime}_{ni}$. Finally, clients send $M^{\prime}_{n}$ back to the server. The batch size needs to be set according to the GPU’s performance. If the batch size is set to 100, each client only needs to execute $q\times(m+q-1)/100$ batches of CI tests.

The third strategy is the CI test recording mechanism. Sometimes, two variables under the same condition set have already been tested, but a duplicate test is performed in a subsequent run, resulting in a waste of computational resources. We record the results of each test in the CI test record. Before executing a test, we first check the CI test record to see if a corresponding record already exists. If it does, the result in the record is used directly without repeating the test; if not, the test continues to be executed. This mechanism effectively reduces the number of CI tests and accelerates the algorithm.

To evaluate the effectiveness of FedCMFS, we use eight real-datasets to simulate the federated setting. The specific information of the eight real-datasets is shown in Table II.

We select six commonly used multi-label metrics to evaluate the performance of the methods, including Average precision (AP), Coverage (CV), Hamming loss (HL), Rank loss (RL), Macro-F1 (Fma), and Micro-F1 (Fmi). Suppose there is a multi-labeled dataset $D=\{\left(f_{i},Y_{i}\mid 1\leq i\leq s\right)\}$, where $f_{i}$ and $Y_{i}$ are the feature set and label set corresponding to the current $i$th sample, respectively. The ranking function $rank_{i}\left(y\right)$ denotes the predicted ranking of the $i$th sample corresponding to label $y$. The detailed explanation of the six evaluation metrics is as follows:

(1) Average precision: the average of the scores of the correct labels for evaluating label alignment, where $AP\left(D\right)\in\left[0,1\right]$, the higher value the better performance is.

(2) Coverage: the average of the number of steps required by the sample to traverse all labels, the smaller value of $CV\left(D\right)$ the performance is.

(3) Hamming loss: it is used to evaluate the proportion of samples that are incorrectly matched. Here, $q$ stands for the number of labels, $Z_{i}$ is the predicted label set, $Y_{i}$ represents the true label set of the current $i$th sample, and $\Delta$ is the symmetric difference between the predicted and the true label sets. $HL\left(D\right)\in\left[0,1\right]$, the smaller value the better performance is.

(4) Ranking Loss: evaluate the ranking of relevant labels over irrelevant labels for the samples, $RL\left(D\right)\in\left[0,1\right]$, the smaller value the better performance is.

(5)Macro-F1: arithmetic mean of F1 scores.

(6)Micro-F1: weighted average of F1 scores.

The two metrics mentioned above consider both the recall and precision of the model. Here, $TP_{i}$ represents the number of true positives in the model’s predictions, while $FP_{i}$ and $NP_{i}$ represent the number of false positives and false negatives, respectively. $Macro-F1,Micro-F1\in\left[0,1\right]$, and a larger value indicates better performance.

There are no existing multi-label feature selection methods designed in federated environments for preserving data privacy. To validate our FedCMFS, we select five state-of-the-art feature selection methods, MB-MCF (Markov blanket-based multi-label causal feature selection) [5], GLFS (Group-preserving label-specific feature selection for multi-label learning) [30], PDMFS (Parallel Dual-channel Multi-label Feature Selection) [31], GRROOR (Global Redundancy and Relevance Optimization in Orthogonal Regression for Embedded Multi-label Feature Selection) [32], and PMFS (Pareto-based feature selection algorithm for multi-label classification) [33], and then we adopt a simple strategy to make the above five comparison algorithms work in federated setting. Specifically, for each comparison algorithm, each client independently executes the algorithm locally. Once all clients have completed their execution, they send the evaluation metric results to the server. The server then calculates a weighted average (with weights being the proportion of the data contained in each client to the total data volume) and records the weighted average of the evaluation metrics from all clients as the final result for comparison.

All experiments were conducted on a Ubuntu server equipped with an Intel(R) Xeon(R) Platinum 8375C CPU @2.90GHz CPU, 64GB of memory, and an NVIDIA A100-SXM 40GB GPU. The programming environment utilized was Python 3.8, with PyTorch version 2.1.0. The batch size was set to 100.

For FedCMFS algorithm proposed in this paper, parameters $k_{1}$ and $k_{2}$ for FedCFR and FedCFC are set within $\left(0,0.3\right]$. The significance level for conditional independence tests is $\alpha=0.05$. All other comparison algorithms used default parameter settings.

The ML-KNN [34] method is chosen for the experiments to evaluate the results of federated feature selection, which is a widely adopted classifier in multi-label learning(any other multi-label classification algorithms can be used here), and the parameter $k$ of the algorithm is set to 10 according to the default setting. Among all the algorithms, only MB-MCF algorithm selects a fixed number of features, while other comparison algorithms select features randomly. To effectively track metric variations in the final feature subset, all algorithms, except for MB-MCF, align with the FedCMFS algorithm using the identical number of features for federated causal multi-label feature selection.

To simulate the federated setting, this study assumes a total of $N$ clients, where $N\ \in\{3,5,10\ \}$, each with $W_{n}$ data items. The data division method for the simulated federated setting is as follows: (1) For smaller datasets: CHD_49, VirusGo, Yeast, Flags, and Image, each client randomly extracts $40\%-60\%$ of the original training set data from the real dataset without repetition to construct their dataset. (2) For larger datasets: Slashdot, Business, and Education, each client randomly extracts $30\%-50\%$ of the original training set data from the real dataset without repetition to construct their dataset. Although the data within a client is unique, there may be data overlap among different clients.

The comparison results of the six algorithms, FedCMFS, MB-MCF, GLFS, PDMFS, GRROOR, and PMFS are shown in Tables III to VIII. In the table, the optimal results are shown in bold, with higher ↑ values being better, lower ↓ values being better, and Average representing the average ranking of the current method among the six methods.