Hierarchical multi-label text classification (HMTC) aims to tag each document with a set of classes from a class hierarchy. Most existing HMTC methods train classifiers using massive human-labeled documents, which are often too costly to obtain in real-world applications. In this paper, we explore to conduct HMTC based on only class surface names as supervision signals. We observe that to perform HMTC, human experts typically first pinpoint a few most essential classes for the document as its core classes, and then check core classes' ancestor classes to ensure the coverage. To mimic human experts, we propose a novel HMTC framework, named TaxoClass. Specifi-cally, TaxoClass (1) calculates document-class similarities using a textual entailment model, (2) identifies a document's core classes and utilizes confident core classes to train a taxonomy-enhanced classifier, and (3) generalizes the classifier via multi-label self-training. Our experiments on two challenging datasets show TaxoClass can achieve around 0.71 Example-F1 using only class names, outperforming the best previous method by 25%. Hierarchical multi-label text classification (HMTC) aims to assign each text document to a set of relevant classes from a class taxonomy. As a fundamental task in NLP, HMTC has many applications such as product categorization (Goumy and Mejri, 2018), semantic indexing (Li et al., 2019), and fine-grained entity typing (Xu and Barbosa, 2018). Most existing methods address HMTC in a supervised fashion  they first ask humans to provide many labeled documents and then train a text classifier for prediction. Many classifiers have been developed with different deep learning architectures such as CNN (Kim, 2014), RNN (You et al., 2019), Attention Network (Huang et al., 2019), and achieved decent performance when trained on massive human-labeled documents. Despite such a Document : When our son was about 4 months old, our doctor said we could give him crafted cereal. success, people find that applying these methods to many real-world scenarios remains challenging as the human labeling process is often too time-consuming and expensive. Recently, more studies have been developed to address text classification using smaller amount of labeled data. First, several semi-supervised methods (Gururangan et al., 2019; Berthelot et al., 2019) propose to use abundant unlabeled documents to assist model training on labeled dataset. Although mitigating the human annotation burden, these methods still require a labeled dataset that covers all classes, which could be too expensive to obtain when we have a large number of classes in HMTC. Second, some weakly-supervised models exploit class indicative keywords (Meng et al., 2018; Zeng et al., 2019; Mekala and Shang, 2020) or class surface names (Meng et al., 2020; Wang et al., 2020) to derive pseudo-labeled data for model training. Nevertheless, these models all assume each document has only one class and all class surface names (or class indicative keywords) must appear in the corpus, which are too restrictive for HMTC. In this paper, we study the problem of weakly-supervised hierarchical multi-label text classification where only class surface names, a class taxonomy, and an unlabeled corpus are available for model training. This setting is closer to how humans resolve the HMTC problem  we perform classification by understanding each class from its surface name rather than learning from labeled documents. We observe that when asked to assign multiple classes to a document, humans will first pinpoint most essential core classes and then check whether their ancestor classes in the taxonomy should also be tagged. Taking the document in Fig. 1 as an example, humans can quickly identify this review text is clearly about  baby cereal  and  crafted cereal , which are the core classes. After assigning these two most essential classes to the document, people continue to check the core classes' ancestor classes and find  feeding  as well as  baby food  should be tagged. Motivated by the above human labeling process, we propose TaxoClass , a weakly-supervised HMTC framework including four major steps. First, we calculate the document-class similarity using a pre-trained textual entailment model (Yin et al., 2019). Second, we identify each document's core classes by (1) selecting candidate core classes that are most similar to the document at each level in a top-down fashion, and (2) choosing (cid:104) document, candidate core class (cid:105) pairs that are salient across the whole unlabeled corpus. Third, we derive training data from document core classes and use them to train a text classifier. This classifier includes a document encoder based on pre-trained BERT (De-vlin et al., 2019), a class encoder capturing class taxonomy structure, and a text matching network computing the probability of a document being tagged with each class. Finally, we generalize this text classifier using multi-label self-training on all unlabeled documents. Contributions. To summarize, our major contributions are as follows: (1) We propose a weakly-supervised framework TaxoClass that only requires class surface names to perform hierarchical multi-label text classification. To the best of our knowledge, TaxoClass is the first weakly-supervised HMTC method. (2) We develop an unsupervised method to identify document core classes based on which a text classifier can be learned. (3) We conduct extensive experiments to verify the effectiveness of TaxoClass on two real-world datasets. In this section, we introduce the notations and present our task definition. Notations . A corpus D = { D 1 , . . . , DN } is a text collection where each document D i  D is a sequence of words. A class taxonomy T = ( C , R ) is a directed acyclic graph where each node represents a class c j and each directed edge (cid:104) c m , c n (cid:105)  R indicates that parent class c m is more general than the child class c n . In this work, we assume each class c j has a surface name s j (either a word or a phrase) that serves as the weak supervision signal. Task Definition . Given an unlabeled corpus D , a class hierarchy T = ( C , R ) , and class surface names S = { s j } |C| j =1 , our task is to learn a text classifier f (  ) that maps a new document D new to its target y = [ y 1 , . . . , y |C| ]  Y = { 0 , 1 } |C| where y j equals to 1 if this document is categorized with class c j and 0 otherwise. Discussion. When the number of classes |C| is large (as it is in many HMTC applications), we can no longer assume all class surface names in S will explicitly appear in the given corpus D as done in most previous studies (Meng et al., 2019; Li et al., 2019; Wang et al., 2020). This is because many class names are actually summarizing phrases provided by humans ( e.g. ,  grocery & gourmet food  in Fig. 1). As a result, we need to design a method that works under such a scenario. Our TaxoClass framework consists of four major steps: (1) document-class similarity calculation, (2) document core class mining, (3) core class guided classifier training, and (4) multi-label self-training. Fig. 2 shows our framework overview and below sections discuss each step in more details. We take a textual entailment approach (Yin et al., 2019) to calculate the semantic similarity between each (cid:104) document, class (cid:105) pair. This approach imitates how humans determine whether a document is similar to a class or not  we read this document, create a hypothesis by filling the class name into a template ( e.g. ,  this document is about ), and ask ourselves to what extent this hypothesis is correct, given the context document. premise, a template filled with a class name s j as the hypothesis, and outputs a probability of how likely this premise can entail the hypothesis. We treat this probability P ( D i  c j ) as the document-class similarity sim ( D i , c j ) . More specifically, we use Roberta-Large-MNLI 1 as our textual entailment model which utilizes the pre-trained Roberta-Large as its backbone and is fine-tuned on the MNLI dataset. When asked to tag a document with a set of classes from a class taxonomy, humans will first pinpoint a few classes that are most essential to this document. We refer to those most essential classes as the core classes and identify them in below two steps. We observe that on average each document is tagged with a small set of classes from the entire class taxonomy. Therefore, we first reduce the search space of core classes using a top-down approach (c.f. Fig. 3). Given a document D , we start with the  Root  class at level l = 0 , find its two children classes that have the highest similarity with D , and add them into a queue. Then, for each class at level l in the queue, we select l + 2 classes from its children classes that are most similar to D . After all level l classes are processed, we aggregate all selected children classes and choose ( l + 1) 2 classes (at level l + 1 ) with the highest path score 1 https://huggingface.co/ roberta-large-mnli ( ps ) defined below: ps ( Root ) = 1 , ps ( c j ) = max c k  Par ( c j ) { ps ( c k )  sim ( c j , D ) } , (1) where P ar ( c j ) is class c j 's parent class set. All chosen classes (at level l + 1 ) will be pushed into the queue and we stop this process when no class in the queue has further children. Finally, all classes that have entered the queue, except for the  Root  class, consist of the core class candidate set. We use C candi to denote the candidate core class set of document D i . For each document, we identify its core classes from the above selected candidate set based on two observations. First, a document usually has higher similarity with its core class c than with the parent and sibling classes of c . Take the document D 2 in Fig. 2 as an example, the similarity between D 2 and its core class  crib  is 0.95, much higher than the similarity between D 2 and core class's parent class  nursery  (0.6) as well as core class's sibling classes. Based on this observation, we define the confidence score of a candidate core class c for a document D as below: conf ( D, c ) = sim ( D, c )  max c (cid:48)  Par ( c )  Sib ( c ) { sim ( D, c (cid:48) ) } , (2) where Sib ( c ) represents the sibling class set of c . Our second observation is that the similarity between a document D and its core class c is salient from a corpus-wise perspective. Namely, if a class c is a document D 's core class, the confidence score Level l =0 Level l =1 Level l=2 0.24 Root diapering babyproduct health & personal care nursery feeding 0.1 nutritionwellness childsafety (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) 0.8 0.32 (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) sexualwellness ps ( diapering ) = ps ( baby product ) * sim ( diapering , D ) = 0.8 * 0.3 = 0.24 0.48 0.02 0.09 0.01 0.24 Root diapering babyproduct health & personal care nursery feeding 0.1 nutritionwellness childsafety (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) 0.8 0.32 (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) sexualwellness 0.48 0.02 0.09 0.01 Most likely classes are selected for expansion at the next level (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) (cid:3)(cid:17)(cid:3)(cid:17)(cid:3)(cid:17) Figure 3: Top-down core class candidate selection. conf ( D, c ) is higher than the median confidence score 2 between class c and all documents tagged with c (denoted as D ( c ) ). Formally, we have: conf ( D, c )  median { conf ( D (cid:48) , c ) | D (cid:48)  D ( c ) } . (3) According to this observation, we check each class in document D i 's candidate core set C candi and add classes that satisfy the above criteria into the final core class set C i . Note here this core class set C i could be empty when document D i does not have any confident core class. Based on identified document core classes, we train one classifier for hierarchical multi-label text classification. Below we first introduce our classifier architecture and then present our training method. We design our classifier to have a dual-encoder architecture: one document encoder maps document D i to its representation D i , one class encoder learns class c j 's representation c j , and one matching network returns the probability of document D i being tagged with class c j . Document Encoder. In this work, we instantiate our document encoder g doc (  ) to be a pre-trained BERT-base-uncased model (Devlin et al., 2019) and follow previous work (Chang et al., 2019; Meng et al., 2020) to use the [CLS] token representation as the document representation. Class Encoder. For class encoder g class (  ) , we follow (Shen et al., 2020) and use a graph neural network (GNN) (Kipf and Welling, 2017) to model the class taxonomy structure. This taxonomy-enhanced class encoder can capture both the textual information from class surface names and structural information from the class taxonomy. Given a class c j , we first obtain its ego network that includes its parent and children classes in the class taxonomy, as shown in Fig. 4. Then, we input this ego network to a GNN that propagates 2 We have also tried using "average" but empirically found that using median is better and more robust to outliers. node features over the network structure. The node features are initialized with the pre-trained word embeddings of class surface names 3 . The propagation mechanism updates the feature of a node u by iteratively aggregating representations of its neighbors and itself. Formally, we define a GNN with L -layers as follows: h ( l ) u = ReLU   (cid:88) v  N ( u )  ( l  1) uv W ( l  1) h ( l  1) v   , (4) where l  { 1 , . . . , L } , N ( u ) includes node u 's neighbors and itself,  ( l  1) uv = 1  | N ( u ) || N ( v ) | is a normalization constant (same for all layers), and W ( l  1) are learnable parameters. After obtaining individual node features, we combine them into a vector representing the whole ego network G as follows: h G = 1 | G | (cid:88) u  G h ( L ) u . As this ego network is centered on class c j and encodes its both textual and structural information, we treat this final graph representation as the class representation c j . Text Matching Network. Based on the document representation D i and the class representation c j , we use a log-bilinear text matching model to compute the probability of document D i being tagged with class c j as follows: p ij = P ( y j = 1 | D i ) =  (exp( c Tj BD i )) , (6) where  (  ) is the sigmoid function and B is a learnable interaction matrix. We use our discovered document confident core classes to train a text classifier. One intuitive strategy is to treat each document's core classes as positive classes and all the remaining classes as negative classes. However, this strategy has a high false 3 For multi-gram class names, we use their averaged word embeddings. negative rate because some non-core classes could still be relevant to the document (c.f. Fig. 1). We observe a document's multiple labeled classes usually have some ancestor-descendent relations in the class hierarchy T = ( C , R ) . This implies that given a document's core class, its parent class and some of its children classes are also likely to be tagged with this document. Therefore, we introduce all core classes' parent classes into the positive class set and exclude their children classes from the negative class set. Formally, given a document D i with its core class set C i , we define its positive and negative class set as follows: C posi =   (cid:91) c j  C i Par ( c j )    C i , C negi = C  C posi  (cid:91) c j  C i Chd ( c j ) , (7) where Chd ( c j ) is class c j 's children class set. Finally, we train our classification model using the below binary cross entropy (BCE) loss: L =  |D| (cid:88) i =1 C i (cid:54) =  ( (cid:88) c j  C posi log p ij + (cid:88) c j  C negi log(1  p ij )) , (8) where    indicates an empty set and we exclude the documents without any confident core class from the loss calculation. After training the text classifier based on document core classes, we propose to further refine the model via self-training on the entire unlabeled corpus D for better generalization. The idea of self-training (ST) (Xie et al., 2016) is to iteratively use the model's current prediction P to compute a Dataset # Train # Test # Classes Amazon-531 29,487 19,685 531 DBPedia-298 196,665 49,167 298 Table 1: Dataset statistics. target distribution Q which guides the model for re-finement. In general, the ST objective is expressed with the KL divergence loss as below: LST = KL ( Q || P ) = |D| (cid:88) i =1 |C| (cid:88) j =1 q ij log q ij p ij . Different from the previous studies (Meng et al., 2018; Yu et al., 2020), our target distribution Q can be applied to multi-label classification problem as it normalizes the current predictions P for each individual class. Intuitively, this equation can enhance high-confidence predictions while down-weighting low-confidence predictions. This is because if example i is more confidently labeled with class j than other examples, we will have a large p ij that dominates the (cid:80) i p ij term. Consequently, Eq 10 computes a large q ij , which further pushes the model to predict class j for example i . In practice, instead of updating the target distribution Q for every training example, we update it every 25 batches 4 and train the model with Eq. (9), which makes the self-training process more efficient and robust. We summarize our TaxoClass framework in Algorithm 1. We use two public datasets from different domains to evaluate our method: (1) Amazon-531 (McAuley and Leskovec, 2013) contains 49,145 product reviews and a three-level class taxonomy consisting of 531 classes; and (2) DBPedia-298 (Lehmann et al., 2015) includes 245,832 Wikipedia articles and a three-level class taxonomy with 298 classes. Documents in both datasets are lower-cased and truncated to has maximum 500 tokens. We list the data statistics in Table 1. To the best of our knowledge, we are the first to study weakly-supervised HMTC problem and there is no directly comparable baseline under the exact same setting as ours. Therefore, we choose a wide range of representative methods that are most related to TaxoClass and adapt them to our problem setting, described as follows. Hier-doc2vec (Le and Mikolov, 2014) 5 : This weakly-supervised method first embeds documents and classes into a shared semantic space, and then recursively selects the class of the highest embedding similarity with the document in a top-down fashion. We set the embedding dimensionality to be 100 and use the default value for all other hyper-parameters. 6  WeSHClass (Meng et al., 2019) 7 : Another weakly-supervised method that generates pseudo documents to pre-train a text classifier and bootstraps the pre-trained classifier on unlabeled documents with self-training. The class surface names are treated as the class-related keywords in this method. For the pseudo document generation step, we use its internal LSTM language model. We treat all classes in its returned class path as the output classes. SS-PCEM (Xiao et al., 2019) 8 : This semi-supervised method uses a generative model to generate documents based on a class path sampled from the class taxonomy. Both labeled and unlabeled documents are used to fit this generative model via the EM algorithm. Finally, it uses the posterior probability of a test document to predict its labeled classes. Among different base classifiers, we choose their author reported best variant PCEM in this study. We use 30% of labeled training documents for this method. 5 https://radimrehurek.com/gensim/ models/doc2vec.html 6 We also test the Flat-doc2vec variant which directly ranks all classes in the taxonomy and returns top ranked classes. Its performance is significantly worse than Hier-doc2vec and thus we only report Hier-doc2vec results. Hier-0Shot-TC (Yin et al., 2019) 9 : This zero-shot method uses a pre-trained textual entailment model to predict to what extent a document (as the premise text) can entail a template filled with the class name (as the hypothesis text). Similar to Hier-doc2vec , we select the class with the highest entailment score at each level in a top-down recursive fashion. For fair comparison, we change its internal BERT-base-uncased model to RoBERTa-large-mnli model as is used in our method. TaxoClass 10 : Our proposed weakly-supervised framework that identifies document core classes, leverages core classes to train a taxonomy-enhanced text classifier, and generalizes the classifier using multi-label self-training. We also evaluate two ablations: TaxoClass-NoST which removes the multi-label self-training step, and TaxoClass-NoGNN which replaces the GNN-based class encoder with a simple embedding layer initialized with pre-trained word embeddings (c.f. Sect. 3.3.1). We follow previous studies (Partalas et al., 2015; Prabhu et al., 2018) and evaluate the multi-label classification results from different aspects using various metrics. The first metric is Example-F1 11 which calculates the average F1 scores for all documents as follows: Example-F1 = 1 NN (cid:88) i =1 2 | C truei  C predi | | C truei | + | C predi | , where C truei ( C predi ) is the true (model predicted) class set of document D i . Moreover, as many applications formalize the HMTC as a class ranking problem (Jain et al., 2016; Guo et al., 2019), we convert predicted class set C predi into a rank list R predi based on each class's model predicted probability and calculate Precision at k ( P @ k ) as follows: P @ k = 1 NN (cid:88) i =1 | C truei  R predi, 1: k | min ( k, | C truei | ) , 9 https://github.com/yinwenpeng/ BenchmarkingZeroShot 10 https://github.com/mickeystroller/ TaxoClass 11 This metric is also called micro-Dice coefficient. where R predi, 1: k is each method predicted top k most likely classes for D i . Finally, for methods able to return the probability of a document being tagged with each class in the taxonomy, we calculate their Mean Reciprocal Rank (MRR) as follows: MRR = 1 NN (cid:88) i =1 1 | C truei | (cid:88) c j  C truei 1 R ij , where R ij is the rank of document D j 's true class c j in model predicted rank list (over all classes). For all baseline methods except Hier-doc2vec, we use the public implementations from their authors and leave the hyper-parameters unchanged. For both Hier-0Shot-TC and our method, we adopt the same public Roberta-Large-MNLI model as the textual entailment model and use the same hypothesis template:  this product is about .  for Amazon-531 dataset and  this example is . for DBPedia-298 dataset. We use AdamW optimizer to train our model with batch size 64, learning rate 5e-5 for all parameters in BERT document encoder and learning rate 4e-3 for all remaining parameters. During the multi-label self-training stage (c.f. Sect. 3.4), we use learning rate 1e-6 for all parameters in the BERT document encoder and 5e-4 for all remaining parameters. We run all experiments on a single cluster with 80 CPU cores and a Quadro RTX 8000 GPU. All deep learning models are moved to the GPU for faster inference speed. With batch size 64, the TaxoClass framework consumes about 10GB GPU memory. In principle, all methods should be runnable on CPU. Table 2 presents the overall results of all compared methods. First, we find most weakly-supervised and zero-shot method can outperform the semi-supervised method SS-PCEM even the later has access to 30% of labeled documents. Second, we can see that TaxoClass has the overall best performance across all the metrics and defeats the second best method by a large margin. Comparing TaxoClass with TaxoClass-NoGNN, we show the importance of incorporating taxonomy structure into the class encoder. Moreover, the improvement of TaxoClass over TaxoClass-NoST demonstrates the effectiveness of our multi-label self-training. We evaluate the effectiveness of our core class mining method as follows. First, we define a set of rival methods and use them to generate various sets of core classes. Then, we derive pseudo-training data for each generated core class set and use it to learn a text classifier with the same architecture as the one in TaxoClass. Finally, we report each model's performance on the test set. Note here we skip the self-training step to ensure the core class based pseudo-training data is the only variable. Table 3 lists all the results. First, we find that the Explicit Mention method, which treats all classes with names explicitly appear in the corpus as the core classes, does not perform well for our HMTC problem. One reason could be many class names are human-curated summarizing phrases that do not appear in the corpus naturally. Second, the 0Shot method views the output classes of baseline method Hier-0Shot-TC as the core classes and trains a new classifier. Interestingly, this new classifier performs better than the original Hier-0Shot-TC classifier, which shows that transferring knowledge from a general zero-shot classifier to a domain-specific classifier is a possible and promising direction. Finally, we compare variants of our own methods. The Ours-NoCS method removes the candidate core class selection step (c.f. Sect. 3.2.1) and treats all classes with high confidence scores as core classes. The Ours-NoConf method skips the confident core class identification step (c.f. Sect. 3.2.2) and views all candidate core classes as the final output core classes. We can see a significant performance drop on both ablations, which shows the importance of our two core class mining steps. We study whether we can use the identified document core classes to train other text classifiers with different architectures such as fastText (Joulin et al., 2016) and TextCNN (Kim, 2014). As shown in Table 4, both methods achieve reasonable performance. We can also see that TaxoClass with and without GNN-enhanced class encoder can outperform both methods. This shows the effectiveness of our dual-encoder style classifier architecture. We vary the percentage of labeled documents on Amazon-531 dataset for training a supervised fastText classifier and present its corresponding performance in Fig. 5. We can see the performance of our TaxoClass framework is equivalent to that of supervised fastText learned on roughly 70% of E x a m p l e -F 1 0.15 0.0 0.30 0.60 0.75 0 40 60 80 100 Percentage of Labeled Documents 20 0.45 FastText TaxoClass (60, 0.581)(80, 0.619) MRR 0.15 0.0 0.30 0.60 0.75 0 40 60 80 100 20 0.45 (60, 0.602) Percentage of Labeled Documents (80, 0.644) 0.593 0.633 FastText TaxoClass Figure 5: Comparison between TaxoClass and supervised fastText method on Amazon-531 dataset. Weakly-supervised Text Classification. There exist some previous studies that leverage a few labeled documents or class-indicative keywords as weak supervision signals for text classification. A pioneering method is dataless classification (Chang et al., 2008; Song and Roth, 2014) which embeds documents and classes into the same semantic space of Wikipedia concepts and performs classification using the embedding similarity. Li et al. (2018, 2019) extend this idea by mining concepts directly from the corpus rather than using the external Wikipedia. Along another line, Chen et al. (2015) and Li et al. (2016) propose to apply a seed-guided topic model to infer class-specific top-ics from class-indicative keywords and to predict document classes from posterior class-topic assignments. Compared with these methods, our TaxoClass framework neither restricts document and class embeddings to live in the same semantic space nor imposes strong statistical assumptions. Recently, neural models are applied to weakly-supervised text classification. Meng et al. (2018, 2019) propose a pretrain-and-refine paradigm which first generates pseudo documents to pretrain a neural classifier and then refine this classifier via self-training. Mekala and Shang (2020); Meng et al. (2020); Wang et al. (2020) improve the above methods by introducing contextualized weak supervision and using a pre-trained language model to obtain better text representations. While achieving inspiring performance, these methods all assume each document has only one class and all class names (or class-indicative keywords) must appear in the corpus for pseudo training data generation. In this paper, we relax these assumptions and develop a new method for weakly-supervised hierarchical multi-label text classification task. Zero-shot Text Classification. Zero-shot text classification learns a text classifier based on training documents belonging to seen classes and applies the learned classifier to predict testing documents belonging to unseen classes (Wang et al., 2019). Nam et al. (2016) jointly embed documents and classes into a shared semantic space where knowledge from seen classes can be transferred to unseen classes. Such an idea is further developed in (Rios and Kavuluru, 2018; Srivastava et al., 2018; Yin et al., 2019; Chu et al., 2020) where external resources ( e.g. , knowledge graphs, natural language explanations of unseen classes, and open domain data) are introduced to help learn a better shared semantic space. Comparing with these methods, our TaxoClass framework does not require labeled data for a set of seen classes. Hierarchical Text Classification. Hierarchical text classification leverages a class hierarchy to improve the standard text classification performance. Typical methods can be divided into two categories: (1) local approaches which learn a text classifier per class (Banerjee et al., 2019), per parent class (Liu et al., 2005), or per level (Wehrmann et al., 2018), and (2) global approaches which incorporate taxonomy structure information into one single classifier through recursive regularization (Gopal and Yang, 2013) or graph neural network (GNN) based encoder (Peng et al., 2018; Huang et al., 2019; Zhou et al., 2020). Our TaxoClass framework adopts the second global approach and uses a GNN-based encoder to obtain each class's representation. This paper studies the hierarchical multi-label text classification problem when only class surface names, instead of massive labeled documents, are given. We propose a novel TaxoClass framework which leverages the class taxonomy structure to derive document core classes and learns taxonomy-enhanced text classifier for prediction. Extensive experiments demonstrate the effectiveness of TaxoClass on two real-world datasets from different domains. In the future, we plan to explore how TaxoClass framework can be integrated with semi-supervised methods and data augmentation methods, when some class surface names are too ambiguous to indicate class semantics. Moreover, we consider extending our multi-label self-training method to other related NLP tasks such as fine-grained entity typing. As text classification is a standard task in NLP, we do not see any significant ethical concerns. The expected usage of our work is to classify documents such as news articles, scientific literature, and etc. Research was sponsored in part by US DARPA SocialSim Program No. W911NF-17-C0099, NSF IIS 16-18481, IIS 17-04532, and IIS 17-41317, and DTRA HDTRA11810026. Any opinions, findings or recommendations expressed herein are those of the authors and should not be interpreted as necessarily representing the views, either expressed or implied, of DARPA or the U.S. Government. We thank anonymous reviewers for valuable and insightful feedback.
abstain abstain objective objective objective abstain result abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain method method objective abstain abstain objective abstain method method abstain method abstain objective objective objective result method abstain abstain abstain method abstain other abstain method abstain abstain abstain abstain method method abstain abstain method abstain method abstain abstain abstain abstain other method abstain method method abstain abstain method abstain other abstain abstain method abstain method abstain method abstain method abstain method abstain abstain abstain abstain abstain abstain method abstain method abstain method method abstain method abstain abstain abstain abstain method method abstain abstain abstain abstain method abstain abstain abstain method abstain abstain abstain abstain abstain abstain method method abstain method abstain abstain method method abstain abstain abstain method method other result abstain abstain method method method method result abstain other abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain result result abstain result other other other other other method other other other other objective other other other other abstain other other other abstain method objective abstain objective objective result abstain other other other other