Leveraging Meta-path Contexts for Classification in Heterogeneous Information Networks

Given an object $x$ in an HIN, our objective is to identify other objects in the network that are similar to $x$ and use their labels to infer that of $x$. We call these other objects relevant neighbors. Note that these neighbors could be multiple hops away from $x$, especially if they are related to $x$ via paths that are instances of certain given meta-paths that express important semantic relations between objects. An interesting question is how relevant neighbors can be obtained effectively and efficiently. If meta-paths are numerous (e.g., those that are obtained via automatic methods) and long, then the neighbors derived from them could cover a large scope of the network. Directly aggregating information from large numbers of neighbors would make model construction inefficient. While there are sampling methods [52] of neighbors, the sampling process itself could be time-consuming and less relevant neighbors may be sampled instead of the more relevant ones. Our first step is to filter neighbors and select the most relevant neighbors of an object.

Given a meta-path $\mathcal{P}$, ConCH measures the similarity between two objects $x_{u}$ and $x_{v}$ of the same type w.r.t. $\mathcal{P}$ by PathSim [58]:

PathSim has been shown to be very effective in a variety of data mining tasks in HINs [59, 3, 18, 1]. Given an object $x$ and a meta-path $\mathcal{P}$, ConCH collects a set of neighbors $N_{x}^{\mathcal{P}}$ that contains the top-$k$ objects with the highest PathSim scores with $x$ w.r.t. $\mathcal{P}$. Using only the top-$k$ neighbors significantly reduces the number of relevant objects that need to be considered in the subsequent steps of the classification process. Also, it removes less relevant ones and thus helps reduce noise. This further improves the classification effectiveness and efficiency.

Recall that given two objects $x_{1}$ and $x_{l}$, and a meta-path $\mathcal{P}$, the mp-context $c_{\scriptscriptstyle 1l}^{\scriptscriptstyle\mathcal{P}}$ is a set of path instances of $\mathcal{P}$ between $x_{1}$ and $x_{l}$. Learning a context embedding from scratch by treating it as learnable parameter is very costly. To reduce the number of parameters, we construct a feature vector for each context. Specifically, we apply a conventional HIN embedding method, such as metapath2vec [32], to obtain initial object embeddings. Then, we generate a path instance’s embedding by aggregating the embedding vectors of all the objects in the path instance. Given a path instance $p_{x_{1}\leadsto{x_{l}}}=x_{1}x_{2}\ldots x_{l}\vdash\mathcal{P}$, its embedding is computed by

where $e_{i}$ is the initial embedding vector of $x_{i},\forall 1\leq i\leq l$. An initial context embedding is further obtained by aggregating path instances’ embeddings:

which serves as the context $c_{\scriptscriptstyle 1l}^{\scriptscriptstyle\mathcal{P}}$’s feature vector.

In the previous steps, we obtained a selected set of path-based neighbors of objects and mp-contexts. We next update their embeddings through a mutual update process. Note that a meta-path-based relation between two objects is influenced by the meta-path instances (i.e., a context) that connect the two objects; At the same time, a context is influenced by the objects that compose the meta-path instances. Hence, we update object embeddings and context embeddings together. To facilitate such an update, we first construct, for each meta-path $\mathcal{P}$, a bipartite graph $G_{\mathcal{P}}=(\mathcal{X},V_{C}^{\mathcal{P}},E_{OC}^{\mathcal{P}})$, where $\mathcal{X}$ is the set of objects to be classified, $V_{C}^{\mathcal{P}}$ is the set of meta-path contexts derived from $\mathcal{P}$, and $E_{OC}^{\mathcal{P}}$ is the set of edges such that $e_{ij}$ connects object $x_{i}$ in $\mathcal{X}$ and context $c_{j}$ in $V_{C}^{\mathcal{P}}$ if the path instances in $c_{j}$ start from or end at $x_{i}$. Note that our neighbor filtering scheme (see Section IV-A) derives top-$k$ neighbors for each object. Therefore, the degree of any object $x$ in the bipartite graph is at most $k$.

Fig. 2 shows example bipartite graphs derived from a movie HIN. For the meta-path Movie-Actor-Movie (MAM), M1 and M3 are connected by the path instance M1$\rightarrow$ A1 $\rightarrow$ M3, and M2 and M4 are connected by M2$\rightarrow$ A2 $\rightarrow$ M4. The bipartite graph for MAM is shown in Fig. 2(a), in which context C1 = {M1$\rightarrow$ A1 $\rightarrow$ M3} and C2 = {M2$\rightarrow$ A2 $\rightarrow$ M4}.

We update object embeddings (denoted by $h_{x}^{\mathcal{P}}$) and context embeddings (denoted by $h_{c}^{\mathcal{P}}$) from each other. For each context $c_{j}$ that is linked to two objects $x_{u}$ and $x_{v}$ in $G_{\mathcal{P}}$, we update its embedding vector $h_{c_{j}}^{\mathcal{P}}$ in the $(t+1)$-st timestep by aggregating information from both $x_{u}$ and $x_{v}$:

where $W_{1}^{(t)}$ and $W_{2}^{(t)}$ are two linear transformation matrices to be learned. For any object $x_{i}\in\mathcal{X}$, it connects to at most $k$ contexts. From these contexts, we update the embedding vector of $x_{i}$ in the $(t+1)$-st timestep by:

where $W_{3}^{(t)}$ and $W_{4}^{(t)}$ are another two weight matrices. Here, we use the sum aggregator. It is efficient and since we have retained only the top-$k$ neighbors that are the most informative, the aggregation should also be effective.

Our next step is to fuse together the object embeddings derived from different meta-paths. Since different meta-paths represent different semantic relations, they may contribute in different extents in the classification task. We use the vanilla attention mechanism to learn the importance of meta-paths. Given a meta-path $\mathcal{P}$ and the embedding vector $h_{x_{i}}^{\mathcal{P}}$ of an object $x_{i}$, we feed $h_{x_{i}}^{\mathcal{P}}$ into a two-layer MLP and get:

where $a$ is the weight vector, $\xi$ is the leaky_ReLU function, and $W_{5}$ and $W_{6}$ are two linear transformation matrices. We regularize $\tilde{w}_{x_{i}}^{\mathcal{P}}$ by softmax function and compute the attention weight $w_{x_{i}}^{\mathcal{P}}$ of the meta-path $\mathcal{P}$ by

Finally, we aggregate the embedding vectors across meta-paths and generate the final embedding vector $z_{i}$ of $x_{i}$ by:

After the semantic aggregation, a standard way to guide parameter learning is to use label information in the training set. Specifically, we first feed $z_{i}$ in Eq. 8 into a two-layer MLP to output a label vector $\tilde{z}_{i}$ of length $r$ ($r$ is the number of labels):

where $W_{7}$ and $W_{8}$ are learnable weight matrices. The label corresponding to the largest-value entry in $\tilde{z}_{i}$ is taken as the predicted label of $x_{i}$. Then we minimize the Cross-Entropy loss function:

where $\mathcal{Y}$ is the training set of labeled objects and $y_{i}$ is the one-hot encoded true label vector of object $x_{i}$. While the supervised loss in Eq. 10 is useful, the model performance could be adversely affected when the number of labeled objects is limited. Further, self-supervised learning has shown great potential in utilizing unlabeled data. Therefore, we incorporate self-supervised learning into the learning process to leverage both labeled and unlabeled objects.

After the final embedding vector of an object is derived (in Eq. 8), we compute a summary vector $s$ as the global representation encoder, which retains the information from all the objects of the type to be classified. We simply take the averaging operator and get:

where $n$ is the number of objects to be classified. Then we maximize the mutual information between node embeddings and the global representation, which encourages each single object to have access to the information of others. Following [45], we use a noise-contrastive type objective function with a standard binary cross entropy loss:

where $\mathcal{D}$ is a discriminator to distinguish the positive sample set $Pos=\{(z_{i},s)\}_{i=1}^{N}$ from the negative sample set $Neg=\{(\hat{z}_{j},s)\}_{j=1}^{M}$. The sample $(z_{i},s)$ is positive when object $x_{i}$ belongs to the original graph; the sample $(\hat{z}_{j},s)$ is negative when object $x_{j}$ is the generated fake one. $\mathcal{D}(z_{i},s)$ represents the probability score assigned to the input node-summary pair, and it is defined as

where $\sigma$ is the sigmoid function and $W_{\mathcal{D}}$ is the learnable weight matrix. To generate negative samples, inspired by [49], for each meta-path-based bipartite graph, we fix the adjacency matrix unchanged and randomly shuffle rows of the initial object feature matrix, which generates a “negative” bipartite graph. For example, Fig. 2(a) and Fig. 2(c) show the original bipartite graph (we call it “positive” for comparison) and the “negative” one derived by the meta-path MAM, respectively. Feature vectors of movies in the negative bipartite graph are shuffled from that in the positive graph. For the constructed negative bipartite graphs, we repeat steps ④ and ⑤ (in Sec IV-C and IV-D) to get $\hat{z}_{j}$ for each object $x_{j}$ and further construct $Neg$.

Finally, to learn from both labeled and unlabeled data, we formulate the problem as a multi-task learning problem by combining $\mathcal{L}_{sup}$ and $\mathcal{L}_{ss}$ to get a loss function:

where $\lambda$ controls the relative importance of the two terms. Here, the self-supervised loss acts as a regularizer that learns from unlabeled data. The learned data-driven prior knowledge could provide supplementary information to the training set when the number of labeled objects is limited. This further enhances the model’s capability. The loss function can be optimized by stochastic gradient descent. To prevent overfitting, we further regularize all the weight matrices $W_{j}$’s mentioned in Eqs. 4 - 13.

The major computation cost of ConCH comes from the updates of object and context embeddings. Let $n$ be the number of objects to be classified. In each bipartite graph, there are at most $kn$ contexts. Since the degree of each object is at most $k$ and that of a context is at most $2$, the total time complexity of embedding updates is $O(3knd_{1}d_{2})$, where $d_{1}$ and $d_{2}$ are respectively the maximum numbers of rows and columns in the transformation matrices of the MLPs. Further, for each meta-path, we generate a “positive” bipartite graph and a “negative” one. Therefore, the total time complexity of embedding updates is $O(6knd_{1}d_{2}|\mathcal{PS}|)$, where $|\mathcal{PS}|$ is the number of meta-paths. Since the computation for each bipartite graph is independent from the others’, ConCH can be easily parallelized. Finally, we summarize ConCH in Alg. 1.

We use three datasets: DBLP, Yelp, and Freebase. DBLP²²2https://dblp.uni-trier.de/ is a bibliographic network of academic publications. Yelp³³3https://www.yelp.com/academic_dataset/ contains information of businesses, such as user data and reviews. Freebase⁴⁴4https://www.freebase.com/ is a knowledge base of facts recorded with the RDF model. The three datasets are representative HINs. We define a classification task for each dataset as follows:

We first compare ConCH with 11 other methods, which can be grouped into two categories. Readers are referred to Section II for more details.

We implement ConCH using PyTorch. The model is initialized by Glorot initialization [62] and trained by Adam [63]. For ConCH and all its variants, we set the learning rate to $0.001$, the dropout ratio to $0.5$ and the penalty weight on the $\ell_{2}$-norm regularizer to $0.0005$ on all three datasets. We set $k$ in neighbor filtering to 5, 10, 10 and the number of layers $L$ to 2, 1, 1 in DBLP, Yelp and Freebase, respectively. For the self-supervised regularization weight $\lambda$, we fine tune it from $\{0.001,0.01,0.1,1\}$. We use early stopping with a patience of 100, i.e., we stop training if the validation accuracy does not decrease for 100 consecutive epochs. To run ConCH, we first run metapath2vec with the default parameter settings in the original codes provided by the authors to construct context features. We set the initial context embedding dimensionality to 128 for DBLP and Yelp, and 32 for Freebase. We perform neighbor filtering and context feature extraction as preprocessing steps. For fair comparison, we set the output embedding dimensionality for all the methods to be 128. We run all the experiments on a server with 128G memory and a single NVIDIA 2080Ti GPU. We also feed all the methods the same training/validation/test set splits. For all the baseline methods, we use the original codes released by their authors. For MVGRL, HetGNN and HDGI, since they are unsupervised, we train the models by the train loss early stopping with 100 epochs. For other graph neural network models, we use the same early stopping criteria as ConCH for fairness. For these models, we fine tune the model hyper-parameters by grid search. These include the number of model layers $\{1,2,3\}$ and the learning rate $\{0.01,0.001,0.0001\}$. For HGCN, as suggested in the original paper, we further perform the hyper-parameter tuning for the number of inception layers $\{1,2,3,4\}$, the convolutional kernel size $\{1,2,3,4\}$ and the order of label propagation $\{0,1,2\}$. For all the meta-path-based methods, we employ the same meta-path sets. For the random-walk-based embedding methods, we use the default parameters reported in their original papers. For each method, we run experiments 10 times and report the average results. We provide our code and data here: https://github.com/dingdanhao110/Conch.

Table I summarizes the performance results. We evaluate the methods on three datasets under two evaluation metrics. Moreover, to compare the methods when labeled objects are scarce, we vary the training set size from very small (2% and 5%) to moderate (10% and 20%). There are thus in total 3 $\times$ 2 $\times$ 4 = 24 “contests” in the comparison study. Each row in the table corresponds to one contest. For each contest, we highlight the winner’s score in bold. From the table, we make the following observations:

(1) As the training set size decreases, the performance of many baseline methods drops sharply. For example, on DBLP, the Micro-F1 score of HDGI is $0.9233$ with 20% labeled objects, which is close to the winner’s score. However, with only 2% labeled objects, the score of HDGI degrades to $0.7733$ while the best score (ConCH) is $0.9429$.

(2) For the two network-embedding-based methods, mp2vec performs better on DBLP and Yelp, while node2vec takes the lead on Freebase. Although mp2vec is an embedding method for HINs that uses meta-paths, it can take only one meta-path as input, which affects its performance.

(3) ConCH outperforms graph neural network models GCN and GAT. This is because both methods are designed for homogeneous networks without considering objects’ and links’ heterogeneity. While MVGRL leverages self-supervision, it ignores heterogeneity and is outperformed by ConCH.

(4) Although HAN is designed for HINs and it uses meta-paths, HAN omits mp-contexts, which lowers its effectiveness. For example, its Macro-F1 score on Yelp with $20\%$ labeled data is 0.6637, which is significantly lower than that of ConCH. This shows the importance of mp-contexts. Moreover, since HDGI takes HAN as the base neural network model, its performance is also adversely affected due to the ignorance of mp-contexts. MAGNN considers mp-contexts and it performs well on DBLP. However, as we will show in Sec. V-G, MAGNN is computationally expensive. Further, MAGNN needs to preprocess and maintain information for each meta-path instance, which requires a lot of storage. For example, the meta-paths processing in the Yelp task generates a large number of path instances between objects, which causes out-of-memory errors. As a result, in our experiments, MAGNN fails to run on Yelp.

(5) HetGNN and HGT can achieve overall good performance over all three datasets. However, they are also easily affected when the number of labeled objects is limited. For example, with 2% labeled objects, the Macro-F1 scores of HetGNN and HGT on Yelp are $0.8486$ and $0.7836$, respectively, while the winner’s is $0.8860$. HGCN constructs relational features for an object by aggregating its neighbors’ label information. However, the constructed relational features and the original features of the object could be in different feature space, which restricts the model’s effectiveness.

(6) ConCH achieves the best performance in all 24 cases. ConCH uses a simple neighbor filtering scheme to remove the less relevant neighbors of an object. Moreover, ConCH, based on meta-paths, leverages mp-contexts to boost the classification performance. We further observe that, given scarce labeled objects, ConCH  achieves superior performance compared with other methods. For example, with 2% labeled objects, the Micro-F1 score of ConCH on Yelp is $0.8841$ while that of the first runner-up is only $0.8558$. This is because the self-supervision learned from unlabeled data provides additional information that helps classify objects.

We conduct an ablation study on ConCH to understand the characteristics of its main components. One variant updates objects’ embeddings by directly aggregating information from its multi-hop neighbors specified by meta-paths without considering contexts derived from the path instances. This helps us understand the importance of including mp-contexts in object classification. We call this variant ConCH_nc (no contexts). Another variant randomly selects $k$ meta-path-based neighbors from a given object as relevant neighbors. This is in contrast to ConCH, which selects relevant neighbors by picking the top-$k$ most similar path-based neighbors based on PathSim scores (see Section IV-A). We call this variant ConCH_rd (random), which helps us evaluate the effectiveness of our neighbor-filtering strategy. To show the importance of the self-supervised regularization, we train the model with $\mathcal{L}_{sup}$ only and call this variant ConCH_su (supervised). Moreover, while we formulate our problem as a multi-task learning objective, we can also train the model by a pre-training & fine-tuning strategy. Specifically, we first train the model by using $\mathcal{L}_{ss}$ only and then take the learned parameters as the initialization to the model that uses $\mathcal{L}_{sup}$ only. This variant can be used to show the advantage of the multi-task learning framework and we call it ConCH_ft (fine-tuning). Finally, we consider a variant of ConCH that assigns meta-paths equal weights without the attention mechanism. We call this variant ConCH_ew (equal weights).

Similar to Sec. V-D, we compare ConCH with these variants for four training set sizes on three datasets w.r.t. Macro-F1 and Micro-F1 measures. The results are given in Figs. 3 - 5. From these figures, we observe:

(1) ConCH beats ConCH_nc in all 24 cases. In particular, ConCH significantly outperforms ConCH_nc on Yelp and Freebase. This shows that mp-context information is particularly important for HINs that are with heterogeneity in object types and link types. When using meta-paths, the inclusion of mp-contexts is essential for effective classification.

(2) ConCH achieves better performance than ConCH_rd. Since ConCH_rd randomly selects $k$ path-based neighbors for an object, the performance gaps between ConCH and ConCH_rd show that ConCH’s top-$k$ neighbor-filtering strategy is very effective in selecting more influential path-based neighbors to improve classification accuracy.

(3) Given 20% labeled objects, ConCH_su achieves comparable performance with ConCH. However, as the training set size decreases, the performance gap between ConCH and ConCH_su gets larger. This further shows the importance of leveraging self-supervised learning to cover the shortage of labeled objects.

(4) ConCH clearly outperforms ConCH_ft on three datasets. ConCH_ft, which switches the objective function from $\mathcal{L}_{ss}$ in pre-training to $\mathcal{L}_{sup}$ in fine-tuning, solves two optimization problems. However, ConCH unifies the two loss functions into one objective that is much easier to be optimized and can better leverage both labeled and unlabeled objects. Our results are similar to those reported in [42].

(5) ConCH performs better than ConCH_ew in 22 cases. This further shows the importance of the attention mechanism in learning meta-path weights.

ConCH learns the importance of meta-paths by the attention mechanism. To show the effectiveness of attention weight learning, we compute the average learned weights of meta-paths for all three datasets. We show the results (Fig. 6) with $20\%$ labeled objects as training sets for illustration.

Fig. 6(a) shows the learned meta-paths’ weights for the DBLP dataset. Recall that the classification task is to classify authors by their research areas. From the figure, we see that the weight of the meta-path APCPA (authors that publish papers in the same venue) is almost $1$, while that of meta-paths APA (co-authorship) and APAPA (authors that share a common co-author) are very close to $0$. An almost-0 weight for APA may seem counter-intuitive considering that co-authorship is a strong signal that two authors work in the same area. The reason why APA is given such a low weight is that it is a sparse relation. An author typically co-authors with only a handful of others in the community. Further, an author is related to a large number of other authors by APCPA (conference co-attendant relation). Moreover, authors related by APA are also related by APCPA, hence, the former is subsumed by the latter. In this example, we see that ConCH correctly selects the relevant meta-path APCPA over APA and APAPA.

Fig. 6(b) shows the learned meta-paths’ weights for the Yelp dataset. Recall that the task is to classify restaurants by their food categories. We see that the meta-path BRKRB (restaurants whose reviews contain the same food keyword) is given a much larger weight than BRURB (restaurants that are visited by the same customer). This is reasonable because food keywords in reviews directly indicate food category. On the other hand, a customer could visit restaurants that serve different categories of food.

The Freebase task is to classify movies by genre. Fig. 6(c) shows that all three meta-paths are useful. The weights of meta-paths MAM (movies share the same actor) and MDM (movies filmed by the same director) are a bit larger than that of MPM (movies produced by the same producer). From our discussion, we see that ConCH’s meta-path weight learning strategy is highly effective.

In this section we study ConCH’s efficiency. For fairness, we compare the training time for ConCH, HAN, MAGNN, HGT and HGCN, as they are semi-supervised classification methods in HINs. For all these methods, we use the same training/validation set and run the experiments for 300 epochs. We take 20% labeled objects as training set for illustration. We repeat all the experiments three times and show the average training time of these methods w.r.t. the Micro-F1 score on the validation set in Fig. 7. Note that we cannot run MAGNN on Yelp. To recap the major differences of these methods: ConCH, HAN and MAGNN are based on meta-paths. However, ConCH selects the $k$ most informative path-based neighbors for an object based on a filtering scheme. HAN uses all meta-path-based neighbors (i.e., no filtering) and it learns the neighbors’ relative importance by the vanilla attention mechanism. HAN does not use mp-contexts either. Different from ConCH, which uses mp-contexts to construct high-level context objects with features, MAGNN utilizes mp-contexts in a fine-grained manner by independently considering all the meta-path instances. It learns the importance of meta-path instances and further aggregates information from these path instances to generate object embeddings. HGT employs a Transformer based aggregator to aggregate information from multi-type neighbors for an object, while HGCN leverages multiple kernels that use different convolutional filters.

From Figs. 7(a)-(c), we can see that ConCH consistently converges fast to the best results over all three datasets. MAGNN and HGT can also reach high performance scores, however, they need much longer time to converge. In particular, for MAGNN, when meta-paths are of longer lengths, the number of path instances could be numerous, which adversely affects model efficiency. For example, ConCH is about $50\times$ faster than MAGNN on DBLP; ConCH achieves almost $40\times$ speedup than HGT on Yelp. Although HAN and HGCN are faster than MAGNN and HGT, their performances are poor. These results show that our approach ConCH is very efficient and also highly effective. Finally, the runtime of ConCH depends on $k$, which is the number of selected relevant neighbors for an object. Fig. 7(d) shows how ConCH’s runtime of one training epoch varies with $k$. From the figure, we see that the runtime increases fairly linearly with $k$. Thus, ConCH is scalable w.r.t. $k$.

To further study ConCH’s efficiency, we conduct experiments on a large dblp-4area subgraph extracted from the AMiner citation network ⁶⁶6https://originalstatic.aminer.cn/misc/dblp.v12.7z. We first extract papers whose fields of study in the original dataset contain at least one of four areas: database (DB), data mining (DM), machine learning (ML), and information retrieval (IR). For simplicity, we only consider conference papers. We extract authors and conferences related to these papers. The resulting dataset contains 416,554 papers (P), 537,435 authors (A) and 2,649 conferences (C). Links include A-P (an author publishes a paper) and P-C (a paper is published at a conference). Our task is to classify papers into one of the four research areas. For each paper, following [61], we compute a 300-dimension attribute vector by averaging the word embeddings of keywords it contains. We consider the meta-path set {PAP, PCP}. The ground truth labels of papers are derived from the original dataset, where we label each paper by the research area with the largest field of study weight.

Figure 8 shows the efficiency study on the AMiner dataset. All these methods are semi-supervised classification methods in HINs. Compared with others, ConCH converges fast to the best performance. Table II further summarizes the classification performance over all the methods on AMiner. ConCH clearly outperforms all the baseline methods, which again shows its effectiveness. Due to the large dataset size, both MVGRL and MAGNN cause out-of-memory errors. Note that MVGRL requires both adjacency matrix and diffusion matrix as input to provide both local and global views of a graph structure, respectively. However, the diffusion matrix computed by all the approaches suggested in the original paper is too dense, which causes out-of-memory errors. This further shows that ConCH is efficient and also very effective.

We end this section with a sensitivity analysis on the hyper-parameters of ConCH. In particular, we study four key hyper-parameters: the output embedding dimensionality, the input context embedding dimensionality, the number of selected relevant neighbors $k$ and the self-supervised regularization weight $\lambda$. In our experiments, we vary one parameter each time with others fixed. Fig. 9 illustrates the results with 20% labeled objects w.r.t. the Micro-F1 scores. (Results on Macro-F1 scores exhibit similar trends, and thus are omitted for space reasons.) From the figure, we see that

(1) As the output embedding dimensionality increases, ConCH achieves better performance. This is because when the dimensionality is small, node embeddings cannot capture enough information for classifying objects.

(2) There is a performance drop in Freebase when the input context feature dimensionality is 128. This shows that initial context embedding vectors in a large dimensionality could contain noise that adversely affects the classification accuracy.

(3) For the other two hyper-parameters, ConCH gives very stable performances over a wide range of parameter values. In particular, ConCH performs well even with small $k$. This further shows that ConCH is an effective and efficient method for solving the classification problem on HINs.