Datasets:

zai-org
/

RPC-Bench

+# LEARNING A NEURAL-NETWORK-BASED REPRESENTATION FOR OPEN SET RECOGNITION
+Anonymous authors Paper under double-blind review
+# ABSTRACT
+In this paper, we present a neural network based representation for addressing the open set recognition problem. In this representation instances from the same class are close to each other while instances from different classes are further apart, resulting in statistically significant improvement when compared to other approaches on three datasets from two different domains.
+# 1 INTRODUCTION
+To build robust AI systems, Dietterich Dietterich (2017) reasons that one of the main challenges is handling the “unknown unknowns." One idea is to detect model failures (i.e., the system understands that its model about the world/domain has limitations and may fail). For example, assume you trained a binary classifier model to discriminate between pictures of cats and dogs. Let’s assume this model performs well at recognizing images of cats and dogs. What would this model do if it is faced with a picture of a fox or a caracal? The model being a binary classifier will predict these pictures to be either a dog or a cat, which is not desirable and can be considered as a failure of the model. In machine learning, one direction of research for detecting model failure is “open category learning", where not all categories are known during training, and the system needs to appropriately handle instances from novel/unknown categories that may appear during testing. Besides “open category learning", terms such as “open world recognition" Bendale & Boult (2015) and “open set recognition" Scheirer et al. (2013); Bendale & Boult (2016) have been used in past literatures. In this paper, we will use the term “open set recognition".
+Where does open set recognition appear in real-world problems? Various real-world applications operate in an open set scenario. For example, Ortiz and Becker Ortiz & Becker (2014) point to the problem of face recognition. One such use case is automatic labeling of friends in social media posts, “where the system must determine if the query face exists in the known gallery, and, if so, the most probable identity." Another domain is in malware classification, where training data usually is incomplete because of novel malware families/classes that emerge regularly. As a result, malware classification systems operate in an open set scenario.
+In this paper, we propose a neural network based representation and a mechanism that utilizes this representation for performing open set recognition. Since our primary motivation when developing this approach was the malware classification domain, we evaluate our work on two malware datasets. To show the applicability of our approach to other domains, we evaluate our approach on images.
+Our contributions include: (1) we propose an approach for learning a representation that facilitates open set recognition, (2) we propose a loss function that enables us to use the same distance function both when training and when computing an outlier score, (3) our proposed approaches achieve statistically significant improvement compared to previous research work on three datasets.
+# 2 RELATED WORK
+We can broadly categorize existing open set recognition systems into two types. The first type provides mechanisms to discriminate known class instances from unknown class instances. These systems, however, cannot discriminate between the known classes, where there is more than one. Research works such as Scheirer et al. (2013); Bodesheim et al. (2013; 2015) fall in this category. Scheirer et al. Scheirer et al. (2013) formalized the concept of open set recognition and proposed a
+1-vs-set binary SVM based approach. Bodesheim et al. Bodesheim et al. (2013) propose KNFST for performing open set recognition for multiple known classes at the same time. The idea of KNFST is further extended in Bodesheim et al. (2015) by considering the locality of a sample when calculating its outlier score.
+The second type of open set recognition system provides the ability to discriminate between known classes in addition to identifying unknown class instances. Research works such as Jain et al. (2014); Bendale & Boult (2015; 2016); Da et al. (2014); Ge et al. (2017) fall in this category. PI-SVM Jain et al. (2014), for instance, uses a collection of binary SVM classifiers, one for each class, and fits a Weibull distribution over the score of each classifier. This approach allows PI-SVM to be able to both perform recognition of unknown class instances and classification between the known class instances. Bendale and Boult Bendale & Boult (2015) propose an approach to extend Nearest Class Mean (NCM) to perform open set recognition with the added benefit of being able to do incremental learning.
+Neural Net based methods for open set recognition have been proposed in Bendale & Boult (2016); Cardoso et al. (2015); Ge et al. (2017). Openmax Bendale & Boult (2016) (a state-of-art algorithm) modifies the regular Softmax layer of a neural network by redistributing the activation vector (the values of the final layer of a neural network that are given as input to the Softmax function) to account for unknown classes. Ge et al. Ge et al. (2017) use DCGAN Radford et al. (2015) to generate unknown-class samples. The network is trained on the original instances plus the generated samples, and Openmax is used to ajdusted the activation vector. Similarly, Yu et al. Yu et al. (2017) generate “negative” samples using adversarial learning and use supervised algorithms to learn the final classifier. Our approach does not generate “unknown-class/negative” samples and hence does not increase the training overhead in the learning step. In malware classification, K. Rieck et al.Rieck et al. (2011) proposed a malware clustering approach and an associated outlier score. Although the authors did not propose their work for open set recognition, their outlier score can be used for unsupervised open set recognition. Rudd et al. Rudd et al. (2017) outline ways to extend existing closed set intrusion detection approaches for open set scenarios. Lee et al. Lee et al. (2018) are interested in detecting test samples that are out-of-distribution (different from the training “in-distribution’); however, each test sample is still from one of the known classes.
+# 3 APPROACH
+For open set recognition, given a set of instances belonging to known classes, we would like to learn a function that can accurately classify an unseen instance to one of the known classes or an unknown class. Let $D$ be a set of instances $X$ and their respective class labels $Y$ (i.e., $D = ( X , Y ) ,$ , and $K$ be the number of unique known class labels. Given $D$ for training, the problem of open set recognition is to learn a function $f$ that can accurately classify an unseen instance (not in $X$ ) to one of the $K$ classes or an unknown class (or the “none of the above" class).
+The problem of open set recognition differs from the problem of closed set (“regular") classification because the learned function $f$ needs to handle unseen instances that might belong to classes that are not known during training. That is, the learner is robust in handling instances of classes that are not known. This difference is the main challenge for open set recognition. Another challenge is how to learn a more effective instance representation that facilitates open set recognition than the original instance representation used in $X$ .
+Learning representations Consider $\vec { x }$ is an instance and $y = f ( \vec { x } )$ is the class label predicted using $f ( \vec { x } )$ . In case of a closed set, $y$ is one of the known class labels. In the case of open set, $y$ could be one of the known classes or an unknown class. The hidden layers in a neural network, ${ \vec { z } } = g ( { \vec { x } } )$ , can be considered as different representations of $\vec { x }$ . Note, we can rewrite $y$ in terms of the hidden layer as $y = f ( \vec { z } ) = f ( g ( \vec { x } ) )$ .
+The objective of our approach is to learn a representation that facilitates open set recognition. We would like this new representation to have two properties: (P1) instances of the same class are closer together, and (P2) instances of different classes are further apart. The two properties can lead to larger spaces among known classes for the instances of the unknown classes to occupy. Consequently, instances of unknown classes could be more effectively detected. This representation is similar in spirit to a Fisher Discriminant. A Fisher discriminant aims to find a linear projection that maximizes
+Algorithm 1: Training to minimize ii-loss.
+Input :
+$( X , Y )$ : Training data and labels
+1 for number of training iterations do
+2 Sample a mini-batch ( $X _ { b a t c h }$ , $Y _ { b a t c h . }$ ) from $( X , Y )$
+3 $Z _ { b a t c h } \gets g ( X _ { b a t c h } )$
+4 $\{ \vec { \mu } _ { 1 } \cdot \cdot \cdot \vec { \mu } _ { K } \}  c l a s s \_ m e a n s ( Z _ { b a t c h } , Y _ { b a t c h } )$
+5 $\begin{array} { r } { | | \neg | 0 { \sf S } { \sf S }  i n t r a _ { - } s p r e a d ( Z _ { b a t c h } , \{ \vec { \mu } _ { 1 } \cdot \cdot \cdot \vec { \mu } _ { K } \} ) } \end{array}$ - inter_separation $\left( \{ \vec { \mu } _ { 1 } \cdots \vec { \mu } _ { K } \} \right)$
+6 update parameters of $g$ using stochastic gradient descent to minimize ii-loss
+7 $\{ \vec { \mu } _ { 1 } \cdot \cdot \cdot \vec { \mu } _ { K } \} \gets c l a s s \_ m e a n s ( g ( X ) , Y )$
+8 return $\{ \vec { \mu } _ { 1 } \cdot \cdot \cdot \vec { \mu } _ { K } \}$ and parameters of $g$ as the model.
+between class (inter-class) separation while minimizing within class (intra-class) spread. Such a projection is obtained by maximizing the Fisher criteria. However, in the case of this work, we use a neural network with a non-linear projection to learn this representation. The neural network $g$ used to learn the representation can be either a combination of convolution and fully connected layers, as shown in Figure 1a, or it can be all fully connected layers, Figure 1b. Both types are used in our experimental evaluation.
+II-Loss Function In a typical neural network classifier, the activation vector that comes from the final linear layer is given as input to a Softmax function. Then the network is trained to minimize a loss function such as cross-entropy on the outputs of the Softmax layer. In our case, the output vector $\vec { z _ { i } }$ of the final linear layer of a neural network (i.e., activation vector that serves as input to a softmax in a typical neural net) are considered as the projection of the input vector $\vec { x _ { i } }$ , of instance $i$ , to a different space. The network is trained using mini-batch stochastic gradient descent with backpropagation as outlined in Algorithm 1 to minimize the loss function in Equation 1, which we will refer to ii-loss for the remainder of this paper. In this loss function, we aim to maximize the distance between different classes (inter-class separation) and minimize the distance of an instance from its class mean (intra-class spread). We measure intra-class spread as the average distance of instances from their class means (first part of Equation 1). We measure the inter-class separation in terms of the distance between the closest two class means among all the $K$ known classes (second part of Equation 1). After the network finishes training, the class means are calculated for each class using all the training instances of that class and stored as part of the model.
+$$
+i i - l o s s = \big ( \underbrace { \frac { 1 } { N } \sum _ { j = 1 } ^ { K } \sum _ { i = 1 } ^ { | C _ { j } | } \| \vec { \mu _ { j } } - \vec { z _ { i } } \| _ { 2 } ^ { 2 } } _ { \mathrm { i n t r a . } \mathrm { s p r e a d } } \big ) - \big ( \ * { \underset { 1 \leq m \leq K } { \operatorname* { m i n } } } \| \vec { \mu _ { m } } - \vec { \mu _ { n } } \| _ { 2 } ^ { 2 } \big )
+$$
+where $| C _ { j } |$ is the number of training instances in class $C _ { j }$ , $N$ is the number of training instances, $K$ is the number of known classes, and \~µj = 1|C | P|Cj |i=1 z is the mean of class $C _ { j }$ .
+Combining ii-loss with Cross Entropy Loss While the two desirable properties P1 and P2 discussed in an earlier Section aim to have a representation that separates instances from different classes, lower classification error is not explicitly stated. Hence, a third desirable property (P3) is a low classification error in the training data. To achieve this, alternatively, a network can be trained on both cross entropy loss and ii-loss (Eq 1) simultaneously. The network architecture in Figure 1c can be used. In this configuration, an additional linear layer is added after the $\mathbf { Z }$ -layer. The output of this linear layer is passed through a Softmax function to produce a distribution over the known classes. Although Figure 1c shows a network with convolutional and fully connected layers, combining ii-loss with cross-entropy can also work with a network of fully connected layers only. The network is trained using mini-batch stochastic gradient descent with backpropagation. During each training iteration, the network weights are first updated to minimize on ii-loss and then in a separate step updated to minimize cross entropy loss. Other researchers have trained neural networks using more than one loss function. For example, the encoder network of an Adversarial autoencoder Makhzani et al. (2015) is updated both to minimize the reconstruction loss and the generators loss.
+![](images/7e463f1d7aa4660a386dbb6243ffe7299ea829dd5ecc4ed54f0487a622f154ed.jpg)
+Figure 1: Network architecture with ii-loss.
+Outlier Score for Open Set Recognition During testing, we use an outlier score to indicate the degree to which the network predicts an instance $\vec { x }$ to be an outlier. This outlier score is calculated as the distance of an instance to the closest class mean from among $K$ known classes.
+$$
+o u t l i e r \_ s c o r e ( \vec { x } ) = \operatorname* { m i n } _ { 1 \leq j \leq K } \left\| \vec { \mu } _ { j } - \vec { z } \right\| _ { 2 } ^ { 2 }
+$$
+where ${ \vec { z } } = g ( { \vec { x } } )$ . Because the network is trained to project the members of a class as close to the class mean as possible the further away the projection $\vec { z }$ of instance $\vec { x }$ is from the closest class mean, the more likely the instance is an outlier for that class.
+Threshold Estimation Once an outlier score identified, the next step is determining what threshold value of this score will indicate an outlier. In other words, how far does the projection of an instance need to be from the closest class mean for it to be deemed an outlier. For this work, we propose a simple threshold estimation. To pick an outlier threshold, we assume that a certain percent of the training set to be noise/outliers . We refer to this percentage as the contamination ratio. For example, if we set the contamination ratio to be 0.01, it will be like assuming $1 \%$ of the training data to be noise/outliers. Then, we calculate the outlier score on the training set instances, sort the scores in ascending order and pick the 99 percentile outlier score value as the outlier threshold value. The reader might notice that the threshold proposed in this section is a global threshold. This means that the same outlier threshold value is used for all classes. An alternative to this approach is to estimate the outlier threshold per-class. However, in our evaluation, we observe that global threshold consistently gives more accurate results than the per-class threshold.
+Performing Open Set Recognition Open set recognition is a classification over $K + 1$ class labels, where the first $K$ labels are from the known classes the classifier is trained on, and the $K + 1 \mathrm { s t }$ label represents the unknown class. This is performed using the outlier score in Equation 2 and the associated threshold. The outlier_score of a test instance is first calculated. If the score is greater than threshold, the test instance is labeled as $K + 1$ , which in our case corresponds to the unknown class; otherwise, the appropriate class label is assigned to the instance from among the known classes, Equation 3. The predicted class probability over the known classes, we can be expressed as the softmax of the negative distance of a projection $\vec { z }$ , of the test instance $\vec { x }$ (i.e., $\vec { z } = g ( \vec { x } ) )$ , from all the known class means, Equation 4. Note, when a network network trained on both ii-loss and cross entropy loss $P ( y = k \mid \vec { x } )$ is from the Softmax layer in Figure 1c.
+$$
+y = { \left\{ \begin{array} { l l } { K + 1 , } & { { \mathrm { i f ~ } } o u t l i e r \_ s c o r e > t h r e s h o l d } \\ { { \mathrm { a r g m a x } } P ( y = j \mid { \vec { x } } ) , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+$$
+P ( y = j \mid \vec { x } ) = \frac { e ^ { - \parallel \vec { \mu } _ { j } - \vec { z } \parallel _ { 2 } ^ { 2 } } } { \sum _ { m = 1 } ^ { K } e ^ { - \parallel \vec { \mu } _ { m } - \vec { z } \parallel _ { 2 } ^ { 2 } } }
+$$
+# 4 EVALUATION
+Datasets and Simulating Open Set Dataset We evaluate our approach using three datasets. The first is the Microsoft Malware Challenge Dataset msc (2015) which consists of disassembled windows malware samples from 9 malware families/classes. We use 10260 samples which are disassembled file parser was able to process correctly. The second dataset is the Android Genome Project Dataset mal which consists of malicious Android apps. In our evaluation, we use only 9 classes that have at least 40 samples. After removing the smaller classes, the dataset has 986 samples. We extract function call graph (FCG) features from the malware samples as proposed by Hassen and Chan Hassen & Chan (2017) . In case of the Android samples Android dataset we first use ada to extract the functions and the function instructions and then used Hassen & Chan (2017) to extract the FCG features. For MS Challenge dataset, we reformat the FCG features as a graph adjacency matrix by taking the edge frequency features in Hassen & Chan (2017) and rearranging them to form an adjacency matrix. Formatting the features this way allowed us to use convolutional layers on the MS Challenge dataset. To show that our approach can be applied to other domains we also evaluate our work on the MNIST Datasetmni, which consists of images of handwritten digits from 0 to 9.
+To simulate an open world dataset for our evaluation datasets, we randomly choose $K$ number of classes from the dataset, which we will refer to as known classes in the remainder of this evaluation section, and keep only training instances from these classes in the training set. We will refer to the other classes as unknown classes. In case of the MS Dataset and Android Dataset, first, we randomly chose 6 known classes and treat set the remaining 3 as unknown classes. We then randomly select $7 5 \%$ of the instances from the known classes for the training set and the remaining for the test set. We further withhold one-third of the test set to serve as a validation set for hyperparameter tuning. We use only the known class instances for tuning. In these two datasets, all the unknown class instances are placed into the test set. In case of the MNIST dataset, first, we randomly chose 6 known classes and the remaining 4 as unknown classes. We then remove the unknown class instances from the training set. We leave the test set, which has both known and unknown class instances, as it is. For each of our evaluation datasets, we create 3 open set datasets. We will refer to these open set datasets as OpenMNIST1, OpenMNIST2, and OpenMNIST3 for the three open set evaluation datasets created from MNIST. Similarly, we also create OpenMS1, OpenMS2, and OpenMS3 for MS Challenge dataset and OPenAndroid1, OpenAndroid2, and OpenAndroid3 for Android Genom Project dataset.
+Evaluated Approaches We evaluate five approaches; all implemented using Tensorflow. The first $( i i )$ is a network setup to be trained using ii-loss. The second $( i i + c e )$ is a network setup to be simultaneously trained using ii-loss and cross entropy (Section 8). The third $( c e )$ is a network which we use to represent the baseline, is trained using cross-entropy only (network setup in Figure 1c without the ii-loss.) The forth approach is OpenmaxBendale & Boult (2016) (a state-of-art algorithm), which was reimplemented based on the original paper and the authors’ source code to fit our evaluation framework. The authors of Openmax state that the choice of distance function Euclidean or combined Euclidean and cosine distance give similar performance in the case of their evaluation datasets Bendale & Boult (2016). In our experiments, however, we observed that the combined Euclidean and cosine distance gives a much better performance. So we report the better result from combined Euclidean and cosine distance. The final approach is Generative Openmax (G-Openmax) Ge et al. (2017). The networks used for MS and MNIST datasets have convolutional layers at the beginning followed by fully connected layers, whereas for the android dataset we use only fully connected layers. The architecture is detailed Appendix A. Our source code is available on Github 1. The evaluation datasets are available online on their respective websites.
+# 4.1 DETECTING UNKNOWN CLASS INSTANCES AND OPEN SET RECOGNITION
+We start our evaluation by showing how well outlier_score (in Equation 2) is able to identify unknown class instances. We evaluate it using 3 random open set datasets created from MS, Android and MNIST datasets as discussed in the Section on simulating open set dataset. For example, in the case of MNIST dataset, we run 10 experiments on OpenMNIST1, 10 experiments on OpenMNIST2, and 10 experiments on OpenMNIST3. We then report the average of the 30 runs. We do the same for the other two datasets.
+Table 1: Average AUC of 30 runs up to $100 \%$ FPR and $10 \%$ FPR (the positive label represented instances from unknown classes and the negative label represented instances from the known classes when calculating the AUC). The underlined average AUC values are higher with statistical significance (p-value $< 0 . 0 5$ with a t-test) compared to the values that are not underlined on the same row. The average AUC values in bold are the largest average AUC values in each row.
+<table><tr><td></td><td>FPR</td><td>ce</td><td>ii</td><td>ii+ce</td></tr><tr><td rowspan="2">MNIST</td><td>100%</td><td>0.9282 (±0.0179)</td><td>0.9588 (±0.0140)</td><td>0.9475 (±0.0151)</td></tr><tr><td>10%</td><td>0.0775 (±0.0044)</td><td>0.0830 (±0.0045)</td><td>0.0801 (±0.0044)</td></tr><tr><td rowspan="2">MS Challenge</td><td>100%</td><td>0.9143 (±0.0433)</td><td>0.9387 (±0.0083)</td><td>0.9407 (±0.0135)</td></tr><tr><td>10%</td><td>0.0526 (±0.0091)</td><td>0.0623 (±0.0030)</td><td>0.0596 (±0.0035)</td></tr><tr><td rowspan="2">Android Genom</td><td>100%</td><td>0.7755 (±0.1114)</td><td>0.8563 (±0.0941)</td><td>0.9007 (±0.0426)</td></tr><tr><td>10%</td><td>0.0066 (±0.0052)</td><td>0.0300 (±0.0193)</td><td>0.0326 (±0.0182)</td></tr></table>
+Table 2: Average F-Score of 30 Runs. The underlined average AUC values are higher with statistical significance (p-value $< 0 . 0 5$ with a t-test) compared to the values that are not underlined on the same row. The average AUC values in bold are the largest average AUC values in each row.
+<table><tr><td></td><td>Openmax</td><td>G-Openmax</td><td>ce</td><td>ceii</td><td>ii</td></tr><tr><td>MNIST</td><td>0.88(±0.05)</td><td>0.69(±0.02)</td><td>0.74(±0.20)</td><td>0.92(±0.02)</td><td>0.93(±0.02)</td></tr><tr><td>MS</td><td>0.87(±0.01)</td><td>0.83(±0.02)</td><td>0.86(±0.04)</td><td>0.89(±0.01)</td><td>0.88(±0.01)</td></tr><tr><td>Android</td><td>0.30(±0.12)</td><td>0.60(±0.11)</td><td>0.46(±0.10)</td><td>0.71(±0.17)</td><td>0.69(±0.15)</td></tr></table>
+Table 1 shows the results of this evaluation. To report the results in such a way that is independent of outlier threshold, we report the area under ROC curve (AUC). This area is calculated using the outlier score and computing the true positive rate (TPR) and the false positive rate (FPR) at different thresholds. We use the t-test to measure the statistical significance of the difference in AUC values. Looking at the AUC up to $100 \%$ FPR in all three datasets, our approach $i i$ and $i i + c e$ perform significantly better(with $\mathsf { p }$ -value of 0.04 or less) in identifying unknown class instances than the baseline approach $c e$ (using only cross entropy loss.) Although AUC up to $100 \%$ FPR gives a full picture, in practice it is desirable to have good performance at lower false positive rates. That is is why we report AUC up to $10 \%$ FPR. Our two approaches report a significantly better AUC than the baseline network trained to only minimize cross entropy loss. We didn’t include Openmax in this section’s evaluation because it doesn’t have an explicit outlier score.
+When the proposed approach is used for open set recognition, the final prediction is a class label, which can be one of the $K$ known class labels if the test instances has an outlier score less than a threshold value or it can be an “unknown" label if the instance has an outlier score greater than the threshold, Eq. 3. In addition to the three approaches evaluated in the previous section, we also include Openmax Bendale & Boult (2016) and G-Openmax Ge et al. (2017) in these evaluations because they give final class label predictions.
+We use average F-score to evaluate open set recognition performance and t-test for statistical significance. Using the same experimental setup the earlier experiment, we report the result of the average f-score, averaged across all class labels and across 30 experiment runs in Table 2. On all three datasets the $i i$ and $i i + c e$ networks gives significantly better f-score compared to the other two configurations (with p-value of 0.0002 or less). In case of the Android dataset, all networks perform lower compared to the other two datasets. We attribute this to the small number of samples in the Android datasets. The dataset is also imbalanced with many classes only having less than 60 samples.
+Two limitations of Openmax can explain its weaker performance compared to our proposed approaches: 1) it does not use a loss function that directly incentivizes projecting class instances around the mean class activation vector and 2) the distance function used by Openmax is not necessarily the right distance function for final activation vector space since it is not used in training. We addressed these limitations by training a neural network with a loss function that explicitly encourages properties P1 and P2. Also, we use the same distance function during training and test.
+![](images/c2b45326e66954ea640041c5efcc3e32e8427337726d4e890b76a0da28fa50d5.jpg)
+Figure 2: The z-layer projection of (a, b) known and (c, d) unknown class instances from test set of MNIST dataset. The labels 0,2,3,4,6,9 represent the known classes while the label “unknown" represents the unknown classes.
+# 4.2 DISCUSSIONS
+Figure 2 provides evidence on how our network projects unknown class instances in the space between the known classes. In the figure the $\mathbf { Z }$ -layer projection of 2000 random test instances of an open set dataset created from MNIST with 6 known and 4 unknown classes. The class labels 0, 2, 3, 4, 6, and 9 in the figure represent the 6 known classes while the “unknown" label represents all the unknown classes. The network with ii-loss is set up to have a z-layer dimension of 6, and the figure shows a 2D plot of dimension (z0,z1), (z0,z2). The Openmax network also has a similar network architecture and last layer dimension of 6. In case of ii-loss based projection, the instances from the known classes (Figures 2a) are projected close to their respective class while the unknown class instances (Figures 2c) are projected, for the most part, in the region between the classes. In case of Openmax, Figures 2b and 2d, the unknown class instances do not fully occupy the open space between the known classes. In Openmax, most instances are projected along the axis; this is because of the one-hot encoding induced by cross-entropy loss. So compared to Openmax, ii-loss appears to better utilize space “among" the classes.
+![](images/68e4758561fecd79ff15bc0e6f1f51b6593435334622f17ac3ec4d5db3b98486.jpg)
+Figure 3: Projections of Android dataset known class test instances from final activation layer of Openmax.
+![](images/fea0ce400d50c7fc9581892765c26c8ef8cb76d27c28d10a72d836e7d47d21f5.jpg)
+Figure 4: Projections of Android dataset (a) known class and (b) unknown class test instances from $\mathbf { Z }$ -layer of a network trained with only cross entropy.
+![](images/6c55368f55b1ffbe3d37eaf6f46c2ab8e7589e6a763d2b0b10efdec3f97c2381.jpg)
+Figure 5: Inter class separation for networks trained (a) with batch normalization used in all layers and (b) without batch normalization at the $\mathbf { Z }$ -layer.
+Performance of Openmax is especially low in case of the Android dataset because of low recall on known classes with small number training instances. The low recall was caused by test instances from the smaller classes being projected further away from the class’s mean activation vector (MAV). For example, in Figure 3a we see that test instances of class 2 are further away from the MAV of class 2 (marked by $\because \overrightarrow { \mathbf { \nabla } } \star \overrightarrow { \mathbf { \nabla } }$ ). As a result, these test instances are predicted as unknown. Similarly, in Figure 3b instances of class 3 are far away from the MAV of class 3(marked by ’X’). Performance of network trained with only cross entropy (ce) is also low for Android dataset because unknown class instances were projected close to the known classes (Figure 4). As a result, these instances get labeled as known classes. In turn, resulting in a lower precision score for the known classes.
+In our experiments, we have observed batch normalization Ioffe & Szegedy (2015) to be extremely important when using ii-loss. Because batch normalization fixes the mean and variance of a layer, it bounds the output of our $\mathbf { Z }$ -layer in a certain hypercube, in turn preventing the inter_separation term in ii-loss from increasing indefinitely. This is evident in Figures 5a and 5b. Figure 5a shows the inter_separation of the network where batch normalization used in all layers including the z-layer; here, the inter_separation increases in the beginning but levels off. Whereas when batch normalization is not used in the $\mathbf { Z }$ -layer the inter_separation term keeps on increasing as seen in Figure 5b; as a result, ii-loss would not converge.
+Autoencoders can also be considered as another way to learn a representation. However, autoencoders do not try to achieve properties P1 and P2. One of the reasons is autoencoder training is unsupervised. Another reason is that non-regularized autoencoders fracture the manifold into different domains resulting in the representation of instances from the same class being further apart Makhzani et al. (2015). Therefore, in the learned representation, the known classes are not well separated. Additionally, outliers get projected to roughly the same area as the known classes. A figure in Appendix C shows the output of an encoder in an autoencoder.
+# 5 CONCLUSION
+We presented an approach for learning a neural network based representation that projects instances of the same class closer together while projecting instances of the different classes further apart. Our empirical evaluation shows that the two properties lead to larger spaces among classes for instances of unknown classes to occupy, hence facilitating open set recognition. We compared our proposed approach with a baseline network trained to minimize a cross entropy loss and with Openmax (a state-of-art neural network based open set recognition approach). We evaluated the approaches on datasets of malware samples and images and observed that our proposed approach achieves statistically significant improvement. We proposed a simple threshold estimation technique in this paper. However, there is room to explore a more robust way to estimate the threshold. We leave this for future work.
+# REFERENCES
+Adagio. https://github.com/hgascon/adagio.
+Android malware genome project. http://www.malgenomeproject.org/.
+Mnist hand written digit dataset. http://yann.lecun.com/exdb/mnist/.
+Microsoft malware classification challenge (big 2015). https://www.kaggle.com/c/malwareclassification, 2015. [Online; accessed 27-April-2015].
+Abhijit Bendale and Terrance Boult. Towards open world recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1893–1902, 2015.
+Abhijit Bendale and Terrance E Boult. Towards open set deep networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1563–1572, 2016.
+Paul Bodesheim, Alexander Freytag, Erik Rodner, Michael Kemmler, and Joachim Denzler. Kernel null space methods for novelty detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3374–3381, 2013.
+Paul Bodesheim, Alexander Freytag, Erik Rodner, and Joachim Denzler. Local novelty detection in multi-class recognition problems. In Applications of Computer Vision (WACV), 2015 IEEE Winter Conference on, pp. 813–820. IEEE, 2015.
+Douglas O Cardoso, Felipe França, and João Gama. A bounded neural network for open set recognition. In Neural Networks (IJCNN), 2015 International Joint Conference on, pp. 1–7. IEEE, 2015.
+Qing Da, Yang Yu, and Zhi-Hua Zhou. Learning with augmented class by exploiting unlabeled data. In Twenty-Eighth AAAI Conference on Artificial Intelligence, 2014.
+Thomas G. Dietterich. Steps toward robust artificial intelligence. AI Magazine, 38(3):3–24, 2017.
+ZongYuan Ge, Sergey Demyanov, Zetao Chen, and Rahil Garnavi. Generative openmax for multiclass open set classification. arXiv preprint arXiv:1707.07418, 2017.
+Mehadi Hassen and Philip K. Chan. Scalable function call graph-based malware classification. In 7th Conference on Data and Application Security and Privacy, pp. 239–248. ACM, 2017.
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+Lalit P Jain, Walter J Scheirer, and Terrance E Boult. Multi-Class Open Set Recognition Using Probability of Inclusion. pp. 393–409, 2014.
+K. Lee, H. Lee, K. Lee, and J. Shin. Training confidence-calibrated classifiers for detecting out-ofdistribution samples. In Proc. ICLR 2018, 2018.
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.
+Enrique G Ortiz and Brian C Becker. Face recognition for web-scale datasets. Computer Vision and Image Understanding, 118:153–170, 2014.
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+Konrad Rieck, Philipp Trinius, Carsten Willems, and Thorsten Holz. Automatic analysis of malware behavior using machine learning. Journal of Computer Security, 19(4):639–668, 2011.
+Ethan Rudd, Andras Rozsa, Manuel Gunther, and Terrance Boult. A survey of stealth malware: Attacks, mitigation measures, and steps toward autonomous open world solutions. IEEE Communications Surveys & Tutorials, 2017.
+Walter J Scheirer, Anderson de Rezende Rocha, Archana Sapkota, and Terrance E Boult. Toward open set recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(7): 1757–1772, 2013.
+Y. Yu, W. Qu, N. Li, and Z. Guo. Open-category classification by adversarial sample generation. In Proc. IJCAI 2017, pp. 3357–3363, 2017.
+# A EVALUATION NETWORK ARCHITECTURES
+We evaluate 5 networks: ii, ce, $_ { \mathrm { i i + c e } }$ , Openmax and G-Openmax. The first four networks and the final classifier of G-Openmax have the same architecture up to the fully connected $\mathbf { Z }$ -layer. In case of the MNIST dataset, the input images are of size (28,28) and are padded to get an input layer size (32,32) with 1 channel. Following the input, layer are 2 non-linear convolutional layers with 32 and 64 units (filters) which have a kernel size of (4,4) with a (1,1) strides and SAME padding. The network also has max polling layers with a kernel size of (3,3), strides of (2,2), and SAME padding after each convolutional layer. Two fully connected non-linear layers with 256 and 128 units follow the second max pooling layer. Then a linear z-layer with a dimension of 6 follows the fully connected layers. In the case of $_ \mathrm { i i + c e }$ and ce networks, the output of the $\mathbf { Z }$ -layer is fed to an additional linear layer of dimension 6 which is then given to a softmax function. We use Relu activation function for all the non-linear layers. Batch normalization is used throughout all the layers. We also use Dropout with keep probability of 0.2 for the fully connected layers. Adam optimizer with a learning rate of 0.001, beta1 of 0.5, and beta2 of 0.999 is used to train our networks for 5000 iterations. In case of the Openmax network, the output of the $\mathbf { Z }$ -layer is directly fed to a softmax layer. Similar to the Openmax paper we use a distance that is a weighted combination of normalized Euclidean and cosine distances. For the ce, ii, and $_ { \mathrm { i i + c e } }$ we use contamination ratio of 0.01 for the threshold selection.
+The open set experiments for MS Challenge dataset also used similar architectures as the four networks used for MNIST dataset with the following differences. The input layer size MS Challenge dataset is (67,67) with 1 channel after padding the original input of (63,63). Instead of the two fully connected non-linear layers, we use one fully connected layer with 256 units. We use dropout in the fully connected layer with keep probability of 0.9. Finally, the network was trained using Adam optimizer with 0.001 learning rate, 0.9 beta1, and 0.999 beta2.
+We do not use a convolutional network for the Android dataset open set experiments. We use a network with one fully connected layer of 64 units. This is followed by a $\mathbf { Z }$ -layer with a dimension of 6. For $_ \mathrm { i i + c e }$ and ce networks we further add a linear layer with a dimension of 6 and the output of this layer is fed to a softmax layer. In case of Openmax, the output of the $\mathbf { Z }$ -layer is directly fed to the softmax layer. For Openmax we use a distance that is a weighted combination of normalized Euclidean and cosine distances. We use Relu activation function for all the nonlinear layers. We used batch normalization for all layers. We also used Dropout with keep probability of 0.9 for the fully connected layers. We used Adam optimizer with a learning rate of 0.1 and first momentum of 0.9 to train our networks for 10000 iterations. For the ce, ii, and ii+ce we use contamination ratio of 0.01 for the threshold selection.
+The closed set experiments use the same set up as the open set experiments with the only difference coming from the dimension of the z-layer. For the MNIST dataset, we used z dimension of 10. For the MS and Android datasets, we use z dimension of 9.
+# B CLOSED SET CLASSIFICATION
+In this section, we would like to show that on a closed dataset, a network trained using ii-loss performs comparably to the same network trained using cross entropy loss. For closed set classification, all the classes in the dataset are used for both training and test. For MS and Android datasets, we randomly divide the datasets into training, validation, and test and report the results on the test set. The MNIST dataset is already divided into training, validation, and test.
+On closed MNIST dataset, a network trained with cross-entropy achieved a 10-run average classification accuracy of $9 9 . 4 2 \%$ . The same network trained using ii-loss achieved an average accuracy of $9 9 . 3 1 \%$ . The network trained only on cross-entropy gives better performance than the network trained on ii-loss. The results from a network trained both ii-loss cross entropy loss to achieve an average classification accuracy of $9 9 . 4 0 \%$ . This result makes it comparable to the performance of the same network trained using cross-entropy only (with a p-value of 0.22). We acknowledge that both results are not state-of-art as we are using simple network architectures. The primary goal of these experiments is to show that the ii-loss trained network can give comparable results to a cross entropy trained network. On the Android dataset, the network trained on a cross entropy gets an average classification accuracy of $9 3 . 1 0 \%$ while ii-loss records $9 2 . 6 8 \%$ , but the difference is not significant (with a p-value at 0.43).
+# C DISCUSSION
+![](images/6bab02304b6eaeec5b486e0dd187d991c65cce0d65554b54371ecdd222f904fd.jpg)
+Figure 6: Projections of (a) known and (b) unknown class instances using the hidden layer of an Autoencoder. The labels 0,2,3,4,6,9 represent the known classes while the label “unknown" represents the unknown classes.
+We mentioned earlier that we used function call graph (FCG) feature for the malware dataset. We also mentioned that in case of the MS Challenge dataset we reformatted the FCG features proposed in Hassen & Chan (2017) to form a (63, 63) adjacency matrix representation of the graph. We feed this matrix as an input to the convolutional network with a (4,4) kernel. Such kernel shape makes sense when it comes to image input because in images proximity of pixels hold essential information. However, it is not apparent to us how nearby cells in a graph adjacency matrix hold meaning full information. We tried different kernel shapes, for example taking an entire row of the matrix at once (because a row of the matrix represents single nodes outgoing edge weights). However the simple (4,4) gives a better close set performance.

parse/train/r1elIi09K7/r1elIi09K7_content_list.json ADDED Viewed

	@@ -0,0 +1,1113 @@

+[
+    {
+        "type": "text",
+        "text": "LEARNING A NEURAL-NETWORK-BASED REPRESENTATION FOR OPEN SET RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            826,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a neural network based representation for addressing the open set recognition problem. In this representation instances from the same class are close to each other while instances from different classes are further apart, resulting in statistically significant improvement when compared to other approaches on three datasets from two different domains. ",
+        "bbox": [
+            232,
+            265,
+            764,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            336,
+            376
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To build robust AI systems, Dietterich Dietterich (2017) reasons that one of the main challenges is handling the “unknown unknowns.\" One idea is to detect model failures (i.e., the system understands that its model about the world/domain has limitations and may fail). For example, assume you trained a binary classifier model to discriminate between pictures of cats and dogs. Let’s assume this model performs well at recognizing images of cats and dogs. What would this model do if it is faced with a picture of a fox or a caracal? The model being a binary classifier will predict these pictures to be either a dog or a cat, which is not desirable and can be considered as a failure of the model. In machine learning, one direction of research for detecting model failure is “open category learning\", where not all categories are known during training, and the system needs to appropriately handle instances from novel/unknown categories that may appear during testing. Besides “open category learning\", terms such as “open world recognition\" Bendale & Boult (2015) and “open set recognition\" Scheirer et al. (2013); Bendale & Boult (2016) have been used in past literatures. In this paper, we will use the term “open set recognition\". ",
+        "bbox": [
+            174,
+            391,
+            825,
+            571
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Where does open set recognition appear in real-world problems? Various real-world applications operate in an open set scenario. For example, Ortiz and Becker Ortiz & Becker (2014) point to the problem of face recognition. One such use case is automatic labeling of friends in social media posts, “where the system must determine if the query face exists in the known gallery, and, if so, the most probable identity.\" Another domain is in malware classification, where training data usually is incomplete because of novel malware families/classes that emerge regularly. As a result, malware classification systems operate in an open set scenario. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            676
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a neural network based representation and a mechanism that utilizes this representation for performing open set recognition. Since our primary motivation when developing this approach was the malware classification domain, we evaluate our work on two malware datasets. To show the applicability of our approach to other domains, we evaluate our approach on images. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our contributions include: (1) we propose an approach for learning a representation that facilitates open set recognition, (2) we propose a loss function that enables us to use the same distance function both when training and when computing an outlier score, (3) our proposed approaches achieve statistically significant improvement compared to previous research work on three datasets. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            803
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            821,
+            344,
+            838
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We can broadly categorize existing open set recognition systems into two types. The first type provides mechanisms to discriminate known class instances from unknown class instances. These systems, however, cannot discriminate between the known classes, where there is more than one. Research works such as Scheirer et al. (2013); Bodesheim et al. (2013; 2015) fall in this category. Scheirer et al. Scheirer et al. (2013) formalized the concept of open set recognition and proposed a ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1-vs-set binary SVM based approach. Bodesheim et al. Bodesheim et al. (2013) propose KNFST for performing open set recognition for multiple known classes at the same time. The idea of KNFST is further extended in Bodesheim et al. (2015) by considering the locality of a sample when calculating its outlier score. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The second type of open set recognition system provides the ability to discriminate between known classes in addition to identifying unknown class instances. Research works such as Jain et al. (2014); Bendale & Boult (2015; 2016); Da et al. (2014); Ge et al. (2017) fall in this category. PI-SVM Jain et al. (2014), for instance, uses a collection of binary SVM classifiers, one for each class, and fits a Weibull distribution over the score of each classifier. This approach allows PI-SVM to be able to both perform recognition of unknown class instances and classification between the known class instances. Bendale and Boult Bendale & Boult (2015) propose an approach to extend Nearest Class Mean (NCM) to perform open set recognition with the added benefit of being able to do incremental learning. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Neural Net based methods for open set recognition have been proposed in Bendale & Boult (2016); Cardoso et al. (2015); Ge et al. (2017). Openmax Bendale & Boult (2016) (a state-of-art algorithm) modifies the regular Softmax layer of a neural network by redistributing the activation vector (the values of the final layer of a neural network that are given as input to the Softmax function) to account for unknown classes. Ge et al. Ge et al. (2017) use DCGAN Radford et al. (2015) to generate unknown-class samples. The network is trained on the original instances plus the generated samples, and Openmax is used to ajdusted the activation vector. Similarly, Yu et al. Yu et al. (2017) generate “negative” samples using adversarial learning and use supervised algorithms to learn the final classifier. Our approach does not generate “unknown-class/negative” samples and hence does not increase the training overhead in the learning step. In malware classification, K. Rieck et al.Rieck et al. (2011) proposed a malware clustering approach and an associated outlier score. Although the authors did not propose their work for open set recognition, their outlier score can be used for unsupervised open set recognition. Rudd et al. Rudd et al. (2017) outline ways to extend existing closed set intrusion detection approaches for open set scenarios. Lee et al. Lee et al. (2018) are interested in detecting test samples that are out-of-distribution (different from the training “in-distribution’); however, each test sample is still from one of the known classes. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            541,
+            297,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For open set recognition, given a set of instances belonging to known classes, we would like to learn a function that can accurately classify an unseen instance to one of the known classes or an unknown class. Let $D$ be a set of instances $X$ and their respective class labels $Y$ (i.e., $D = ( X , Y ) ,$ , and $K$ be the number of unique known class labels. Given $D$ for training, the problem of open set recognition is to learn a function $f$ that can accurately classify an unseen instance (not in $X$ ) to one of the $K$ classes or an unknown class (or the “none of the above\" class). ",
+        "bbox": [
+            174,
+            573,
+            825,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The problem of open set recognition differs from the problem of closed set (“regular\") classification because the learned function $f$ needs to handle unseen instances that might belong to classes that are not known during training. That is, the learner is robust in handling instances of classes that are not known. This difference is the main challenge for open set recognition. Another challenge is how to learn a more effective instance representation that facilitates open set recognition than the original instance representation used in $X$ . ",
+        "bbox": [
+            174,
+            662,
+            825,
+            747
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Learning representations Consider $\\vec { x }$ is an instance and $y = f ( \\vec { x } )$ is the class label predicted using $f ( \\vec { x } )$ . In case of a closed set, $y$ is one of the known class labels. In the case of open set, $y$ could be one of the known classes or an unknown class. The hidden layers in a neural network, ${ \\vec { z } } = g ( { \\vec { x } } )$ , can be considered as different representations of $\\vec { x }$ . Note, we can rewrite $y$ in terms of the hidden layer as $y = f ( \\vec { z } ) = f ( g ( \\vec { x } ) )$ . ",
+        "bbox": [
+            174,
+            762,
+            825,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The objective of our approach is to learn a representation that facilitates open set recognition. We would like this new representation to have two properties: (P1) instances of the same class are closer together, and (P2) instances of different classes are further apart. The two properties can lead to larger spaces among known classes for the instances of the unknown classes to occupy. Consequently, instances of unknown classes could be more effectively detected. This representation is similar in spirit to a Fisher Discriminant. A Fisher discriminant aims to find a linear projection that maximizes ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Training to minimize ii-loss. ",
+        "bbox": [
+            176,
+            107,
+            454,
+            122
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input :   \n$( X , Y )$ : Training data and labels   \n1 for number of training iterations do   \n2 Sample a mini-batch ( $X _ { b a t c h }$ , $Y _ { b a t c h . }$ ) from $( X , Y )$   \n3 $Z _ { b a t c h } \\gets g ( X _ { b a t c h } )$   \n4 $\\{ \\vec { \\mu } _ { 1 } \\cdot \\cdot \\cdot \\vec { \\mu } _ { K } \\}  c l a s s \\_ m e a n s ( Z _ { b a t c h } , Y _ { b a t c h } )$   \n5 $\\begin{array} { r } { | | \\neg | 0 { \\sf S } { \\sf S }  i n t r a _ { - } s p r e a d ( Z _ { b a t c h } , \\{ \\vec { \\mu } _ { 1 } \\cdot \\cdot \\cdot \\vec { \\mu } _ { K } \\} ) } \\end{array}$ - inter_separation $\\left( \\{ \\vec { \\mu } _ { 1 } \\cdots \\vec { \\mu } _ { K } \\} \\right)$   \n6 update parameters of $g$ using stochastic gradient descent to minimize ii-loss   \n7 $\\{ \\vec { \\mu } _ { 1 } \\cdot \\cdot \\cdot \\vec { \\mu } _ { K } \\} \\gets c l a s s \\_ m e a n s ( g ( X ) , Y )$   \n8 return $\\{ \\vec { \\mu } _ { 1 } \\cdot \\cdot \\cdot \\vec { \\mu } _ { K } \\}$ and parameters of $g$ as the model. ",
+        "bbox": [
+            160,
+            126,
+            736,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "between class (inter-class) separation while minimizing within class (intra-class) spread. Such a projection is obtained by maximizing the Fisher criteria. However, in the case of this work, we use a neural network with a non-linear projection to learn this representation. The neural network $g$ used to learn the representation can be either a combination of convolution and fully connected layers, as shown in Figure 1a, or it can be all fully connected layers, Figure 1b. Both types are used in our experimental evaluation. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "II-Loss Function In a typical neural network classifier, the activation vector that comes from the final linear layer is given as input to a Softmax function. Then the network is trained to minimize a loss function such as cross-entropy on the outputs of the Softmax layer. In our case, the output vector $\\vec { z _ { i } }$ of the final linear layer of a neural network (i.e., activation vector that serves as input to a softmax in a typical neural net) are considered as the projection of the input vector $\\vec { x _ { i } }$ , of instance $i$ , to a different space. The network is trained using mini-batch stochastic gradient descent with backpropagation as outlined in Algorithm 1 to minimize the loss function in Equation 1, which we will refer to ii-loss for the remainder of this paper. In this loss function, we aim to maximize the distance between different classes (inter-class separation) and minimize the distance of an instance from its class mean (intra-class spread). We measure intra-class spread as the average distance of instances from their class means (first part of Equation 1). We measure the inter-class separation in terms of the distance between the closest two class means among all the $K$ known classes (second part of Equation 1). After the network finishes training, the class means are calculated for each class using all the training instances of that class and stored as part of the model. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e35c34fe7f1ed3e2a92f471267aebf358fd76c5a75a68e370400a82b0fcf4b8e.jpg",
+        "text": "$$\ni i - l o s s = \\big ( \\underbrace { \\frac { 1 } { N } \\sum _ { j = 1 } ^ { K } \\sum _ { i = 1 } ^ { | C _ { j } | } \\| \\vec { \\mu _ { j } } - \\vec { z _ { i } } \\| _ { 2 } ^ { 2 } } _ { \\mathrm { i n t r a . } \\mathrm { s p r e a d } } \\big ) - \\big ( \\ * { \\underset { 1 \\leq m \\leq K } { \\operatorname* { m i n } } } \\| \\vec { \\mu _ { m } } - \\vec { \\mu _ { n } } \\| _ { 2 } ^ { 2 } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            625,
+            709,
+            691
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $| C _ { j } |$ is the number of training instances in class $C _ { j }$ , $N$ is the number of training instances, $K$ is the number of known classes, and \\~µj = 1|C | P|Cj |i=1 z is the mean of class $C _ { j }$ . ",
+        "bbox": [
+            176,
+            703,
+            821,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Combining ii-loss with Cross Entropy Loss While the two desirable properties P1 and P2 discussed in an earlier Section aim to have a representation that separates instances from different classes, lower classification error is not explicitly stated. Hence, a third desirable property (P3) is a low classification error in the training data. To achieve this, alternatively, a network can be trained on both cross entropy loss and ii-loss (Eq 1) simultaneously. The network architecture in Figure 1c can be used. In this configuration, an additional linear layer is added after the $\\mathbf { Z }$ -layer. The output of this linear layer is passed through a Softmax function to produce a distribution over the known classes. Although Figure 1c shows a network with convolutional and fully connected layers, combining ii-loss with cross-entropy can also work with a network of fully connected layers only. The network is trained using mini-batch stochastic gradient descent with backpropagation. During each training iteration, the network weights are first updated to minimize on ii-loss and then in a separate step updated to minimize cross entropy loss. Other researchers have trained neural networks using more than one loss function. For example, the encoder network of an Adversarial autoencoder Makhzani et al. (2015) is updated both to minimize the reconstruction loss and the generators loss. ",
+        "bbox": [
+            173,
+            756,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e463f1d7aa4660a386dbb6243ffe7299ea829dd5ecc4ed54f0487a622f154ed.jpg",
+        "image_caption": [
+            "Figure 1: Network architecture with ii-loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            101,
+            800,
+            289
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            344,
+            823,
+            373
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Outlier Score for Open Set Recognition During testing, we use an outlier score to indicate the degree to which the network predicts an instance $\\vec { x }$ to be an outlier. This outlier score is calculated as the distance of an instance to the closest class mean from among $K$ known classes. ",
+        "bbox": [
+            173,
+            391,
+            823,
+            434
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ee95714d3bc33a03219b20c488b63d5073fa4f5ba98e29afb97bbbfc6ea592a2.jpg",
+        "text": "$$\no u t l i e r \\_ s c o r e ( \\vec { x } ) = \\operatorname* { m i n } _ { 1 \\leq j \\leq K } \\left\\| \\vec { \\mu } _ { j } - \\vec { z } \\right\\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            443,
+            629,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\vec { z } } = g ( { \\vec { x } } )$ . Because the network is trained to project the members of a class as close to the class mean as possible the further away the projection $\\vec { z }$ of instance $\\vec { x }$ is from the closest class mean, the more likely the instance is an outlier for that class. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Threshold Estimation Once an outlier score identified, the next step is determining what threshold value of this score will indicate an outlier. In other words, how far does the projection of an instance need to be from the closest class mean for it to be deemed an outlier. For this work, we propose a simple threshold estimation. To pick an outlier threshold, we assume that a certain percent of the training set to be noise/outliers . We refer to this percentage as the contamination ratio. For example, if we set the contamination ratio to be 0.01, it will be like assuming $1 \\%$ of the training data to be noise/outliers. Then, we calculate the outlier score on the training set instances, sort the scores in ascending order and pick the 99 percentile outlier score value as the outlier threshold value. The reader might notice that the threshold proposed in this section is a global threshold. This means that the same outlier threshold value is used for all classes. An alternative to this approach is to estimate the outlier threshold per-class. However, in our evaluation, we observe that global threshold consistently gives more accurate results than the per-class threshold. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Performing Open Set Recognition Open set recognition is a classification over $K + 1$ class labels, where the first $K$ labels are from the known classes the classifier is trained on, and the $K + 1 \\mathrm { s t }$ label represents the unknown class. This is performed using the outlier score in Equation 2 and the associated threshold. The outlier_score of a test instance is first calculated. If the score is greater than threshold, the test instance is labeled as $K + 1$ , which in our case corresponds to the unknown class; otherwise, the appropriate class label is assigned to the instance from among the known classes, Equation 3. The predicted class probability over the known classes, we can be expressed as the softmax of the negative distance of a projection $\\vec { z }$ , of the test instance $\\vec { x }$ (i.e., $\\vec { z } = g ( \\vec { x } ) )$ , from all the known class means, Equation 4. Note, when a network network trained on both ii-loss and cross entropy loss $P ( y = k \\mid \\vec { x } )$ is from the Softmax layer in Figure 1c. ",
+        "bbox": [
+            173,
+            726,
+            826,
+            866
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71b5e49f20bd4acd3867f5b6ec8c1f6202012375a52faf92a8eb2ced42f7daea.jpg",
+        "text": "$$\ny = { \\left\\{ \\begin{array} { l l } { K + 1 , } & { { \\mathrm { i f ~ } } o u t l i e r \\_ s c o r e > t h r e s h o l d } \\\\ { { \\mathrm { a r g m a x } } P ( y = j \\mid { \\vec { x } } ) , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            886,
+            705,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a2cb8857d65e7dd7429208bd0b172ec108392f87f983df89144ea5000f4be67a.jpg",
+        "text": "$$\nP ( y = j \\mid \\vec { x } ) = \\frac { e ^ { - \\parallel \\vec { \\mu } _ { j } - \\vec { z } \\parallel _ { 2 } ^ { 2 } } } { \\sum _ { m = 1 } ^ { K } e ^ { - \\parallel \\vec { \\mu } _ { m } - \\vec { z } \\parallel _ { 2 } ^ { 2 } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            113,
+            619,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            167,
+            315,
+            184
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets and Simulating Open Set Dataset We evaluate our approach using three datasets. The first is the Microsoft Malware Challenge Dataset msc (2015) which consists of disassembled windows malware samples from 9 malware families/classes. We use 10260 samples which are disassembled file parser was able to process correctly. The second dataset is the Android Genome Project Dataset mal which consists of malicious Android apps. In our evaluation, we use only 9 classes that have at least 40 samples. After removing the smaller classes, the dataset has 986 samples. We extract function call graph (FCG) features from the malware samples as proposed by Hassen and Chan Hassen & Chan (2017) . In case of the Android samples Android dataset we first use ada to extract the functions and the function instructions and then used Hassen & Chan (2017) to extract the FCG features. For MS Challenge dataset, we reformat the FCG features as a graph adjacency matrix by taking the edge frequency features in Hassen & Chan (2017) and rearranging them to form an adjacency matrix. Formatting the features this way allowed us to use convolutional layers on the MS Challenge dataset. To show that our approach can be applied to other domains we also evaluate our work on the MNIST Datasetmni, which consists of images of handwritten digits from 0 to 9. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To simulate an open world dataset for our evaluation datasets, we randomly choose $K$ number of classes from the dataset, which we will refer to as known classes in the remainder of this evaluation section, and keep only training instances from these classes in the training set. We will refer to the other classes as unknown classes. In case of the MS Dataset and Android Dataset, first, we randomly chose 6 known classes and treat set the remaining 3 as unknown classes. We then randomly select $7 5 \\%$ of the instances from the known classes for the training set and the remaining for the test set. We further withhold one-third of the test set to serve as a validation set for hyperparameter tuning. We use only the known class instances for tuning. In these two datasets, all the unknown class instances are placed into the test set. In case of the MNIST dataset, first, we randomly chose 6 known classes and the remaining 4 as unknown classes. We then remove the unknown class instances from the training set. We leave the test set, which has both known and unknown class instances, as it is. For each of our evaluation datasets, we create 3 open set datasets. We will refer to these open set datasets as OpenMNIST1, OpenMNIST2, and OpenMNIST3 for the three open set evaluation datasets created from MNIST. Similarly, we also create OpenMS1, OpenMS2, and OpenMS3 for MS Challenge dataset and OPenAndroid1, OpenAndroid2, and OpenAndroid3 for Android Genom Project dataset. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluated Approaches We evaluate five approaches; all implemented using Tensorflow. The first $( i i )$ is a network setup to be trained using ii-loss. The second $( i i + c e )$ is a network setup to be simultaneously trained using ii-loss and cross entropy (Section 8). The third $( c e )$ is a network which we use to represent the baseline, is trained using cross-entropy only (network setup in Figure 1c without the ii-loss.) The forth approach is OpenmaxBendale & Boult (2016) (a state-of-art algorithm), which was reimplemented based on the original paper and the authors’ source code to fit our evaluation framework. The authors of Openmax state that the choice of distance function Euclidean or combined Euclidean and cosine distance give similar performance in the case of their evaluation datasets Bendale & Boult (2016). In our experiments, however, we observed that the combined Euclidean and cosine distance gives a much better performance. So we report the better result from combined Euclidean and cosine distance. The final approach is Generative Openmax (G-Openmax) Ge et al. (2017). The networks used for MS and MNIST datasets have convolutional layers at the beginning followed by fully connected layers, whereas for the android dataset we use only fully connected layers. The architecture is detailed Appendix A. Our source code is available on Github 1. The evaluation datasets are available online on their respective websites. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DETECTING UNKNOWN CLASS INSTANCES AND OPEN SET RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            847,
+            723,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We start our evaluation by showing how well outlier_score (in Equation 2) is able to identify unknown class instances. We evaluate it using 3 random open set datasets created from MS, Android and MNIST datasets as discussed in the Section on simulating open set dataset. For example, in the case of MNIST dataset, we run 10 experiments on OpenMNIST1, 10 experiments on OpenMNIST2, and 10 experiments on OpenMNIST3. We then report the average of the 30 runs. We do the same for the other two datasets. ",
+        "bbox": [
+            176,
+            873,
+            825,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fec90605ea457803d89af82125bf61d98ddc2f7be5d9eb5dc537ec6ec785a9e1.jpg",
+        "table_caption": [
+            "Table 1: Average AUC of 30 runs up to $100 \\%$ FPR and $10 \\%$ FPR (the positive label represented instances from unknown classes and the negative label represented instances from the known classes when calculating the AUC). The underlined average AUC values are higher with statistical significance (p-value $< 0 . 0 5$ with a t-test) compared to the values that are not underlined on the same row. The average AUC values in bold are the largest average AUC values in each row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>FPR</td><td>ce</td><td>ii</td><td>ii+ce</td></tr><tr><td rowspan=\"2\">MNIST</td><td>100%</td><td>0.9282 (±0.0179)</td><td>0.9588 (±0.0140)</td><td>0.9475 (±0.0151)</td></tr><tr><td>10%</td><td>0.0775 (±0.0044)</td><td>0.0830 (±0.0045)</td><td>0.0801 (±0.0044)</td></tr><tr><td rowspan=\"2\">MS Challenge</td><td>100%</td><td>0.9143 (±0.0433)</td><td>0.9387 (±0.0083)</td><td>0.9407 (±0.0135)</td></tr><tr><td>10%</td><td>0.0526 (±0.0091)</td><td>0.0623 (±0.0030)</td><td>0.0596 (±0.0035)</td></tr><tr><td rowspan=\"2\">Android Genom</td><td>100%</td><td>0.7755 (±0.1114)</td><td>0.8563 (±0.0941)</td><td>0.9007 (±0.0426)</td></tr><tr><td>10%</td><td>0.0066 (±0.0052)</td><td>0.0300 (±0.0193)</td><td>0.0326 (±0.0182)</td></tr></table>",
+        "bbox": [
+            199,
+            183,
+            799,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1aa5fe6bc5af7c2372961cb1d26060e60976adde85074d568d54fbecb0925c81.jpg",
+        "table_caption": [
+            "Table 2: Average F-Score of 30 Runs. The underlined average AUC values are higher with statistical significance (p-value $< 0 . 0 5$ with a t-test) compared to the values that are not underlined on the same row. The average AUC values in bold are the largest average AUC values in each row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Openmax</td><td>G-Openmax</td><td>ce</td><td>ceii</td><td>ii</td></tr><tr><td>MNIST</td><td>0.88(±0.05)</td><td>0.69(±0.02)</td><td>0.74(±0.20)</td><td>0.92(±0.02)</td><td>0.93(±0.02)</td></tr><tr><td>MS</td><td>0.87(±0.01)</td><td>0.83(±0.02)</td><td>0.86(±0.04)</td><td>0.89(±0.01)</td><td>0.88(±0.01)</td></tr><tr><td>Android</td><td>0.30(±0.12)</td><td>0.60(±0.11)</td><td>0.46(±0.10)</td><td>0.71(±0.17)</td><td>0.69(±0.15)</td></tr></table>",
+        "bbox": [
+            209,
+            377,
+            789,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            477,
+            825,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the results of this evaluation. To report the results in such a way that is independent of outlier threshold, we report the area under ROC curve (AUC). This area is calculated using the outlier score and computing the true positive rate (TPR) and the false positive rate (FPR) at different thresholds. We use the t-test to measure the statistical significance of the difference in AUC values. Looking at the AUC up to $100 \\%$ FPR in all three datasets, our approach $i i$ and $i i + c e$ perform significantly better(with $\\mathsf { p }$ -value of 0.04 or less) in identifying unknown class instances than the baseline approach $c e$ (using only cross entropy loss.) Although AUC up to $100 \\%$ FPR gives a full picture, in practice it is desirable to have good performance at lower false positive rates. That is is why we report AUC up to $10 \\%$ FPR. Our two approaches report a significantly better AUC than the baseline network trained to only minimize cross entropy loss. We didn’t include Openmax in this section’s evaluation because it doesn’t have an explicit outlier score. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When the proposed approach is used for open set recognition, the final prediction is a class label, which can be one of the $K$ known class labels if the test instances has an outlier score less than a threshold value or it can be an “unknown\" label if the instance has an outlier score greater than the threshold, Eq. 3. In addition to the three approaches evaluated in the previous section, we also include Openmax Bendale & Boult (2016) and G-Openmax Ge et al. (2017) in these evaluations because they give final class label predictions. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            784
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use average F-score to evaluate open set recognition performance and t-test for statistical significance. Using the same experimental setup the earlier experiment, we report the result of the average f-score, averaged across all class labels and across 30 experiment runs in Table 2. On all three datasets the $i i$ and $i i + c e$ networks gives significantly better f-score compared to the other two configurations (with p-value of 0.0002 or less). In case of the Android dataset, all networks perform lower compared to the other two datasets. We attribute this to the small number of samples in the Android datasets. The dataset is also imbalanced with many classes only having less than 60 samples. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Two limitations of Openmax can explain its weaker performance compared to our proposed approaches: 1) it does not use a loss function that directly incentivizes projecting class instances around the mean class activation vector and 2) the distance function used by Openmax is not necessarily the right distance function for final activation vector space since it is not used in training. We addressed these limitations by training a neural network with a loss function that explicitly encourages properties P1 and P2. Also, we use the same distance function during training and test. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2b45326e66954ea640041c5efcc3e32e8427337726d4e890b76a0da28fa50d5.jpg",
+        "image_caption": [
+            "Figure 2: The z-layer projection of (a, b) known and (c, d) unknown class instances from test set of MNIST dataset. The labels 0,2,3,4,6,9 represent the known classes while the label “unknown\" represents the unknown classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            138,
+            103,
+            828,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            460,
+            825,
+            517
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 DISCUSSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            534,
+            310,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 provides evidence on how our network projects unknown class instances in the space between the known classes. In the figure the $\\mathbf { Z }$ -layer projection of 2000 random test instances of an open set dataset created from MNIST with 6 known and 4 unknown classes. The class labels 0, 2, 3, 4, 6, and 9 in the figure represent the 6 known classes while the “unknown\" label represents all the unknown classes. The network with ii-loss is set up to have a z-layer dimension of 6, and the figure shows a 2D plot of dimension (z0,z1), (z0,z2). The Openmax network also has a similar network architecture and last layer dimension of 6. In case of ii-loss based projection, the instances from the known classes (Figures 2a) are projected close to their respective class while the unknown class instances (Figures 2c) are projected, for the most part, in the region between the classes. In case of Openmax, Figures 2b and 2d, the unknown class instances do not fully occupy the open space between the known classes. In Openmax, most instances are projected along the axis; this is because of the one-hot encoding induced by cross-entropy loss. So compared to Openmax, ii-loss appears to better utilize space “among\" the classes. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/68e4758561fecd79ff15bc0e6f1f51b6593435334622f17ac3ec4d5db3b98486.jpg",
+        "image_caption": [
+            "Figure 3: Projections of Android dataset known class test instances from final activation layer of Openmax. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            756,
+            694,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fea0ce400d50c7fc9581892765c26c8ef8cb76d27c28d10a72d836e7d47d21f5.jpg",
+        "image_caption": [
+            "Figure 4: Projections of Android dataset (a) known class and (b) unknown class test instances from $\\mathbf { Z }$ -layer of a network trained with only cross entropy. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            103,
+            722,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6c55368f55b1ffbe3d37eaf6f46c2ab8e7589e6a763d2b0b10efdec3f97c2381.jpg",
+        "image_caption": [
+            "Figure 5: Inter class separation for networks trained (a) with batch normalization used in all layers and (b) without batch normalization at the $\\mathbf { Z }$ -layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            296,
+            687,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance of Openmax is especially low in case of the Android dataset because of low recall on known classes with small number training instances. The low recall was caused by test instances from the smaller classes being projected further away from the class’s mean activation vector (MAV). For example, in Figure 3a we see that test instances of class 2 are further away from the MAV of class 2 (marked by $\\because \\overrightarrow { \\mathbf { \\nabla } } \\star \\overrightarrow { \\mathbf { \\nabla } }$ ). As a result, these test instances are predicted as unknown. Similarly, in Figure 3b instances of class 3 are far away from the MAV of class 3(marked by ’X’). Performance of network trained with only cross entropy (ce) is also low for Android dataset because unknown class instances were projected close to the known classes (Figure 4). As a result, these instances get labeled as known classes. In turn, resulting in a lower precision score for the known classes. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            604
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we have observed batch normalization Ioffe & Szegedy (2015) to be extremely important when using ii-loss. Because batch normalization fixes the mean and variance of a layer, it bounds the output of our $\\mathbf { Z }$ -layer in a certain hypercube, in turn preventing the inter_separation term in ii-loss from increasing indefinitely. This is evident in Figures 5a and 5b. Figure 5a shows the inter_separation of the network where batch normalization used in all layers including the z-layer; here, the inter_separation increases in the beginning but levels off. Whereas when batch normalization is not used in the $\\mathbf { Z }$ -layer the inter_separation term keeps on increasing as seen in Figure 5b; as a result, ii-loss would not converge. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Autoencoders can also be considered as another way to learn a representation. However, autoencoders do not try to achieve properties P1 and P2. One of the reasons is autoencoder training is unsupervised. Another reason is that non-regularized autoencoders fracture the manifold into different domains resulting in the representation of instances from the same class being further apart Makhzani et al. (2015). Therefore, in the learned representation, the known classes are not well separated. Additionally, outliers get projected to roughly the same area as the known classes. A figure in Appendix C shows the output of an encoder in an autoencoder. ",
+        "bbox": [
+            174,
+            729,
+            826,
+            827
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            848,
+            318,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We presented an approach for learning a neural network based representation that projects instances of the same class closer together while projecting instances of the different classes further apart. Our empirical evaluation shows that the two properties lead to larger spaces among classes for instances of unknown classes to occupy, hence facilitating open set recognition. We compared our proposed approach with a baseline network trained to minimize a cross entropy loss and with Openmax (a state-of-art neural network based open set recognition approach). We evaluated the approaches on datasets of malware samples and images and observed that our proposed approach achieves statistically significant improvement. We proposed a simple threshold estimation technique in this paper. However, there is room to explore a more robust way to estimate the threshold. We leave this for future work. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            287,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Adagio. https://github.com/hgascon/adagio. ",
+        "bbox": [
+            176,
+            246,
+            460,
+            261
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Android malware genome project. http://www.malgenomeproject.org/. ",
+        "bbox": [
+            174,
+            270,
+            637,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mnist hand written digit dataset. http://yann.lecun.com/exdb/mnist/. ",
+        "bbox": [
+            173,
+            295,
+            620,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Microsoft malware classification challenge (big 2015). https://www.kaggle.com/c/malwareclassification, 2015. [Online; accessed 27-April-2015]. ",
+        "bbox": [
+            173,
+            318,
+            826,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abhijit Bendale and Terrance Boult. Towards open world recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1893–1902, 2015. ",
+        "bbox": [
+            174,
+            357,
+            821,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Abhijit Bendale and Terrance E Boult. Towards open set deep networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1563–1572, 2016. ",
+        "bbox": [
+            173,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Paul Bodesheim, Alexander Freytag, Erik Rodner, Michael Kemmler, and Joachim Denzler. Kernel null space methods for novelty detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3374–3381, 2013. ",
+        "bbox": [
+            173,
+            433,
+            826,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Paul Bodesheim, Alexander Freytag, Erik Rodner, and Joachim Denzler. Local novelty detection in multi-class recognition problems. In Applications of Computer Vision (WACV), 2015 IEEE Winter Conference on, pp. 813–820. IEEE, 2015. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            529
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Douglas O Cardoso, Felipe França, and João Gama. A bounded neural network for open set recognition. In Neural Networks (IJCNN), 2015 International Joint Conference on, pp. 1–7. IEEE, 2015. ",
+        "bbox": [
+            173,
+            536,
+            826,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Qing Da, Yang Yu, and Zhi-Hua Zhou. Learning with augmented class by exploiting unlabeled data. In Twenty-Eighth AAAI Conference on Artificial Intelligence, 2014. ",
+        "bbox": [
+            171,
+            589,
+            823,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas G. Dietterich. Steps toward robust artificial intelligence. AI Magazine, 38(3):3–24, 2017. ",
+        "bbox": [
+            173,
+            627,
+            813,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ZongYuan Ge, Sergey Demyanov, Zetao Chen, and Rahil Garnavi. Generative openmax for multiclass open set classification. arXiv preprint arXiv:1707.07418, 2017. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            681
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mehadi Hassen and Philip K. Chan. Scalable function call graph-based malware classification. In 7th Conference on Data and Application Security and Privacy, pp. 239–248. ACM, 2017. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            720
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            176,
+            728,
+            825,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lalit P Jain, Walter J Scheirer, and Terrance E Boult. Multi-Class Open Set Recognition Using Probability of Inclusion. pp. 393–409, 2014. ",
+        "bbox": [
+            171,
+            780,
+            825,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "K. Lee, H. Lee, K. Lee, and J. Shin. Training confidence-calibrated classifiers for detecting out-ofdistribution samples. In Proc. ICLR 2018, 2018. ",
+        "bbox": [
+            169,
+            819,
+            826,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015. ",
+        "bbox": [
+            173,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Enrique G Ortiz and Brian C Becker. Face recognition for web-scale datasets. Computer Vision and Image Understanding, 118:153–170, 2014. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Konrad Rieck, Philipp Trinius, Carsten Willems, and Thorsten Holz. Automatic analysis of malware behavior using machine learning. Journal of Computer Security, 19(4):639–668, 2011. ",
+        "bbox": [
+            173,
+            150,
+            823,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ethan Rudd, Andras Rozsa, Manuel Gunther, and Terrance Boult. A survey of stealth malware: Attacks, mitigation measures, and steps toward autonomous open world solutions. IEEE Communications Surveys & Tutorials, 2017. ",
+        "bbox": [
+            174,
+            196,
+            826,
+            239
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Walter J Scheirer, Anderson de Rezende Rocha, Archana Sapkota, and Terrance E Boult. Toward open set recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(7): 1757–1772, 2013. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. Yu, W. Qu, N. Li, and Z. Guo. Open-category classification by adversarial sample generation. In Proc. IJCAI 2017, pp. 3357–3363, 2017. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A EVALUATION NETWORK ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            560,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We evaluate 5 networks: ii, ce, $_ { \\mathrm { i i + c e } }$ , Openmax and G-Openmax. The first four networks and the final classifier of G-Openmax have the same architecture up to the fully connected $\\mathbf { Z }$ -layer. In case of the MNIST dataset, the input images are of size (28,28) and are padded to get an input layer size (32,32) with 1 channel. Following the input, layer are 2 non-linear convolutional layers with 32 and 64 units (filters) which have a kernel size of (4,4) with a (1,1) strides and SAME padding. The network also has max polling layers with a kernel size of (3,3), strides of (2,2), and SAME padding after each convolutional layer. Two fully connected non-linear layers with 256 and 128 units follow the second max pooling layer. Then a linear z-layer with a dimension of 6 follows the fully connected layers. In the case of $_ \\mathrm { i i + c e }$ and ce networks, the output of the $\\mathbf { Z }$ -layer is fed to an additional linear layer of dimension 6 which is then given to a softmax function. We use Relu activation function for all the non-linear layers. Batch normalization is used throughout all the layers. We also use Dropout with keep probability of 0.2 for the fully connected layers. Adam optimizer with a learning rate of 0.001, beta1 of 0.5, and beta2 of 0.999 is used to train our networks for 5000 iterations. In case of the Openmax network, the output of the $\\mathbf { Z }$ -layer is directly fed to a softmax layer. Similar to the Openmax paper we use a distance that is a weighted combination of normalized Euclidean and cosine distances. For the ce, ii, and $_ { \\mathrm { i i + c e } }$ we use contamination ratio of 0.01 for the threshold selection. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The open set experiments for MS Challenge dataset also used similar architectures as the four networks used for MNIST dataset with the following differences. The input layer size MS Challenge dataset is (67,67) with 1 channel after padding the original input of (63,63). Instead of the two fully connected non-linear layers, we use one fully connected layer with 256 units. We use dropout in the fully connected layer with keep probability of 0.9. Finally, the network was trained using Adam optimizer with 0.001 learning rate, 0.9 beta1, and 0.999 beta2. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We do not use a convolutional network for the Android dataset open set experiments. We use a network with one fully connected layer of 64 units. This is followed by a $\\mathbf { Z }$ -layer with a dimension of 6. For $_ \\mathrm { i i + c e }$ and ce networks we further add a linear layer with a dimension of 6 and the output of this layer is fed to a softmax layer. In case of Openmax, the output of the $\\mathbf { Z }$ -layer is directly fed to the softmax layer. For Openmax we use a distance that is a weighted combination of normalized Euclidean and cosine distances. We use Relu activation function for all the nonlinear layers. We used batch normalization for all layers. We also used Dropout with keep probability of 0.9 for the fully connected layers. We used Adam optimizer with a learning rate of 0.1 and first momentum of 0.9 to train our networks for 10000 iterations. For the ce, ii, and ii+ce we use contamination ratio of 0.01 for the threshold selection. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The closed set experiments use the same set up as the open set experiments with the only difference coming from the dimension of the z-layer. For the MNIST dataset, we used z dimension of 10. For the MS and Android datasets, we use z dimension of 9. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B CLOSED SET CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            460,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we would like to show that on a closed dataset, a network trained using ii-loss performs comparably to the same network trained using cross entropy loss. For closed set classification, all the classes in the dataset are used for both training and test. For MS and Android datasets, we randomly divide the datasets into training, validation, and test and report the results on the test set. The MNIST dataset is already divided into training, validation, and test. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "On closed MNIST dataset, a network trained with cross-entropy achieved a 10-run average classification accuracy of $9 9 . 4 2 \\%$ . The same network trained using ii-loss achieved an average accuracy of $9 9 . 3 1 \\%$ . The network trained only on cross-entropy gives better performance than the network trained on ii-loss. The results from a network trained both ii-loss cross entropy loss to achieve an average classification accuracy of $9 9 . 4 0 \\%$ . This result makes it comparable to the performance of the same network trained using cross-entropy only (with a p-value of 0.22). We acknowledge that both results are not state-of-art as we are using simple network architectures. The primary goal of these experiments is to show that the ii-loss trained network can give comparable results to a cross entropy trained network. On the Android dataset, the network trained on a cross entropy gets an average classification accuracy of $9 3 . 1 0 \\%$ while ii-loss records $9 2 . 6 8 \\%$ , but the difference is not significant (with a p-value at 0.43). ",
+        "bbox": [
+            173,
+            210,
+            825,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            382,
+            313,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/6bab02304b6eaeec5b486e0dd187d991c65cce0d65554b54371ecdd222f904fd.jpg",
+        "image_caption": [
+            "Figure 6: Projections of (a) known and (b) unknown class instances using the hidden layer of an Autoencoder. The labels 0,2,3,4,6,9 represent the known classes while the label “unknown\" represents the unknown classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            287,
+            421,
+            663,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We mentioned earlier that we used function call graph (FCG) feature for the malware dataset. We also mentioned that in case of the MS Challenge dataset we reformatted the FCG features proposed in Hassen & Chan (2017) to form a (63, 63) adjacency matrix representation of the graph. We feed this matrix as an input to the convolutional network with a (4,4) kernel. Such kernel shape makes sense when it comes to image input because in images proximity of pixels hold essential information. However, it is not apparent to us how nearby cells in a graph adjacency matrix hold meaning full information. We tried different kernel shapes, for example taking an entire row of the matrix at once (because a row of the matrix represents single nodes outgoing edge weights). However the simple (4,4) gives a better close set performance. ",
+        "bbox": [
+            173,
+            768,
+            825,
+            893
+        ],
+        "page_idx": 10
+    }
+]

parse/train/r1elIi09K7/r1elIi09K7_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/r1elIi09K7/r1elIi09K7_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rke_YiRct7/rke_YiRct7.md ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rke_YiRct7/rke_YiRct7_content_list.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rke_YiRct7/rke_YiRct7_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/rke_YiRct7/rke_YiRct7_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/ryeHuJBtPH/ryeHuJBtPH.md ADDED Viewed

	@@ -0,0 +1,353 @@

+# HYPER-SAGNN: A SELF-ATTENTION BASED GRAPH NEURAL NETWORK FOR HYPERGRAPHS
+Ruochi Zhang School of Computer Science Carnegie Mellon University
+Yuesong Zou School of Computer Science Carnegie Mellon University IIIS, Tsinghua University
+Jian Ma School of Computer Science Carnegie Mellon University jianma@cs.cmu.edu
+# ABSTRACT
+Graph representation learning for hypergraphs can be used to extract patterns among higher-order interactions that are critically important in many real world problems. Current approaches designed for hypergraphs, however, are unable to handle different types of hypergraphs and are typically not generic for various learning tasks. Indeed, models that can predict variable-sized heterogeneous hyperedges have not been available. Here we develop a new self-attention based graph neural network called Hyper-SAGNN applicable to homogeneous and heterogeneous hypergraphs with variable hyperedge sizes. We perform extensive evaluations on multiple datasets, including four benchmark network datasets and two single-cell Hi-C datasets in genomics. We demonstrate that Hyper-SAGNN significantly outperforms the state-of-the-art methods on traditional tasks while also achieving great performance on a new task called outsider identification. Hyper-SAGNN will be useful for graph representation learning to uncover complex higher-order interactions in different applications.
+# 1 INTRODUCTION
+Graph structure is a widely used representation for data with complex interactions. Learning on graphs has also been an active research area in machine learning on how to predict or discover patterns based on the graph structure (Hamilton et al., 2017b). Although existing methods can achieve strong performance in tasks such as link prediction and node classification, they are mostly designed for analyzing pair-wise interactions and thus are unable to effectively capture higher-order interactions in graphs. In many real-world applications, however, relationships among multiple instances are key to capturing critical properties, e.g., co-authorship involving more than two authors or relationships among multiple heterogeneous objects such as “(human, location, activity)”. Hypergraphs can be used to represent higher-order interactions (Zhou et al., 2007). To analyze higher-order interaction data, it is straightforward to expand each hyperedge into pair-wise edges with the assumption that the hyperedge is decomposable.
+Several previous methods were developed based on this notion (Sun et al., 2008; Feng et al., 2018). However, earlier work DHNE (Deep Hyper-Network Embedding) (Tu et al., 2018) suggested the existence of heterogeneous indecomposable hyperedges where relationships within an incomplete subset of a hyperedge do not exist. Although DHNE provides a potential solution by modeling the hyperedge directly without decomposing it, due to the neural network structure used in DHNE, the method is limited to the fixed type and fixed-size heterogeneous hyperedges and is unable to consider relationships among multiple types of instances with variable size. For example, Fig. 1 shows a heterogeneous co-authorship hypergraph with two types of nodes (corresponding author and coauthor). Due to the variable number of both authors and corresponding authors in a publication, the hyperedges (co-authorship) have different sizes or types. Unfortunately, methods for representation learning of heterogeneous hypergraph with variable-sized hyperedges, especially those that can predict variable-sized hyperedges, have not been developed.
+![](images/3d7185edb618596f7109f17a04f2b6c586a88751d39a1bcfc0f96085b26d4a91.jpg)
+Figure 1: An example of the coauthorship hypergraph. Here authors are represented as nodes (in dark blue and light blue) and coauthorships are represented as hyperedges.
+In this work, we developed a self-attention based graph neural network, called Hyper-SAGNN that can work with both homogeneous and heterogeneous hypergraphs with variable hyperedge size. Using the same datasets in the DHNE paper (Tu et al., 2018), we demonstrated the advantage of Hyper-SAGNN over DHNE in multiple tasks. We further tested the effectiveness of the method in predicting edges and hyperedges and showed that the model can achieve better performance from the multi-tasking setting. We also formulated a novel task called outsider identification and showed that Hyper-SAGNN performs strongly. Importantly, as an application of Hyper-SAGNN to singlecell genomics, we were able to learn the embeddings for the most recently produced single-cell Hi-C (scHi-C) datasets to uncover the clustering of cells based on their 3D genome structure (Ramani et al., 2017; Nagano et al., 2017). We showed that Hyper-SAGNN achieved improved results in identifying distinct cell populations as compared to existing scHi-C clustering methods. Taken together, Hyper-SAGNN can significantly outperform state-of-the-art methods and can be applied to a wide range of hypergraphs for different applications.
+# 2 RELATED WORK
+Deep learning based models have been developed recently to generalize from graphs to hypergraphs (Gui et al., 2016; Tu et al., 2018). The HyperEdge Based Embedding (HEBE) method (Gui et al., 2016) aims to learn the embeddings for each object in a specific heterogeneous event by representing it as a hyperedge. However, as demonstrated in Tu et al. (2018), HEBE does not perform well on sparse hypergraphs. Notably, previous methods typically decompose the hyperedge into pair-wise relationships where the decomposition methods can be divided into two categories: explicit and implicit. For instance, given a hyperedge $( v _ { 1 } , v _ { 2 } , v _ { 3 } )$ , the explicit approach would decompose it directly into three edges, $( v _ { 1 } , v _ { 2 } ) , ( v _ { 2 } , v _ { 3 } ) , ( v _ { 1 } , v _ { 3 } )$ , while the implicit approach would add a hidden node $e$ representing the hyperedge before decomposition, i.e., $( \bar { v } _ { 1 } , e ) , \bar { ( v } _ { 2 } , e ) , ( v _ { 3 } , e )$ . The deep hypergraph embedding (DHNE) model, however, directly models the tuple-wise relationship using MLP (Multilayer Perceptron). The method is able to achieve better performance on multiple tasks as compared to other methods designed for graphs or hypergraphs such as Deepwalk (Perozzi et al., 2014), node2vec (Grover & Leskovec, 2016), and HEBE. Unfortunately, the structure of MLP takes fixed-size input, making DHNE only capable of handling $k$ -uniform hypergraphs, i.e., hyperedges containing $k$ nodes. To use DHNE for non- $k$ -uniform hypergraphs or hypergraphs with different types of hyperedges, a function for each type of hyperedges needs to be trained individually, which leads to significant computational cost and loss of the capability to generalize to unseen types of hyperedges. Similarly, heterogeneous hyper-network embedding (Baytas et al., 2018) also used MLP as part of the model which requires fixed size input to train the model. Another recent method, hyper2vec (Huang et al., 2019), can also generate embeddings for nodes within the hypergraph and outperforms other hypergraph embedding methods such as HGE (Yu et al., 2018) in the node classification task. However, hyper2vec cannot solve the link prediction problem directly as it only generates the embeddings of nodes in an unsupervised manner without a learned function to map from embeddings of nodes to hyperedges. Also, for $k$ -uniform hypergraphs, hyper2vec is equivalent to node2vec, which cannot capture the high-order network structures for indecomposable hyperedges (as shown in Tu et al. (2018)). Moreover, graph neural network based methods (Yadati et al., 2018; Feng et al., 2019; Bai et al., 2019) have been proposed to generalize the convolution operation or attention mechanism from graphs to hypergraphs. However, these methods mainly focus on the hypergraphs where node attributes are known and are typically used for semi-supervised node classification tasks. Similar to hyper2vec, these methods cannot be directly used for predicting hyperedges. Our Hyper-SAGNN in this work addresses all these challenges with a self-attention based graph neural network that can learn embeddings of the nodes and predict hyperedges for non- $k$ -uniform heterogeneous hypergraphs.
+# 3 METHOD
+# 3.1 DEFINITIONS AND NOTATIONS
+Definition 1. (Hypergraph) A hypergraph is defined as $G = ( V , E )$ , where $V = \{ v _ { 1 } , . . . , v _ { n } \}$ represents the set of nodes in the graph, and $E = \{ e _ { i } = ( v _ { 1 } ^ { ( i ) } , . . . , v _ { k } ^ { ( i ) } ) \}$ represents the set of hyperedges. For any hyperedge $e$ , it can contain more than two nodes (i.e., $\bar { \delta } ( e ) \geq 2 )$ . If all hyperedges within a hypergraph have the same size of $k$ , it is called a $k$ -uniform hypergraph. Note that even if a hypergraph is $k$ -uniform, it can still have different types of hyperedges because the node type can vary for nodes within the hyperedges.
+Definition 2. (The hyperedge prediction problem) We formally define the hyperedge prediction problem. For a given tuple $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ , our goal is to learn a function $f$ that satisfies:
+$$
+f ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) = { \left\{ \begin{array} { l l } { \geq s , } & { { \mathrm { i f ~ } } ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \in E } \\ { < s , } & { { \mathrm { i f ~ } } ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \not \in E } \end{array} \right. }
+$$
+where $s$ is the threshold to binarize the continuous value of $f$ into a label, which indicates whether the tuple is an hyperedge or not. Specifically, when we are given the pre-trained embedding vectors or the features of nodes $X = \{ x _ { 1 } , . . . , x _ { i } \}$ , we can rewrite this function as:
+$$
+f ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \triangleq f ( g ( x _ { 1 } ) , g ( x _ { 2 } ) , . . . , g ( x _ { k } ) )
+$$
+where the vectors $g ( x _ { i } )$ can be considered as the fine-tuned embedding or embedding vectors for the nodes. For convenience, we refer to $x _ { i }$ as the features and $g ( x _ { i } )$ as the learned embeddings.
+# 3.2 STRUCTURE OF HYPER-SAGNN
+Our goal is to learn the functions $f$ and $g$ that take tuples of node features $( x _ { 1 } , . . . , x _ { k } )$ as input and produce the probability of these nodes forming a hyperedge. Without the assumption that the hypergraph is $k$ -uniform and the type of each hyperedge is identical, we require that $f$ can take variable-sized, non-ordered input. Although simple functions such as average pooling $\begin{array} { r } { f ( g ( x _ { 1 } ) , . . . , g ( x _ { k } ) ) = \frac { 1 } { K } \sum _ { i = 1 } ^ { k } g ( x _ { i } ) } \end{array}$ satisfy this tuple-wise condition, previous work showed that the linear function is not sufficient to model this relationship (Tu et al., 2018). DHNE used an MLP to model the non-linear function, but it requires that an individual function needs to be trained for different types of hyperedges. Here we propose a new method to tackle the general hyperedge prediction problem.
+Graph neural network based methods such as GraphSAGE (Hamilton et al., 2017a) typically define a unique computational graph for each node, allowing it to perform efficient information aggregation for nodes with different degrees. Graph Attention Network (GAT) (Velickovi ˇ c et al., 2017) utilizes ´ a self-attention mechanism in the information aggregation process. Motivated by these properties, we propose our method Hyper-SAGNN based on the self-attention mechanism within each tuple to learn the function $f$ .
+We first briefly introduce the selfattention mechanism. We use the same terms as the self-attention mechanism described in Vaswani et al. (2017); Velickovi ˇ c et al. (2017). Given a group ´ of nodes $\left( \vec { x } _ { 1 } , \vec { x } _ { 2 } , . . . , \vec { x } _ { k } \right)$ and weight matrices $W _ { Q } , W _ { K } , W _ { V }$ that represent linear transformations of features before applying the dot-product attention to be trained, we first compute the attention coefficients that reflect the pairwise importance of nodes:
+![](images/ef89afc7791475249e0d6dca699c8f8ba53f3028d25320bc26dae489763651e6.jpg)
+Figure 2: Structure of the neural network used in HyperSAGNN. The input $\left( \vec { x } _ { 1 } , \vec { x } _ { 2 } , . . . , \vec { x } _ { k } \right)$ , representing the features for nodes 1 to $k$ , passes through two branches of the network resulting in static embeddings $\left( \vec { s } _ { 1 } , \vec { s } _ { 2 } , . . . , \vec { s } _ { k } \right)$ and dynamic embeddings $( \vec { d } _ { 1 } , \vec { d } _ { 2 } , . . . , \vec { d } _ { k } )$ , respectively. The layer for generating dynamic embeddings is the multi-head attention layer. An example for its mechanism on node 1 here is shown in the figure as well. Then the pseudo-euclidean distance of each pair of static and dynamic embeddings is calculated by onelayered position-wise feed-forward network to produce probability scores $\left( p _ { 1 } , p _ { 2 } , . . . , p _ { k } \right)$ . These scores are further averaged to represent whether this group of nodes form a hyperedge.
+$$
+e _ { i j } = \left( W _ { Q } ^ { T } x _ { i } \right) ^ { T } \left( W _ { K } ^ { T } x _ { j } \right) , \forall 1 \leq i , j \leq k
+$$
+We then normalize $e _ { i j }$ by all possible $j$ within the tuple through the softmax function, i.e.,
+$$
+\alpha _ { i j } = \frac { \exp ( e _ { i j } ) } { \sum _ { 1 \leq l \leq k } \exp ( e _ { i l } ) }
+$$
+Finally, a weighted sum of the transformed features with an activation function is calculated:
+$$
+\vec { d } _ { i } = \operatorname { t a n h } \left( \sum _ { 1 \leq j \leq k , i \neq j } \alpha _ { i j } W _ { V } ^ { T } x _ { j } \right)
+$$
+In GAT, each node is applied to the self-attention mechanism usually with all its first-order neighbors. In Hyper-SAGNN, we aggregate the information for a node $v _ { i }$ only with its neighbors for a given tuple. The structure of Hyper-SAGNN is illustrated in Fig. 2.
+The input to our model can be represented as tuples, i.e., $\left( \vec { x } _ { 1 } , \vec { x } _ { 2 } , . . . , \vec { x } _ { k } \right)$ . Each tuple first passes through a position-wise feed-forward network to produce $\left( \vec { s } _ { 1 } , \vec { s } _ { 2 } , . . . , \vec { s } _ { k } \right)$ , where $\vec { s } _ { i } = \bar { \operatorname { t a n h } } ( \bar { W } _ { s } ^ { T } \vec { x } _ { i } )$ . We refer to each $\vec { s _ { i } }$ as the static embedding for node $i$ since it remains the same for node $i$ no matter what the given tuple is. The tuple also passes through a multi-head graph attention layer to produce a new set of node embedding vectors $( \dot { \vec { d } } _ { 1 } , \vec { d } _ { 2 } , . . . , \vec { d } _ { k } )$ , which we refer to as the dynamic embeddings because they are dependent on all the node features within this tuple.
+Note that unlike the standard attention mechanism described above, when calculating $\vec { d _ { i } }$ , we require that $j \neq i$ in Eqn. (5). In other words, we exclude the term $\alpha _ { i i } W _ { V } ^ { T } x _ { i }$ in the calculation of dynamic embeddings. Based on our results we found that including $\vec { \alpha } _ { i i }$ would lead to either similar or worse performance in terms of hyperedge prediction and node classification (see Appendix A.6 for details). We will elaborate on the motivation of this choice later in this section.
+With the static and dynamic embedding vectors for each node, we calculate the Hadamard power (element-wise power) of the difference of the corresponding static/dynamic pair. It is then further passed through a one-layered neural network with sigmoid as the activation function to produce a probability score $p _ { i }$ . Finally, all the output $p _ { i } \in [ 0 , 1 ]$ is averaged to get the final $p$ , i.e.,
+$$
+\begin{array} { l } { { \displaystyle o _ { i } = W _ { o } ^ { T } ( ( \vec { d } _ { i } - \vec { s } _ { i } ) ^ { \circ 2 } ) + b } } \\ { { \displaystyle p = \frac { 1 } { K } \sum _ { i = 1 } ^ { k } p _ { i } = \frac { 1 } { K } \sum _ { i = 1 } ^ { k } \sigma ( o _ { i } ) } } \end{array}
+$$
+By design, $o _ { i }$ can be regarded as the squared weighted pseudo-euclidean distance between the static embedding $\vec { s } _ { i }$ and the dynamic one $\vec { d } _ { i }$ . It is called pseudo-euclidean distance because we do not require the weight to be non-zero or to sum up to 1. One rationale for allowing negative weights when calculating the distance could be the Minkowski space where the distance is defined as $d ^ { 2 } = x ^ { 2 } + \stackrel { . } { y } ^ { 2 } + z ^ { 2 } - t ^ { 2 }$ . Therefore, for these high-dimensional embedding vectors, we do not specifically treat them as euclidean vectors.
+Our network essentially aims to build the correlation of the average “distance” of the static/dynamic embedding pairs with the probability of the node group forming a hyperedge. Since the dynamic embedding is the weighted sum of features (with potential non-linear transformation) from neighbors within the tuple, this “distance” reflects how well the static embedding of each node can be approximated by the features of their neighbors within that tuple. This design strategy shares some similarities with the CBOW model in natural language processing (Mikolov
+![](images/6a00ff2a4d42bad32d89a9c2c2151c1735c9865d97d2f01dfb33ed2874e0e494.jpg)
+Figure 3: Illustration of the method for generating node features for node $_ { i }$ in the hypergraph. In the walk based approach, a biased random walk on hypergraphs is used to produce walking paths (the yellow circles in the walking paths represent node i). These walks are further used to train a skip-gram model to generate features. In the encoder based approach, the $_ { i }$ -th row of the adjacency matrix (as shown in the figure where the orange/white blocks represent whether or not node $_ { i }$ is adjacent to other nodes in the graph) is used as the input to an autoencoder. The output of the encoder part is used as the features for node $_ { i }$ .
+et al., 2013), where the model aims to predict the target word given its context (see Appendix A.5 for the analysis of the static/dynamic embedding pairs). In principle, we could still include the $\vec { \alpha } _ { i i }$ term to obtain the embedding $\vec { d } _ { i } ^ { * }$ . Alternatively, we can directly pass $\vec { d } _ { i } ^ { * }$ through a fully connected layer to produce $p _ { i } ^ { * }$ while the rest remains the same. However, we argue that our proposed model would be able to produce $s _ { i }$ that can be directly used for tasks such as node classification while the alternative approach is unable to achieve that (see Appendix A.6 for detailed analysis).
+# 3.3 APPROACHES FOR GENERATING FEATURES
+In an inductive learning setting with known attributes for the nodes, $\vec { x } _ { i }$ can just be the attributes of the node. However, in a transductive learning setting without knowing the attributes of the nodes, we have to generate $\vec { x } _ { i }$ based on the graph structure solely. Here we use two existing strategies to generate features $\vec { x } _ { i }$ . As shown in Fig. 3, the first approach is the random walk based method. We designed a biased random walk scheme for nodes in hypergraphs and used that to sample walks. Then, similar to node2vec, a skip-gram model is trained to generate features. The second approach is the encoder based approach where the corresponding row of the adjacency matrix is used as the features. The features are further passed through an autoencoder-like structure to reduce the dimensionality with the output of the hidden layer used as the features. The detailed description of these two approaches can be found in Appendix A.1.
+# 4 RESULTS
+We sought to compare Hyper-SAGNN with the state-of-the-art method DHNE as it has already been demonstrated with superior performance over previous algorithms such as DeepWalk, LINE, and HEBE. We first used the same four datasets in the DHNE paper to have a direct comparison. The details on these datasets can be found in the Appendix A.2. The details on the parameters used in this section for both Hyper-SAGNN and other methods can also be found in the Appendix A.3. The details of the tasks and the evaluation metrics used in this section are explained in the Appendix A.4.
+# 4.1 PERFORMANCE COMPARISON WITH EXISTING METHODS
+We evaluated the effectiveness of our embedding vectors and the learned function with the network reconstruction task. We compared our Hyper-SAGNN using the encoder based approach and also the model using the random walk based pre-trained embeddings against DHNE and the baseline node2vec. We first trained the model and then used the learned embeddings to predict the hyperedges of the original network. We sampled the negative samples to be 5 times the amount of the positive samples following the same setup of DHNE. We evaluated the performance based on both the AUROC (Area Under the Receiver Operating Characteristic curve) and the AUPR (Area under the Precision-Recall curve). As shown in Table 1, Hyper-SAGNN can capture the network structure better than DHNE over all datasets either using the encoder based approach or the random walk based approach.
+Table 1: AUC and AUPR values for network reconstruction. The models trained with the random walk based approach and the encoder based approach are marked as Hyper-SAGNN-W and Hyper-SAGNN-E, respectively.
+<table><tr><td rowspan="2"></td><td colspan="2">GPS</td><td colspan="2">MOVIELENS</td><td colspan="2">DRUG</td><td colspan="2">WORDNET</td></tr><tr><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>node2vec-mean</td><td>0.572</td><td>0.188</td><td>0.557</td><td>0.197</td><td>0.668</td><td>0.246</td><td>0.613</td><td>0.215</td></tr><tr><td>node2vec-min</td><td>0.570</td><td>0.187</td><td>0.535</td><td>0.186</td><td>0.682</td><td>0.257</td><td>0.576</td><td>0.201</td></tr><tr><td>DHNE</td><td>0.959</td><td>0.836</td><td>0.974</td><td>0.878</td><td>0.952</td><td>0.873</td><td>0.989</td><td>0.953</td></tr><tr><td>Hyper-SAGNN-E</td><td>0.971</td><td>0.877</td><td>0.991</td><td>0.952</td><td>0.977</td><td>0.916</td><td>0.989</td><td>0.950</td></tr><tr><td>Hyper-SAGNN-W</td><td>0.976</td><td>0.857</td><td>0.998</td><td>0.986</td><td>0.988</td><td>0.945</td><td>0.994</td><td>0.956</td></tr></table>
+We further assessed the performance of Hyper-SAGNN on the hyperedge prediction task. We randomly split the hyperedge set into training and testing set by a ratio of 4:1. The way to generate negative samples is the same as the network reconstruction task. As shown in Table 2, our model again achieves significant improvement over DHNE for predicting the unseen hyperedges. The most significant improvement is from the wordnet dataset, which is about a $2 4 . 6 \%$ increase on the AUPR score. For network reconstruction and hyperedge prediction tasks, the difference between the random walk based Hyper-SAGNN and the encoder based Hyper-SAGNN is minor.
+In addition to the tasks related to the prediction of hyperedges, we also evaluated whether the learned embeddings are effective for node classification tasks. A multi-label classification experiment and a multi-class classification experiment were carried out for the MovieLens dataset and the wordnet dataset, respectively. We used Logistic Regression as the classifier. The proportion of the training data was chosen to be from $10 \%$ to $90 \%$ for the MovieLens dataset, and $1 \%$ to $10 \%$ for the wordnet dataset. We used averaged Mirco-F1 and Macro-F1 to evaluate the performance. The results are in Fig. 4. We observed that Hyper-SAGNN consistently achieves both higher Micro-F1 and Macro-F1 scores over DHNE for different fractions of the training data. Also, Hyper-SAGNN based on the random walk generally achieves the best performance (Hyper-SAGNN-W in Fig. 4).
+![](images/b81cc54be66315c169f54f95b8208888706edca91c358f6796546394ccdc348f.jpg)
+Figure 4: Performance of classification on MovieLens and wordnet datasets. Hyper-SAGNNs trained with the random walk based approach and the encoder based approach are marked as Hyper-SAGNN-W, HyperSAGNN-E, respectively. The models trained with a mix of edges and hyperedges are denoted with “(mix)”.
+# 4.2 PERFORMANCE ON NON- $k$ -UNIFORM HYPERGRAPH
+Next, we evaluated Hyper-SAGNN using the non- $k$ -uniform heterogeneous hypergraph. For the above four datasets, we decomposed each hyperedge into 3 pairwise edges and added them to the existing graph. We trained our model to predict both the hyperedges and the edges (i.e., nonhyperedges). We then evaluated the performance for link prediction tasks for both the hyperedges and the edges. We also performed the node classification task following the same setting as above. The results for link prediction are in Table 2. Fig. 4 shows the results for the node classification task.
+Table 2: Performance evaluation based on AUROC and AUPR for hyperedge/edge prediction. Methods with annotation (mix) represent Hyper-SAGNN trained with a mixture of edges and hyper-edges. Datasets marked with “(2)” represent the performance on pair-wise edge prediction (i.e., non-hyperedges).
+<table><tr><td rowspan="2"></td><td colspan="2">GPS</td><td colspan="2">MOVIELENS</td><td colspan="2">DRUG</td><td colspan="2">WORDNET</td></tr><tr><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>node2vec-mean</td><td>0.563</td><td>0.191</td><td>0.562</td><td>0.197</td><td>0.670</td><td>0.246</td><td>0.608</td><td>0.213</td></tr><tr><td>node2vec - min</td><td>0.570</td><td>0.185</td><td>0.539</td><td>0.186</td><td>0.684</td><td>0.258</td><td>0.575</td><td>0.200</td></tr><tr><td>DHNE</td><td>0.910</td><td>0.668</td><td>0.877</td><td>0.668</td><td>0.925</td><td>0.859</td><td>0.816</td><td>0.459</td></tr><tr><td>Hyper-SAGNN-E</td><td>0.952</td><td>0.798</td><td>0.926</td><td>0.793</td><td>0.961</td><td>0.895</td><td>0.890</td><td>0.705</td></tr><tr><td>Hyper-SAGNN-W</td><td>0.922</td><td>0.722</td><td>0.930</td><td>0.810</td><td>0.955</td><td>0.892</td><td>0.880</td><td>0.706</td></tr><tr><td>Hyper-SAGNN-E (mix)</td><td>0.950</td><td>0.795</td><td>0.928</td><td>0.799</td><td>0.956</td><td>0.887</td><td>0.881</td><td>0.694</td></tr><tr><td>Hyper-SAGNN-W (mix)</td><td>0.920</td><td>0.720</td><td>0.929</td><td>0.811</td><td>0.950</td><td>0.889</td><td>0.884</td><td>0.684</td></tr><tr><td></td><td colspan="2">GPS (2)</td><td></td><td>MOVIELENS (2)</td><td></td><td>DRUG (2)</td><td>WORDNET (2)</td><td></td></tr><tr><td></td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>Hyper-SAGNN-E (mix)</td><td>0.921</td><td>0.899</td><td>0.971</td><td>0.967</td><td>0.981</td><td>0.973</td><td>0.891</td><td>0.897</td></tr><tr><td>Hyper-SAGNN-W (mix)</td><td>0.931</td><td>0.910</td><td>0.999</td><td>0.999</td><td>0.999</td><td>0.999</td><td>0.923</td><td>0.916</td></tr></table>
+We observed that Hyper-SAGNN can preserve the graph structure on different levels. Compared to training the model with hyperedges only, including the edges into the training would not cause obvious changes in performance for hyperedge predictions (about a $1 \%$ fluctuation for AUC/AUPR).
+We then further assessed the model in a new evaluation setting where there are adequate edges but only a few hyperedges presented. We asked whether the model can still achieve good performance on the hyperedge prediction based on this dataset. This scenario is possible in real-world applications especially when the dataset is combined from different sources. For example, in the drug dataset, it is possible that, in addition to the (user, drug, reaction) hyperedges, there are also extra edges that come from other sources, e.g., (drug, reaction) edges from the drug database, (user, drug) and (user, reaction) edges from the medical record. Here for each dataset that we tested, we used $50 \%$ of the edges and only $5 \%$ of the hyperedges to train the model. The results are in Fig. 5.
+When using only the edges to train the model, our method still achieves higher AUROC and AUPR score for hyperedge prediction as compared to node2vec (Table 2). We found that when the model is trained with both the downsampled hyperedge dataset and the edge dataset, it would be able to reach higher performance or suffer less from overfitting than being trained with each of the datasets individually. This demonstrates that our model can capture the consensus information on the graph structure across different sizes of hyperedges.
+![](images/fae418121b31e783d45f3c35949e2f20fea66c4b8d15ea3f051e738578a0dfd8.jpg)
+Figure 5: AUROC and AUPR scores of Hyper-SAGNN for hyperedge prediction on the downsampled dataset over training epochs.
+# 4.3 OUTSIDER IDENTIFICATION
+In addition to the standard link prediction and node classification, we further formulated a new task called “outsider identification”. Previous methods such as DHNE can answer the question of whether a specific tuple of nodes $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ form a hyperedge. However, in many settings, we might also want to know the reason why this group of nodes will not form a hyperedge. We first define the outsider of a group of nodes as follows. Node $v _ { i }$ is the outsider of the node group $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ if it satisfies:
+$$
+\begin{array} { l } { \exists e \in E , ( v _ { 1 } , v _ { 2 } , . . . , v _ { i - 1 } , v _ { i + 1 } , . . . , v _ { k } ) \in e } \\ { \exists e \in E , s . t . \exists j \in \{ 1 , 2 , . . , k \} , j \not = i , ( v _ { i } , v _ { j } ) \in e } \end{array}
+$$
+We speculated that Hyper-SAGNN can answer this question by analyzing the probability score $p _ { 1 }$ to $p _ { k }$ (defined in Eqn. 7). We assume that the node $v _ { i }$ with the smallest $p _ { i }$ would be the outsider. We then set the evaluation as follows. We first trained the model as usual, but at the final stage, we replaced the average pooling layer with the min pooling layer and fine-tuned the model for several epochs. We then fed the generated triplets with known outsider node into the trained model and calculated the top- $k$ accuracy of the outsider node matching the node with the smallest probability. Because this task is based on the prediction results of the hyperedges, we only tested on the dataset that achieves the best hyperedge prediction, i.e., the drug dataset. We found that we have $8 1 . 9 \%$ accuracy for the smallest probability and $9 5 . 3 \%$ accuracy for the top-2 smallest probability. These results show that by switching the pooling layer we would have better outsider identification accuracy (from $78 . 5 \%$ to $8 1 . 9 \%$ ) with the cost of slightly decreased hyperedge prediction performance (AUC from 0.955 to 0.935). This demonstrates that our model is able to accurately predict the outsider within the group even without further labeled information. Moreover, the performance of outsider identification can be further improved if we include the cross-entropy between $p _ { i }$ and the label of whether $v _ { i }$ is an outsider for all applicable triplets in the loss term. Together, these results show the advantage of Hyper-SAGNN in terms of the interpretability of hyperedge prediction.
+# 4.4 APPLICATION TO SINGLE-CELL HI-C DATASETS
+We next applied Hyper-SAGNN to the recently produced single-cell Hi-C (scHi-C) datasets (Ramani et al., 2017; Nagano et al., 2017). Genome-wide mapping of chromatin interactions by HiC (Lieberman-Aiden et al., 2009; Rao et al., 2014) has enabled comprehensive characterization of the 3D genome organization that reveals patterns of chromatin interactions between genomic loci. However, unlike bulk Hi-C data where signals are aggregated from cell populations, scHi-C provides unique information about chromatin interactions at single-cell resolution, thus allowing us to ascertain cell-to-cell variation of the 3D genome organization. Specifically, we propose that scHi-C makes it possible to model the cell-to-cell variation of chromatin interaction as a hyperedge, i.e., (cell, genomic locus, genomic locus). Note that the hyperedege here is “partially non-ordered”, namely (cell $i$ , locus $j$ , locus $k$ ) should be equivalent to (cell $i$ , locus $k$ , locus $j$ ). Our method is able to guarantee that while DHNE cannot achieve that directly. For the analysis of scHi-C, the most common strategy would be revealing the cell-to-cell variation by embedding the cells based on the contact matrix and then applying the clustering algorithms such as $K$ -means clustering on the embedded vectors. We performed the following evaluation to assess the effectiveness of HyperSAGNN on learning the embeddings of cells by representing the scHi-C data as hypergraphs.
+We tested Hyper-SAGNN on two datasets. The first one consists of scHi-C from four human cell lines: HAP1, GM12878, K562, and HeLa (Ramani et al., 2017). The second one includes the scHiC that represents the cell cycle of the mouse embryonic stem cells (Nagano et al., 2017). We refer to the first dataset as “Ramani et al. data”, and the second as “Nagano et al. data” for abbreviation. We trained Hyper-SAGNN with the corresponding datasets. Due to the large average degrees of cell nodes, the random walk approach would take an extensive amount of time to sample the walks. Thus, we only applied the encoder version of our method. We visualize the learned embeddings by reducing them to 2 dimensions with PCA and UMAP (McInnes et al., 2018) (Fig. 6A-D).
+We quantified the effectiveness of the embeddings by applying $K$ -means clustering on the Ramani et al. data and evaluating with Adjusted Rand Index (ARI). In addition, we also assessed the effectiveness of the embeddings with a supervised scenario. We used Logistic Regression as the classifier with $10 \%$ of the cell as training samples and evaluated the multi-class classification task with Micro-F1 and Macro-F1. We did not run $K$ -means clustering on the Nagano et al. data as it represents a state of continuous cell cycle which is not suitable for a clustering task. We instead used the metric ACROC (Average Circular ROC) developed in the HiCRep/MDS paper (Liu et al., 2018) to evaluate the performance of the three methods on the Nagano et al. data. We compared the performance with two recently developed computational methods based on dimensionality reduction of the contact matrix, HiC-Rep/MDS (Liu et al., 2018) and scHiCluster (Zhou et al., 2019). Because Hyper-SAGNN is not a deterministic method for generating embeddings for scHi-C, we repeated the training process 5 times and averaged the score. All these results are in Fig. 6E.
+![](images/e42575c08dd82a72351d9f23fffa4d7550e8993ed0dfe1a812f27b8b0b2ffd7f.jpg)
+Figure 6: (A) and (B): Visualization of the learned embedding based on Hyper-SAGNN for the Ramani et al. data. (C) and (D): Visualization of the learned embedding based on Hyper-SAGNN for the Nagano et al. data. Embedding vectors are projected to two dimensional space using either UMAP or PCA. (E): Quantitative evaluation of the Hyper-SAGNN on two scHi-C datasets
+For the Ramani et al. data (Fig. 6A-B), the visualization of the embedding vectors learned by HyperSAGNN exhibits clear patterns that cells with the same cell type are clustered together. Moreover, cell line HAP1, GM12878, and K562 are all blood-related cell lines, which are likely to be more similar to each other in terms of 3D genome organization as compared to HeLa. Indeed, we observed that they are also closer to each other in the embedding space. Quantitative results in Fig. 6E are consistent with the visualization as our method achieves the highest ARI, Micro-F1, MacroF1 score among all three methods. For the Nagano et al. data, as shown in Fig. 6C-D, we found that the embeddings exhibit a circular pattern that corresponds to the cell cycle. Also, both HiCRep/MDS and Hyper-SAGNN achieve high ACROC scores. All these results show the effectiveness of representing the scHi-C datasets as hypergraphs using Hyper-SAGNN, which has great potential to provide insights into the cell-to-cell variation of higher-order genome organization.
+# 5 CONCLUSION
+In this work, we developed a new graph neural network called Hyper-SAGNN for the representation learning of general hypergraphs. The model has the flexibility to deal with homogeneous and heterogeneous, and uniform and non-uniform hypergraphs. We demonstrated that Hyper-SAGNN can improve or match state-of-the-art performance for hypergraph representation learning while addressing the shortcomings of prior methods such as the inability to predict hyperedges for non- $k$ -uniform heterogeneous hypergraphs. Hyper-SAGNN is computationally efficient as the input size to the attention layer is bounded by the maximum hyperedge size as opposed to the number of neighbors.
+One potential improvement of Hyper-SAGNN as future work would be to allow information aggregation over all the first-order neighbors before calculating the static/dynamic embeddings for a node with the additional computational cost. With this design, the static embedding for a node would still satisfy our constraint that it is fixed for a known hypergraph with varying input tuples. This would allow us to incorporate previously developed methods on graphs, such as GraphSAGE (Hamilton et al., 2017a) and GCN (Kipf & Welling, 2016), as well as methods designed for hypergraphs like HyperGCN (Yadati et al., 2018) into this framework for better link prediction performance. Such improvement may also extend the application of Hyper-SAGNN to semi-supervised learning.
+# ACKNOWLEDGMENT
+J.M. acknowledges support from the National Institutes of Health Common Fund 4D Nucleome Program grant U54DK107965, National Institutes of Health grant R01HG007352, and National Science Foundation grant 1717205. Y.Z. (Yao Class, IIIS, Tsinghua University) contributed to this work as a visiting undergraduate student at Carnegie Mellon University during summer 2019.
+# REFERENCES
+Song Bai, Feihu Zhang, and Philip HS Torr. Hypergraph convolution and hypergraph attention. arXiv preprint arXiv:1901.08150, 2019.
+Inci M Baytas, Cao Xiao, Fei Wang, Anil K Jain, and Jiayu Zhou. Heterogeneous hyper-network embedding. In 2018 IEEE International Conference on Data Mining (ICDM), pp. 875–880. IEEE, 2018.
+Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In Advances in Neural Information Processing Systems 26, pp. 2787–2795. Curran Associates, Inc., 2013.
+Fuli Feng, Xiangnan He, Yiqun Liu, Liqiang Nie, and Tat-Seng Chua. Learning on partial-order hypergraphs. In Proceedings of the 2018 World Wide Web Conference, pp. 1523–1532. International World Wide Web Conferences Steering Committee, 2018.
+Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3558–3565, 2019.
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge Discovery and Data Mining, pp. 855–864. ACM, 2016.
+Huan Gui, Jialu Liu, Fangbo Tao, Meng Jiang, Brandon Norick, and Jiawei Han. Large-scale embedding learning in heterogeneous event data. In 2016 IEEE 16th International Conference on Data Mining (ICDM), pp. 907–912. IEEE, 2016.
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017a.
+William L Hamilton, Rex Ying, and Jure Leskovec. Representation learning on graphs: Methods and applications. arXiv preprint arXiv:1709.05584, 2017b.
+F. Maxwell Harper and Joseph A. Konstan. The movielens datasets: History and context. ACM Trans. Interact. Intell. Syst., 5(4):19:1–19:19, December 2015. ISSN 2160-6455.
+Jie Huang, Chuan Chen, Fanghua Ye, Jiajing Wu, Zibin Zheng, and Guohui Ling. Hyper2vec: Biased random walk for hyper-network embedding. In International Conference on Database Systems for Advanced Applications, pp. 273–277. Springer, 2019.
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+Erez Lieberman-Aiden, Nynke L Van Berkum, Louise Williams, Maxim Imakaev, Tobias Ragoczy, Agnes Telling, Ido Amit, Bryan R Lajoie, Peter J Sabo, Michael O Dorschner, et al. Comprehensive mapping of long-range interactions reveals folding principles of the human genome. Science, 326(5950):289–293, 2009.
+Jie Liu, Dejun Lin, Galip Gurkan Yardımcı, and William Stafford Noble. Unsupervised embedding ¨ of single-cell hi-c data. Bioinformatics, 34(13):i96–i104, 2018.
+Leland McInnes, John Healy, and James Melville. Umap: Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018.
+Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient Estimation of Word Representations in Vector Space. arXiv e-prints, art. arXiv:1301.3781, Jan 2013.
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 3111–3119. Curran Associates, Inc., 2013.
+Takashi Nagano, Yaniv Lubling, Csilla Varnai, Carmel Dudley, Wing Leung, Yael Baran, ´ Netta Mendelson Cohen, Steven Wingett, Peter Fraser, and Amos Tanay. Cell-cycle dynamics of chromosomal organization at single-cell resolution. Nature, 547(7661):61, 2017.
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge Discovery and Data Mining, pp. 701–710. ACM, 2014.
+Vijay Ramani, Xinxian Deng, Ruolan Qiu, Kevin L Gunderson, Frank J Steemers, Christine M Disteche, William S Noble, Zhijun Duan, and Jay Shendure. Massively multiplex single-cell hi-c. Nature Methods, 14(3):263, 2017.
+Suhas SP Rao, Miriam H Huntley, Neva C Durand, Elena K Stamenova, Ivan D Bochkov, James T Robinson, Adrian L Sanborn, Ido Machol, Arina D Omer, Eric S Lander, et al. A 3d map of the human genome at kilobase resolution reveals principles of chromatin looping. Cell, 159(7): 1665–1680, 2014.
+Liang Sun, Shuiwang Ji, and Jieping Ye. Hypergraph spectral learning for multi-label classification. In Proceedings of the 14th ACM SIGKDD international Conference on Knowledge Discovery and Data Mining, pp. 668–676. ACM, 2008.
+Ke Tu, Peng Cui, Xiao Wang, Fei Wang, and Wenwu Zhu. Structural deep embedding for hypernetworks. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.
+Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Anand Louis, and Partha Talukdar. Hypergcn: Hypergraph convolutional networks for semi-supervised classification. arXiv preprint arXiv:1809.02589, 2018.
+Chia-An Yu, Ching-Lun Tai, Tak-Shing Chan, and Yi-Hsuan Yang. Modeling multi-way relations with hypergraph embedding. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, pp. 1707–1710, 2018.
+Vincent W. Zheng, Bin Cao, Yu Zheng, Xing Xie, and Qiang Yang. Collaborative filtering meets mobile recommendation: A user-centered approach. In Proceedings of the Twenty-Fourth AAAI Conference on Artificial Intelligence, AAAI’10, pp. 236–241. AAAI Press, 2010.
+Dengyong Zhou, Jiayuan Huang, and Bernhard Scholkopf. Learning with hypergraphs: Clustering, ¨ classification, and embedding. In Advances in Neural Information Processing systems, pp. 1601– 1608, 2007.
+Jingtian Zhou, Jianzhu Ma, Yusi Chen, Chuankai Cheng, Bokan Bao, Jian Peng, Terrence J Sejnowski, Jesse R Dixon, and Joseph R Ecker. Robust single-cell hi-c clustering by convolutionand random-walk–based imputation. Proceedings of the National Academy of Sciences, pp. 201901423, 2019.
+# A APPENDIX
+# A.1 DETAILS OF THE STRATEGIES FOR GENERATING FEATURE VECTORS
+We first define the functions used in the subsequent sections as follows: a hyperedge $e$ with weight $w ( e )$ is incident with a vertex $v$ if and only if $v \in e$ . We denote the indicator function that represents the incident relationship between $v$ and $e$ by $h ( v , e )$ , which equals 1 when $e$ is incident with $v$ . The degree of vertex and the size of hyperedge are defined as:
+$$
+\begin{array} { l } { { d ( v ) \triangleq \displaystyle \sum _ { e \in E } h ( v , e ) w ( e ) } } \\ { { \delta ( e ) \triangleq \displaystyle \sum _ { v \in V } h ( v , e ) = | e | } } \end{array}
+$$
+# A.1.1 ENCODER BASED APPROACH
+As shown on the right side of Fig. 3, the first method to generate features is referred to as the encoder based approach, which is similar to the structure used in DHNE (Tu et al., 2018). We first obtain the incident matrix of the hypergraph $H \in \mathbb { R } ^ { | V | \times | E | }$ with entries $h ( v , e ) = 1$ if $v \in e$ and 0 otherwise. We also calculate the diagonal degree matrix $D _ { v }$ containing the vertex degree $\begin{array} { r } { d ( v ) = \sum _ { e \in E } h ( v , e ) } \end{array}$ . We thus have the adjacency matrix $A = H H ^ { T } - D _ { v }$ , of which the entries $a ( v _ { i } , v _ { j } )$ denote the concurrent times between each pair of nodes $( v _ { i } , v _ { j } )$ . The $i$ -th row of $A$ , denoted by $\vec { a } _ { i }$ , shows the neighborhood structures of the node $v _ { i }$ , which then passes through a one-layer neural network to produce $\vec { x } _ { i }$ :
+$$
+\vec { x } _ { i } = \operatorname { t a n h } \left( W _ { \mathrm { e n c } } \cdot \vec { a } _ { i } + \vec { b } _ { \mathrm { e n c } } \right)
+$$
+In DHNE, a symmetric structure was introduced where there are corresponding decoders to transform the $\vec { x } _ { i }$ back to $\vec { a } _ { i }$ . Tu et al. (2018) remarked that including this reconstruction error term would help DHNE to learn the graph structure better. We also include the reconstruction error term into the loss function, but with tied-weights between encoder and decoder to reduce the number of parameters that need to be trained.
+# A.1.2 RANDOM WALK BASED APPROACH
+Besides the encoder based approach, we also utilize a random walk based framework to generate the feature vectors $\vec { x } _ { i }$ (shown on the left side of Fig. 3). We extend the biased 2nd-order random walks proposed in node2vec (Grover & Leskovec, 2016) to generalize to hypergraphs. For a walk from $v$ to $x$ then to $t$ , the strategies are described as follows.
+The 1st-order random walk strategy given the current vertex $x$ is to randomly select a hyperedge $e$ incident with $x$ based on the weight of $e$ and then to choose the next vertex $y$ from $e$ uniformly (Zhou et al., 2007). Therefore, the 1st-order transition probability is defined as:
+$$
+\pi _ { 1 } ( t | x ) \triangleq \sum _ { e \in E } w ( e ) { \frac { h ( t , e ) h ( x , e ) } { \delta ( e ) } }
+$$
+We then generalize the 2nd-order bias $\alpha _ { p q }$ from ordinary graph to hypergraph for a walk from $v$ to $x$ to $t$ as:
+$$
+\alpha _ { p , q } ( t , v ) = { \left\{ \begin{array} { l l } { 1 / p , } & { { \mathrm { i f ~ } } \exists e \in E { \mathrm { , ~ s . t . ~ } } t , v , x \in e } \\ { 1 { \mathrm { , ~ } } } & { { \mathrm { e l s e ~ i f ~ } } \exists e \in E { \mathrm { , ~ s . t . ~ } } t , x \in e } \\ { 1 / q , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+where the parameters $p$ and $q$ are to control the tendencies that encourage outward exploration and obtain a local view.
+Next we add the above terms to set the biased 2nd-order transition probability as:
+$$
+\pi ( t | v , x ) = { \left\{ \begin{array} { l l } { { \frac { \pi _ { 1 } ( t | x ) \cdot \alpha _ { p q } ( t , v ) } { Z } } , } & { { \mathrm { i f ~ } } \exists e \in E { \mathrm { , ~ s . t . ~ } } v , x \in e } \\ { 0 , } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+where $Z$ is a normalizing factor.
+With the well-defined 2nd-order transition probability $\pi ( t | v , x )$ , we simulate a random walk of fixed length $l$ through a 2nd-order Markov process marked by $\begin{array} { r } { \dot { P } ( c _ { i } = t | c _ { i - 1 } = x , c _ { i - 2 } = v ) = \pi ( t | v , x ) } \end{array}$ , where $c _ { i }$ is the $i$ -th node in the walk. A Skip-gram model (Mikolov et al., 2013; Mikolov et al., 2013) is then used to extract the node features from sampled walks such that the nodes that appear in similar contexts would have similar embeddings.
+# A.2 DETAILS OF THE DATASETS USED IN THIS WORK
+The four datasets used in the first part of our evaluation are:
+• GPS (Zheng et al., 2010): GPS network. The hyperedges are based on (user, location, activity) relations.
+• MovieLens (Harper & Konstan, 2015): Social network. The hyperedges are based on (user, movie, tag) relations, describing peoples’ tagging activities.
+• drug: Medicine network from FAERS1. The hyperedges are based on (user, drug, reaction) relations.
+• wordnet (Bordes et al., 2013): Semantic network from WordNet 3.0. The hyperedges are based on (head entity, relation, tail entity), expressing the relationships between words.
+Details of the datasets are shown in Table A1.
+Table A1: Datasets used in this work. Note that the columns under $\ddot { \# } ( \mathrm { V } ) \dot { \cdot }$ ” correspond to the columns under “node type” for each dataset.
+<table><tr><td>DATASETS</td><td colspan="4">NODETYPE</td><td colspan="2">#(V)</td><td>#(E)</td></tr><tr><td>GPS</td><td>user</td><td>location</td><td>activity</td><td>146</td><td>70</td><td>5</td><td>1,436</td></tr><tr><td>MovieLens</td><td>user</td><td>movie</td><td>tag</td><td>2,113</td><td>5,908</td><td>9,079</td><td>47,957</td></tr><tr><td>drug</td><td>user</td><td>drug</td><td>reaction</td><td>12</td><td>1,076</td><td>6,398</td><td>171,756</td></tr><tr><td>wordnet</td><td>head</td><td>relation</td><td>tail</td><td>40,504</td><td>18</td><td>40,551</td><td>145,966</td></tr></table>
+# A.3 PARAMETER SETTING
+We downloaded the source code of DHNE from its GitHub repository. The structure of the neural network of DHNE was set to be the same as what the authors described in Tu et al. (2018). We tuned parameters such as the $\alpha$ term and the learning rate following the same procedure. We also tried adding dropout between representation vectors and the fully connected layer for better performance of DHNE. All these parameters were tuned until it was able to replicate or even improve the performance reported in the original paper. To make a fair comparison, for all the results below, we made sure that the training and validation data setups were the same across different methods.
+For node2vec, we decomposed the hypergraph into pairwise edges and ran node2vec on the decomposed graph. For the hyperedge prediction task, we first used the learned embedding to predict pairwise edges. We then used the mean or min of the pairwise similarity as the probability for the tuple to form a hyperedge. We set the window size to 10, walk length to 40, the number of walks per vertex to 10, which are the same parameters used in DHNE for node2vec. However, we found that for the baseline method node2vec, when we tuned the hyper-parameter $p , q$ and also used larger walk length, window size and walks per vertex (120, 20, 80 instead of 40, 10, 10), it would achieve comparable performance for node classification task as DHNE. This observation is consistent with our designed biased hypergraph random walk. But this would result in a longer time for sampling the walks and training the skip-gram model. We therefore kept the parameters consistent with what was used in DHNE paper.
+For our Hyper-SAGNN, we set the representation size to 64, which is the same as DHNE. The number of heads in the multi-head attention layer is set to 8. When using the encoder based approach to calculate $x _ { i }$ , we set the encoder structure to be the same as the encoder part in DHNE. When using the random walk based approach, we decomposed the hypergraph into a graph as described above. We set the window size to 10, walk length to 40, the number of walks per vertex to 10, to allow time-efficient generation of feature vector $\vec { x } _ { i }$ . The results in Section 4.1 showed that even when the pre-trained embeddings are not so ideal, Hyper-SAGNN can still well capture the structure of the graph.
+To train the model, we used the Adam optimizer with learning rate 1e-3. Each batch contains 96 positive hyperedges with 480 negative samples. The training is terminated when it reaches the maximum training epoch number (100) or the performance on the validation set no longer improves.
+# A.4 EXPERIMENT SETTING
+To compare the performance of Hyper-SAGNN with other baseline methods, we used the same three tasks in the DHNE paper, i.e., network reconstruction, link prediction, and node classification. In this section, we describe the setting of these three tasks and the evaluation metrics.
+Network reconstruction aims to reconstruct the input hypergraph from the learned embedding. Specifically, a hypergraph $G = ( V , E )$ is used as input to the algorithm. After training, the model makes predictions for the original hyperedge set $E$ . Link prediction, on the other hand, aims to predict the unseen hyperedge set $E ^ { ' }$ based on the model trained with hypergraph $G = ( V , E )$ . These two tasks can be regarded as binary classification tasks and thus can be evaluated by metrics such as AUROC and AUPR. For both tasks, the negative samples are set to be 5 times the amount of the positive samples following the same setup of DHNE.
+For the node classification, after training the model, the embeddings for the nodes are used to train a Logistic Regression classifier with targets as the pre-defined labels for the nodes. Here we have a multi-label classification and a multi-class classification task for dataset MovieLens and wordnet, respectively, making the metrics defined for binary classification not applicable. Therefore, the performances are evaluated by Micro and Macro F1 scores that are used for quantifying the performance of multi-label/multi-class classification.
+# A.5 ANALYSIS OF THE DYNAMIC EMBEDDINGS
+In this section, we discuss the relationships between dynamic embeddings and static embeddings. As mentioned in the Method section, we design the model to establish the connection between the probability score for a tuple with how well the static embedding of each node can be approximated by the features of their neighbor within that tuple. If the model works as we designed, the dynamic embedding of node $i$ conditioned on an actual hyperedge $( i , j , . . . , k )$ should approximate the static embedding of node $i$ better. In contrast, the dynamic embedding of node $i$ when it is a member of a non-hyperedge tuple would not have a good “approximation”. To evaluate this, after training the model we collected all the dynamic embeddings for nodes when they are within the tuples of positive samples, which would be referred to as positive dynamic embeddings. We also collected the dynamic embeddings for nodes when conditioned on the “hard negative samples” (the negative samples that are generated by only changing one node in the positive samples), which would be referred to as negative dynamic embeddings. We tested whether the positive dynamic embeddings indeed resemble the static embeddings better by comparing the performance of node classification using dynamic embeddings and static embeddings. For each node, since the number of positive and negative dynamic embeddings is not finite, we sampled and averaged a number of them as the features. The remaining setting of node classification is the same as described in the main text. As shown in Fig. A1, in general, the positive dynamic embeddings can achieve much better performance as compared to the negative dynamic embeddings. Both the micro and macro F1 scores increase when more positive dynamic embeddings are sampled and averaged. When averaging all positive dynamic embeddings and using those as features, the node classification performance is close to what we achieved using static embeddings. This analysis demonstrates that the positive dynamic embeddings “approximate” the static embeddings as they contain sufficient information for accurate node classification. In addition, for the negative dynamic embeddings where only one node is changed when generating negative samples, it performs dramatically worse. Note that we exclude the $\alpha _ { i i }$ term in the calculation of dynamic embeddings, which makes the dynamic embedding for node $i$ the combination of features of its neighbor within a given tuple. These results demonstrate that the probability scores for each node indicate the “distances” of static/dynamic embedding pairs that reflect how well the static embedding of each node can be approximated by the features of their neighbor within that tuple.
+![](images/cb460ae70ceeb9a325f12172826863dd0024c467475db80935c30b53d25ef7e7.jpg)
+Figure A1: Node classification performance comparison for static embeddings and dynamic embeddings. The results based on static embeddings are marked as “static”. Results based on positive/negative dynamic embeddings are marked as “dynamic P/dynamic $\mathbf { N } ^ { \ast }$ . The numbers of dynamic embeddings sampled during this process are also included in the legend.
+# A.6 COMPARISON OF HYPER-SAGNN VS. THE VARIANTS
+As mentioned above, unlike the standard GAT model, we exclude the $\alpha _ { i i }$ term in the self-attention mechanism. To test whether this constraint would improve or reduce the model’s ability to learn, we implemented a variant of our model (referred to as variant type I) by including this term. Also, as mentioned in the Method section, another potential variant of our model would be directly using the $\vec { d } _ { i } ^ { * }$ to calculate the probability score $p _ { i } ^ { * }$ . We refer to this variant as variant type II. For variant type II, on node classification task, since it does not have a static embedding, we used $W _ { v } ^ { T } x _ { i }$ . The rest of the parameters and structure of the neural network remain the same.
+We then compared the performance of Hyper-SAGNN and two variants in terms of AUC and AUPR values for network reconstruction task and hyperedge link prediction task on the following four datasets: MovieLens, wordnet, drug, and GPS. We also compared the performance in terms of the Micro F1 score and Macro F1 score on the node classification task on the MovieLens and the wordnet dataset. For the MovieLens dataset, we used $90 \%$ nodes as training data while for wordnet, we used $1 \%$ of the nodes as training data. All the evaluation setup is the same as described in the main text. To avoid the effect of randomness from the neural network training, we repeated the training process for each experiment five times and made the line plot of the score versus the epoch number. To illustrate the differences more clearly, we started the plot at epoch 3 for the random walk based approach and epoch 12 for the encoder based approach. The performance of the model using the random walk based approach is shown in Fig. A2 to Fig. A5. The performance of the model using the encoder based approach is shown in Fig. A6 to Fig. A9.
+For models with the random walk based approach, Hyper-SAGNN is the best in terms of all metrics for the GPS, MovieLens, and wordnet dataset. On the drug dataset, Hyper-SAGNN achieves higher AUROC and AUPR score on the network reconstruction task than two variants, but slightly lower AUROC score for the link prediction task (less than $0 . 5 \%$ ).
+For models with the encoder based approach, the advantage is not that obvious. All 3 methods achieve similar performance in terms of all metrics for the GPS and the drug dataset. For the MovieLens and wordnet dataset, Hyper-SAGNN performs similar to variant type I, higher than variant type II on the network reconstruction and link prediction task. However, our model achieves slightly higher accuracy on the node classification task than variant type I.
+Therefore, these evaluations show that the choice of the structure of Hyper-SAGNN can achieve higher or at least comparable performance than the two potential variants over multiple tasks on multiple datasets.
+![](images/51e83ee47bb78e57d5d07a62922e2371e76bac3c9f5ba046f817cf40e271982a.jpg)
+Figure A2: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (GPS)
+![](images/9382330a834f8f978055a6ca4455646e2ac520152c58fcd1285082668294877f.jpg)
+Figure A3: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (MovieLens)
+![](images/593260bbf4d269b2e743f2b2302db1123091baf47f951389eea7223f51914fae.jpg)
+Figure A4: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (drug)
+![](images/77dbd2b072ced8c9d0eca0cc205863e3f7958ec022875ec18fed5eec74415cc9.jpg)
+Figure A5: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (wordnet)
+![](images/62c4b08ae880e11812964c3db4cab98703489e417dbe87bf91139b323a320f57.jpg)
+Figure A6: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (GPS)
+![](images/047d6767bbdd4d374629324ce84b71ce57ca325ee96f6fa2721e2ec1fe9f8a5b.jpg)
+Figure A7: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (MovieLens)
+![](images/73e154b86af5c356ef1314dc08e6b0cc394cc96efddeb08bc2aecbb52121848f.jpg)
+Figure A8: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (drug)
+![](images/cd304b130b7f2610d04d5b246f96dab66458b07093fbaf55601a91075e353667.jpg)
+Figure A9: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (wordnet)

parse/train/ryeHuJBtPH/ryeHuJBtPH_content_list.json ADDED Viewed

	@@ -0,0 +1,1875 @@

+[
+    {
+        "type": "text",
+        "text": "HYPER-SAGNN: A SELF-ATTENTION BASED GRAPH NEURAL NETWORK FOR HYPERGRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ruochi Zhang School of Computer Science Carnegie Mellon University ",
+        "bbox": [
+            183,
+            170,
+            372,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuesong Zou School of Computer Science Carnegie Mellon University IIIS, Tsinghua University ",
+        "bbox": [
+            398,
+            170,
+            589,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jian Ma School of Computer Science Carnegie Mellon University jianma@cs.cmu.edu ",
+        "bbox": [
+            614,
+            171,
+            805,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph representation learning for hypergraphs can be used to extract patterns among higher-order interactions that are critically important in many real world problems. Current approaches designed for hypergraphs, however, are unable to handle different types of hypergraphs and are typically not generic for various learning tasks. Indeed, models that can predict variable-sized heterogeneous hyperedges have not been available. Here we develop a new self-attention based graph neural network called Hyper-SAGNN applicable to homogeneous and heterogeneous hypergraphs with variable hyperedge sizes. We perform extensive evaluations on multiple datasets, including four benchmark network datasets and two single-cell Hi-C datasets in genomics. We demonstrate that Hyper-SAGNN significantly outperforms the state-of-the-art methods on traditional tasks while also achieving great performance on a new task called outsider identification. Hyper-SAGNN will be useful for graph representation learning to uncover complex higher-order interactions in different applications. ",
+        "bbox": [
+            233,
+            295,
+            764,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph structure is a widely used representation for data with complex interactions. Learning on graphs has also been an active research area in machine learning on how to predict or discover patterns based on the graph structure (Hamilton et al., 2017b). Although existing methods can achieve strong performance in tasks such as link prediction and node classification, they are mostly designed for analyzing pair-wise interactions and thus are unable to effectively capture higher-order interactions in graphs. In many real-world applications, however, relationships among multiple instances are key to capturing critical properties, e.g., co-authorship involving more than two authors or relationships among multiple heterogeneous objects such as “(human, location, activity)”. Hypergraphs can be used to represent higher-order interactions (Zhou et al., 2007). To analyze higher-order interaction data, it is straightforward to expand each hyperedge into pair-wise edges with the assumption that the hyperedge is decomposable. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            689
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Several previous methods were developed based on this notion (Sun et al., 2008; Feng et al., 2018). However, earlier work DHNE (Deep Hyper-Network Embedding) (Tu et al., 2018) suggested the existence of heterogeneous indecomposable hyperedges where relationships within an incomplete subset of a hyperedge do not exist. Although DHNE provides a potential solution by modeling the hyperedge directly without decomposing it, due to the neural network structure used in DHNE, the method is limited to the fixed type and fixed-size heterogeneous hyperedges and is unable to consider relationships among multiple types of instances with variable size. For example, Fig. 1 shows a heterogeneous co-authorship hypergraph with two types of nodes (corresponding author and coauthor). Due to the variable number of both authors and corresponding authors in a publication, the hyperedges (co-authorship) have different sizes or types. Unfortunately, methods for representation learning of heterogeneous hypergraph with variable-sized hyperedges, especially those that can predict variable-sized hyperedges, have not been developed. ",
+        "bbox": [
+            174,
+            689,
+            562,
+            868
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d7185edb618596f7109f17a04f2b6c586a88751d39a1bcfc0f96085b26d4a91.jpg",
+        "image_caption": [
+            "Figure 1: An example of the coauthorship hypergraph. Here authors are represented as nodes (in dark blue and light blue) and coauthorships are represented as hyperedges. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            578,
+            699,
+            821,
+            773
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we developed a self-attention based graph neural network, called Hyper-SAGNN that can work with both homogeneous and heterogeneous hypergraphs with variable hyperedge size. Using the same datasets in the DHNE paper (Tu et al., 2018), we demonstrated the advantage of Hyper-SAGNN over DHNE in multiple tasks. We further tested the effectiveness of the method in predicting edges and hyperedges and showed that the model can achieve better performance from the multi-tasking setting. We also formulated a novel task called outsider identification and showed that Hyper-SAGNN performs strongly. Importantly, as an application of Hyper-SAGNN to singlecell genomics, we were able to learn the embeddings for the most recently produced single-cell Hi-C (scHi-C) datasets to uncover the clustering of cells based on their 3D genome structure (Ramani et al., 2017; Nagano et al., 2017). We showed that Hyper-SAGNN achieved improved results in identifying distinct cell populations as compared to existing scHi-C clustering methods. Taken together, Hyper-SAGNN can significantly outperform state-of-the-art methods and can be applied to a wide range of hypergraphs for different applications. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            299,
+            344,
+            315
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning based models have been developed recently to generalize from graphs to hypergraphs (Gui et al., 2016; Tu et al., 2018). The HyperEdge Based Embedding (HEBE) method (Gui et al., 2016) aims to learn the embeddings for each object in a specific heterogeneous event by representing it as a hyperedge. However, as demonstrated in Tu et al. (2018), HEBE does not perform well on sparse hypergraphs. Notably, previous methods typically decompose the hyperedge into pair-wise relationships where the decomposition methods can be divided into two categories: explicit and implicit. For instance, given a hyperedge $( v _ { 1 } , v _ { 2 } , v _ { 3 } )$ , the explicit approach would decompose it directly into three edges, $( v _ { 1 } , v _ { 2 } ) , ( v _ { 2 } , v _ { 3 } ) , ( v _ { 1 } , v _ { 3 } )$ , while the implicit approach would add a hidden node $e$ representing the hyperedge before decomposition, i.e., $( \\bar { v } _ { 1 } , e ) , \\bar { ( v } _ { 2 } , e ) , ( v _ { 3 } , e )$ . The deep hypergraph embedding (DHNE) model, however, directly models the tuple-wise relationship using MLP (Multilayer Perceptron). The method is able to achieve better performance on multiple tasks as compared to other methods designed for graphs or hypergraphs such as Deepwalk (Perozzi et al., 2014), node2vec (Grover & Leskovec, 2016), and HEBE. Unfortunately, the structure of MLP takes fixed-size input, making DHNE only capable of handling $k$ -uniform hypergraphs, i.e., hyperedges containing $k$ nodes. To use DHNE for non- $k$ -uniform hypergraphs or hypergraphs with different types of hyperedges, a function for each type of hyperedges needs to be trained individually, which leads to significant computational cost and loss of the capability to generalize to unseen types of hyperedges. Similarly, heterogeneous hyper-network embedding (Baytas et al., 2018) also used MLP as part of the model which requires fixed size input to train the model. Another recent method, hyper2vec (Huang et al., 2019), can also generate embeddings for nodes within the hypergraph and outperforms other hypergraph embedding methods such as HGE (Yu et al., 2018) in the node classification task. However, hyper2vec cannot solve the link prediction problem directly as it only generates the embeddings of nodes in an unsupervised manner without a learned function to map from embeddings of nodes to hyperedges. Also, for $k$ -uniform hypergraphs, hyper2vec is equivalent to node2vec, which cannot capture the high-order network structures for indecomposable hyperedges (as shown in Tu et al. (2018)). Moreover, graph neural network based methods (Yadati et al., 2018; Feng et al., 2019; Bai et al., 2019) have been proposed to generalize the convolution operation or attention mechanism from graphs to hypergraphs. However, these methods mainly focus on the hypergraphs where node attributes are known and are typically used for semi-supervised node classification tasks. Similar to hyper2vec, these methods cannot be directly used for predicting hyperedges. Our Hyper-SAGNN in this work addresses all these challenges with a self-attention based graph neural network that can learn embeddings of the nodes and predict hyperedges for non- $k$ -uniform heterogeneous hypergraphs. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            282,
+            815
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 DEFINITIONS AND NOTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            825,
+            424,
+            840
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. (Hypergraph) A hypergraph is defined as $G = ( V , E )$ , where $V = \\{ v _ { 1 } , . . . , v _ { n } \\}$ represents the set of nodes in the graph, and $E = \\{ e _ { i } = ( v _ { 1 } ^ { ( i ) } , . . . , v _ { k } ^ { ( i ) } ) \\}$ represents the set of hyperedges. For any hyperedge $e$ , it can contain more than two nodes (i.e., $\\bar { \\delta } ( e ) \\geq 2 )$ . If all hyperedges within a hypergraph have the same size of $k$ , it is called a $k$ -uniform hypergraph. Note that even if a hypergraph is $k$ -uniform, it can still have different types of hyperedges because the node type can vary for nodes within the hyperedges. ",
+        "bbox": [
+            174,
+            848,
+            825,
+            909
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. (The hyperedge prediction problem) We formally define the hyperedge prediction problem. For a given tuple $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ , our goal is to learn a function $f$ that satisfies: ",
+        "bbox": [
+            173,
+            135,
+            823,
+            165
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b42a1f8ad6986dc1d48dfde75d88ff652057f57ef3f232bcd02bb2291f688d4.jpg",
+        "text": "$$\nf ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) = { \\left\\{ \\begin{array} { l l } { \\geq s , } & { { \\mathrm { i f ~ } } ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \\in E } \\\\ { < s , } & { { \\mathrm { i f ~ } } ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \\not \\in E } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            167,
+            665,
+            202
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s$ is the threshold to binarize the continuous value of $f$ into a label, which indicates whether the tuple is an hyperedge or not. Specifically, when we are given the pre-trained embedding vectors or the features of nodes $X = \\{ x _ { 1 } , . . . , x _ { i } \\}$ , we can rewrite this function as: ",
+        "bbox": [
+            173,
+            204,
+            825,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/50cf6293354b0a11e7737d8d9d32d69b30a1af8abe0a7f82d3726f22f811d68d.jpg",
+        "text": "$$\nf ( v _ { 1 } , v _ { 2 } , . . . , v _ { k } ) \\triangleq f ( g ( x _ { 1 } ) , g ( x _ { 2 } ) , . . . , g ( x _ { k } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            252,
+            650,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the vectors $g ( x _ { i } )$ can be considered as the fine-tuned embedding or embedding vectors for the nodes. For convenience, we refer to $x _ { i }$ as the features and $g ( x _ { i } )$ as the learned embeddings. ",
+        "bbox": [
+            173,
+            273,
+            826,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 STRUCTURE OF HYPER-SAGNN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            313,
+            441,
+            327
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to learn the functions $f$ and $g$ that take tuples of node features $( x _ { 1 } , . . . , x _ { k } )$ as input and produce the probability of these nodes forming a hyperedge. Without the assumption that the hypergraph is $k$ -uniform and the type of each hyperedge is identical, we require that $f$ can take variable-sized, non-ordered input. Although simple functions such as average pooling $\\begin{array} { r } { f ( g ( x _ { 1 } ) , . . . , g ( x _ { k } ) ) = \\frac { 1 } { K } \\sum _ { i = 1 } ^ { k } g ( x _ { i } ) } \\end{array}$ satisfy this tuple-wise condition, previous work showed that the linear function is not sufficient to model this relationship (Tu et al., 2018). DHNE used an MLP to model the non-linear function, but it requires that an individual function needs to be trained for different types of hyperedges. Here we propose a new method to tackle the general hyperedge prediction problem. ",
+        "bbox": [
+            173,
+            334,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph neural network based methods such as GraphSAGE (Hamilton et al., 2017a) typically define a unique computational graph for each node, allowing it to perform efficient information aggregation for nodes with different degrees. Graph Attention Network (GAT) (Velickovi ˇ c et al., 2017) utilizes ´ a self-attention mechanism in the information aggregation process. Motivated by these properties, we propose our method Hyper-SAGNN based on the self-attention mechanism within each tuple to learn the function $f$ . ",
+        "bbox": [
+            173,
+            469,
+            431,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first briefly introduce the selfattention mechanism. We use the same terms as the self-attention mechanism described in Vaswani et al. (2017); Velickovi ˇ c et al. (2017). Given a group ´ of nodes $\\left( \\vec { x } _ { 1 } , \\vec { x } _ { 2 } , . . . , \\vec { x } _ { k } \\right)$ and weight matrices $W _ { Q } , W _ { K } , W _ { V }$ that represent linear transformations of features before applying the dot-product attention to be trained, we first compute the attention coefficients that reflect the pairwise importance of nodes: ",
+        "bbox": [
+            174,
+            671,
+            431,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef89afc7791475249e0d6dca699c8f8ba53f3028d25320bc26dae489763651e6.jpg",
+        "image_caption": [
+            "Figure 2: Structure of the neural network used in HyperSAGNN. The input $\\left( \\vec { x } _ { 1 } , \\vec { x } _ { 2 } , . . . , \\vec { x } _ { k } \\right)$ , representing the features for nodes 1 to $k$ , passes through two branches of the network resulting in static embeddings $\\left( \\vec { s } _ { 1 } , \\vec { s } _ { 2 } , . . . , \\vec { s } _ { k } \\right)$ and dynamic embeddings $( \\vec { d } _ { 1 } , \\vec { d } _ { 2 } , . . . , \\vec { d } _ { k } )$ , respectively. The layer for generating dynamic embeddings is the multi-head attention layer. An example for its mechanism on node 1 here is shown in the figure as well. Then the pseudo-euclidean distance of each pair of static and dynamic embeddings is calculated by onelayered position-wise feed-forward network to produce probability scores $\\left( p _ { 1 } , p _ { 2 } , . . . , p _ { k } \\right)$ . These scores are further averaged to represent whether this group of nodes form a hyperedge. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            452,
+            463,
+            818,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f09afece060782fec5dcac77af521748d3972c4276606fb12bdebc6756f63bb0.jpg",
+        "text": "$$\ne _ { i j } = \\left( W _ { Q } ^ { T } x _ { i } \\right) ^ { T } \\left( W _ { K } ^ { T } x _ { j } \\right) , \\forall 1 \\leq i , j \\leq k\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            842,
+            637,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We then normalize $e _ { i j }$ by all possible $j$ within the tuple through the softmax function, i.e., ",
+        "bbox": [
+            174,
+            867,
+            766,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3441f85b635ba12e7fc8078dd8b1477c577ac6bb4cdb24a387ba39cc257423f.jpg",
+        "text": "$$\n\\alpha _ { i j } = \\frac { \\exp ( e _ { i j } ) } { \\sum _ { 1 \\leq l \\leq k } \\exp ( e _ { i l } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            886,
+            581,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, a weighted sum of the transformed features with an activation function is calculated: ",
+        "bbox": [
+            169,
+            103,
+            781,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f149f9a7601ef3df41c04ee6232a12f8e7dfd48a79e6b9c9aaa3856905365483.jpg",
+        "text": "$$\n\\vec { d } _ { i } = \\operatorname { t a n h } \\left( \\sum _ { 1 \\leq j \\leq k , i \\neq j } \\alpha _ { i j } W _ { V } ^ { T } x _ { j } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            125,
+            617,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In GAT, each node is applied to the self-attention mechanism usually with all its first-order neighbors. In Hyper-SAGNN, we aggregate the information for a node $v _ { i }$ only with its neighbors for a given tuple. The structure of Hyper-SAGNN is illustrated in Fig. 2. ",
+        "bbox": [
+            173,
+            188,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The input to our model can be represented as tuples, i.e., $\\left( \\vec { x } _ { 1 } , \\vec { x } _ { 2 } , . . . , \\vec { x } _ { k } \\right)$ . Each tuple first passes through a position-wise feed-forward network to produce $\\left( \\vec { s } _ { 1 } , \\vec { s } _ { 2 } , . . . , \\vec { s } _ { k } \\right)$ , where $\\vec { s } _ { i } = \\bar { \\operatorname { t a n h } } ( \\bar { W } _ { s } ^ { T } \\vec { x } _ { i } )$ . We refer to each $\\vec { s _ { i } }$ as the static embedding for node $i$ since it remains the same for node $i$ no matter what the given tuple is. The tuple also passes through a multi-head graph attention layer to produce a new set of node embedding vectors $( \\dot { \\vec { d } } _ { 1 } , \\vec { d } _ { 2 } , . . . , \\vec { d } _ { k } )$ , which we refer to as the dynamic embeddings because they are dependent on all the node features within this tuple. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that unlike the standard attention mechanism described above, when calculating $\\vec { d _ { i } }$ , we require that $j \\neq i$ in Eqn. (5). In other words, we exclude the term $\\alpha _ { i i } W _ { V } ^ { T } x _ { i }$ in the calculation of dynamic embeddings. Based on our results we found that including $\\vec { \\alpha } _ { i i }$ would lead to either similar or worse performance in terms of hyperedge prediction and node classification (see Appendix A.6 for details). We will elaborate on the motivation of this choice later in this section. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            401
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With the static and dynamic embedding vectors for each node, we calculate the Hadamard power (element-wise power) of the difference of the corresponding static/dynamic pair. It is then further passed through a one-layered neural network with sigmoid as the activation function to produce a probability score $p _ { i }$ . Finally, all the output $p _ { i } \\in [ 0 , 1 ]$ is averaged to get the final $p$ , i.e., ",
+        "bbox": [
+            174,
+            409,
+            825,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a08ccc9f33163ac8b441f927702bcff283f2a87c33a10f804cf92e824dd43d77.jpg",
+        "text": "$$\n\\begin{array} { l } { { \\displaystyle o _ { i } = W _ { o } ^ { T } ( ( \\vec { d } _ { i } - \\vec { s } _ { i } ) ^ { \\circ 2 } ) + b } } \\\\ { { \\displaystyle p = \\frac { 1 } { K } \\sum _ { i = 1 } ^ { k } p _ { i } = \\frac { 1 } { K } \\sum _ { i = 1 } ^ { k } \\sigma ( o _ { i } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            481,
+            436,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By design, $o _ { i }$ can be regarded as the squared weighted pseudo-euclidean distance between the static embedding $\\vec { s } _ { i }$ and the dynamic one $\\vec { d } _ { i }$ . It is called pseudo-euclidean distance because we do not require the weight to be non-zero or to sum up to 1. One rationale for allowing negative weights when calculating the distance could be the Minkowski space where the distance is defined as $d ^ { 2 } = x ^ { 2 } + \\stackrel { . } { y } ^ { 2 } + z ^ { 2 } - t ^ { 2 }$ . Therefore, for these high-dimensional embedding vectors, we do not specifically treat them as euclidean vectors. ",
+        "bbox": [
+            174,
+            554,
+            496,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our network essentially aims to build the correlation of the average “distance” of the static/dynamic embedding pairs with the probability of the node group forming a hyperedge. Since the dynamic embedding is the weighted sum of features (with potential non-linear transformation) from neighbors within the tuple, this “distance” reflects how well the static embedding of each node can be approximated by the features of their neighbors within that tuple. This design strategy shares some similarities with the CBOW model in natural language processing (Mikolov ",
+        "bbox": [
+            174,
+            729,
+            496,
+            896
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6a00ff2a4d42bad32d89a9c2c2151c1735c9865d97d2f01dfb33ed2874e0e494.jpg",
+        "image_caption": [
+            "Figure 3: Illustration of the method for generating node features for node $_ { i }$ in the hypergraph. In the walk based approach, a biased random walk on hypergraphs is used to produce walking paths (the yellow circles in the walking paths represent node i). These walks are further used to train a skip-gram model to generate features. In the encoder based approach, the $_ { i }$ -th row of the adjacency matrix (as shown in the figure where the orange/white blocks represent whether or not node $_ { i }$ is adjacent to other nodes in the graph) is used as the input to an autoencoder. The output of the encoder part is used as the features for node $_ { i }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            472,
+            816,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "et al., 2013), where the model aims to predict the target word given its context (see Appendix A.5 for the analysis of the static/dynamic embedding pairs). In principle, we could still include the $\\vec { \\alpha } _ { i i }$ term to obtain the embedding $\\vec { d } _ { i } ^ { * }$ . Alternatively, we can directly pass $\\vec { d } _ { i } ^ { * }$ through a fully connected layer to produce $p _ { i } ^ { * }$ while the rest remains the same. However, we argue that our proposed model would be able to produce $s _ { i }$ that can be directly used for tasks such as node classification while the alternative approach is unable to achieve that (see Appendix A.6 for detailed analysis). ",
+        "bbox": [
+            173,
+            896,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            102,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 APPROACHES FOR GENERATING FEATURES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            171,
+            509,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In an inductive learning setting with known attributes for the nodes, $\\vec { x } _ { i }$ can just be the attributes of the node. However, in a transductive learning setting without knowing the attributes of the nodes, we have to generate $\\vec { x } _ { i }$ based on the graph structure solely. Here we use two existing strategies to generate features $\\vec { x } _ { i }$ . As shown in Fig. 3, the first approach is the random walk based method. We designed a biased random walk scheme for nodes in hypergraphs and used that to sample walks. Then, similar to node2vec, a skip-gram model is trained to generate features. The second approach is the encoder based approach where the corresponding row of the adjacency matrix is used as the features. The features are further passed through an autoencoder-like structure to reduce the dimensionality with the output of the hidden layer used as the features. The detailed description of these two approaches can be found in Appendix A.1. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            333
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            348,
+            281,
+            364
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We sought to compare Hyper-SAGNN with the state-of-the-art method DHNE as it has already been demonstrated with superior performance over previous algorithms such as DeepWalk, LINE, and HEBE. We first used the same four datasets in the DHNE paper to have a direct comparison. The details on these datasets can be found in the Appendix A.2. The details on the parameters used in this section for both Hyper-SAGNN and other methods can also be found in the Appendix A.3. The details of the tasks and the evaluation metrics used in this section are explained in the Appendix A.4. ",
+        "bbox": [
+            174,
+            373,
+            825,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 PERFORMANCE COMPARISON WITH EXISTING METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            602,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluated the effectiveness of our embedding vectors and the learned function with the network reconstruction task. We compared our Hyper-SAGNN using the encoder based approach and also the model using the random walk based pre-trained embeddings against DHNE and the baseline node2vec. We first trained the model and then used the learned embeddings to predict the hyperedges of the original network. We sampled the negative samples to be 5 times the amount of the positive samples following the same setup of DHNE. We evaluated the performance based on both the AUROC (Area Under the Receiver Operating Characteristic curve) and the AUPR (Area under the Precision-Recall curve). As shown in Table 1, Hyper-SAGNN can capture the network structure better than DHNE over all datasets either using the encoder based approach or the random walk based approach. ",
+        "bbox": [
+            173,
+            491,
+            825,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc4183757594eae59685c46f60cc5346c4987237e3133dfb671d77d68b1c1fb1.jpg",
+        "table_caption": [
+            "Table 1: AUC and AUPR values for network reconstruction. The models trained with the random walk based approach and the encoder based approach are marked as Hyper-SAGNN-W and Hyper-SAGNN-E, respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">GPS</td><td colspan=\"2\">MOVIELENS</td><td colspan=\"2\">DRUG</td><td colspan=\"2\">WORDNET</td></tr><tr><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>node2vec-mean</td><td>0.572</td><td>0.188</td><td>0.557</td><td>0.197</td><td>0.668</td><td>0.246</td><td>0.613</td><td>0.215</td></tr><tr><td>node2vec-min</td><td>0.570</td><td>0.187</td><td>0.535</td><td>0.186</td><td>0.682</td><td>0.257</td><td>0.576</td><td>0.201</td></tr><tr><td>DHNE</td><td>0.959</td><td>0.836</td><td>0.974</td><td>0.878</td><td>0.952</td><td>0.873</td><td>0.989</td><td>0.953</td></tr><tr><td>Hyper-SAGNN-E</td><td>0.971</td><td>0.877</td><td>0.991</td><td>0.952</td><td>0.977</td><td>0.916</td><td>0.989</td><td>0.950</td></tr><tr><td>Hyper-SAGNN-W</td><td>0.976</td><td>0.857</td><td>0.998</td><td>0.986</td><td>0.988</td><td>0.945</td><td>0.994</td><td>0.956</td></tr></table>",
+        "bbox": [
+            245,
+            680,
+            753,
+            755
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We further assessed the performance of Hyper-SAGNN on the hyperedge prediction task. We randomly split the hyperedge set into training and testing set by a ratio of 4:1. The way to generate negative samples is the same as the network reconstruction task. As shown in Table 2, our model again achieves significant improvement over DHNE for predicting the unseen hyperedges. The most significant improvement is from the wordnet dataset, which is about a $2 4 . 6 \\%$ increase on the AUPR score. For network reconstruction and hyperedge prediction tasks, the difference between the random walk based Hyper-SAGNN and the encoder based Hyper-SAGNN is minor. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition to the tasks related to the prediction of hyperedges, we also evaluated whether the learned embeddings are effective for node classification tasks. A multi-label classification experiment and a multi-class classification experiment were carried out for the MovieLens dataset and the wordnet dataset, respectively. We used Logistic Regression as the classifier. The proportion of the training data was chosen to be from $10 \\%$ to $90 \\%$ for the MovieLens dataset, and $1 \\%$ to $10 \\%$ for the wordnet dataset. We used averaged Mirco-F1 and Macro-F1 to evaluate the performance. The results are in Fig. 4. We observed that Hyper-SAGNN consistently achieves both higher Micro-F1 and Macro-F1 scores over DHNE for different fractions of the training data. Also, Hyper-SAGNN based on the random walk generally achieves the best performance (Hyper-SAGNN-W in Fig. 4). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b81cc54be66315c169f54f95b8208888706edca91c358f6796546394ccdc348f.jpg",
+        "image_caption": [
+            "Figure 4: Performance of classification on MovieLens and wordnet datasets. Hyper-SAGNNs trained with the random walk based approach and the encoder based approach are marked as Hyper-SAGNN-W, HyperSAGNN-E, respectively. The models trained with a mix of edges and hyperedges are denoted with “(mix)”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            88,
+            772,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            263,
+            825,
+            333
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 PERFORMANCE ON NON- $k$ -UNIFORM HYPERGRAPH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            344,
+            568,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Next, we evaluated Hyper-SAGNN using the non- $k$ -uniform heterogeneous hypergraph. For the above four datasets, we decomposed each hyperedge into 3 pairwise edges and added them to the existing graph. We trained our model to predict both the hyperedges and the edges (i.e., nonhyperedges). We then evaluated the performance for link prediction tasks for both the hyperedges and the edges. We also performed the node classification task following the same setting as above. The results for link prediction are in Table 2. Fig. 4 shows the results for the node classification task. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/06e023bd691c7e2496cc830fc9d549787ec0ebf503e27b8e211884c14d5cd92c.jpg",
+        "table_caption": [
+            "Table 2: Performance evaluation based on AUROC and AUPR for hyperedge/edge prediction. Methods with annotation (mix) represent Hyper-SAGNN trained with a mixture of edges and hyper-edges. Datasets marked with “(2)” represent the performance on pair-wise edge prediction (i.e., non-hyperedges). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">GPS</td><td colspan=\"2\">MOVIELENS</td><td colspan=\"2\">DRUG</td><td colspan=\"2\">WORDNET</td></tr><tr><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>node2vec-mean</td><td>0.563</td><td>0.191</td><td>0.562</td><td>0.197</td><td>0.670</td><td>0.246</td><td>0.608</td><td>0.213</td></tr><tr><td>node2vec - min</td><td>0.570</td><td>0.185</td><td>0.539</td><td>0.186</td><td>0.684</td><td>0.258</td><td>0.575</td><td>0.200</td></tr><tr><td>DHNE</td><td>0.910</td><td>0.668</td><td>0.877</td><td>0.668</td><td>0.925</td><td>0.859</td><td>0.816</td><td>0.459</td></tr><tr><td>Hyper-SAGNN-E</td><td>0.952</td><td>0.798</td><td>0.926</td><td>0.793</td><td>0.961</td><td>0.895</td><td>0.890</td><td>0.705</td></tr><tr><td>Hyper-SAGNN-W</td><td>0.922</td><td>0.722</td><td>0.930</td><td>0.810</td><td>0.955</td><td>0.892</td><td>0.880</td><td>0.706</td></tr><tr><td>Hyper-SAGNN-E (mix)</td><td>0.950</td><td>0.795</td><td>0.928</td><td>0.799</td><td>0.956</td><td>0.887</td><td>0.881</td><td>0.694</td></tr><tr><td>Hyper-SAGNN-W (mix)</td><td>0.920</td><td>0.720</td><td>0.929</td><td>0.811</td><td>0.950</td><td>0.889</td><td>0.884</td><td>0.684</td></tr><tr><td></td><td colspan=\"2\">GPS (2)</td><td></td><td>MOVIELENS (2)</td><td></td><td>DRUG (2)</td><td>WORDNET (2)</td><td></td></tr><tr><td></td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td><td>AUC</td><td>AUPR</td></tr><tr><td>Hyper-SAGNN-E (mix)</td><td>0.921</td><td>0.899</td><td>0.971</td><td>0.967</td><td>0.981</td><td>0.973</td><td>0.891</td><td>0.897</td></tr><tr><td>Hyper-SAGNN-W (mix)</td><td>0.931</td><td>0.910</td><td>0.999</td><td>0.999</td><td>0.999</td><td>0.999</td><td>0.923</td><td>0.916</td></tr></table>",
+        "bbox": [
+            225,
+            506,
+            767,
+            652
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We observed that Hyper-SAGNN can preserve the graph structure on different levels. Compared to training the model with hyperedges only, including the edges into the training would not cause obvious changes in performance for hyperedge predictions (about a $1 \\%$ fluctuation for AUC/AUPR). ",
+        "bbox": [
+            176,
+            672,
+            823,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We then further assessed the model in a new evaluation setting where there are adequate edges but only a few hyperedges presented. We asked whether the model can still achieve good performance on the hyperedge prediction based on this dataset. This scenario is possible in real-world applications especially when the dataset is combined from different sources. For example, in the drug dataset, it is possible that, in addition to the (user, drug, reaction) hyperedges, there are also extra edges that come from other sources, e.g., (drug, reaction) edges from the drug database, (user, drug) and (user, reaction) edges from the medical record. Here for each dataset that we tested, we used $50 \\%$ of the edges and only $5 \\%$ of the hyperedges to train the model. The results are in Fig. 5. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When using only the edges to train the model, our method still achieves higher AUROC and AUPR score for hyperedge prediction as compared to node2vec (Table 2). We found that when the model is trained with both the downsampled hyperedge dataset and the edge dataset, it would be able to reach higher performance or suffer less from overfitting than being trained with each of the datasets individually. This demonstrates that our model can capture the consensus information on the graph structure across different sizes of hyperedges. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/fae418121b31e783d45f3c35949e2f20fea66c4b8d15ea3f051e738578a0dfd8.jpg",
+        "image_caption": [
+            "Figure 5: AUROC and AUPR scores of Hyper-SAGNN for hyperedge prediction on the downsampled dataset over training epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            98,
+            766,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 OUTSIDER IDENTIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            406,
+            375
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition to the standard link prediction and node classification, we further formulated a new task called “outsider identification”. Previous methods such as DHNE can answer the question of whether a specific tuple of nodes $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ form a hyperedge. However, in many settings, we might also want to know the reason why this group of nodes will not form a hyperedge. We first define the outsider of a group of nodes as follows. Node $v _ { i }$ is the outsider of the node group $( v _ { 1 } , v _ { 2 } , . . . , v _ { k } )$ if it satisfies: ",
+        "bbox": [
+            174,
+            382,
+            825,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4930aa78d0fb98d1cfc449a3769776886cfebb21326824a4e01fea94d3e50a95.jpg",
+        "text": "$$\n\\begin{array} { l } { \\exists e \\in E , ( v _ { 1 } , v _ { 2 } , . . . , v _ { i - 1 } , v _ { i + 1 } , . . . , v _ { k } ) \\in e } \\\\ { \\exists e \\in E , s . t . \\exists j \\in \\{ 1 , 2 , . . , k \\} , j \\not = i , ( v _ { i } , v _ { j } ) \\in e } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            473,
+            658,
+            511
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We speculated that Hyper-SAGNN can answer this question by analyzing the probability score $p _ { 1 }$ to $p _ { k }$ (defined in Eqn. 7). We assume that the node $v _ { i }$ with the smallest $p _ { i }$ would be the outsider. We then set the evaluation as follows. We first trained the model as usual, but at the final stage, we replaced the average pooling layer with the min pooling layer and fine-tuned the model for several epochs. We then fed the generated triplets with known outsider node into the trained model and calculated the top- $k$ accuracy of the outsider node matching the node with the smallest probability. Because this task is based on the prediction results of the hyperedges, we only tested on the dataset that achieves the best hyperedge prediction, i.e., the drug dataset. We found that we have $8 1 . 9 \\%$ accuracy for the smallest probability and $9 5 . 3 \\%$ accuracy for the top-2 smallest probability. These results show that by switching the pooling layer we would have better outsider identification accuracy (from $78 . 5 \\%$ to $8 1 . 9 \\%$ ) with the cost of slightly decreased hyperedge prediction performance (AUC from 0.955 to 0.935). This demonstrates that our model is able to accurately predict the outsider within the group even without further labeled information. Moreover, the performance of outsider identification can be further improved if we include the cross-entropy between $p _ { i }$ and the label of whether $v _ { i }$ is an outsider for all applicable triplets in the loss term. Together, these results show the advantage of Hyper-SAGNN in terms of the interpretability of hyperedge prediction. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 APPLICATION TO SINGLE-CELL HI-C DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            544,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We next applied Hyper-SAGNN to the recently produced single-cell Hi-C (scHi-C) datasets (Ramani et al., 2017; Nagano et al., 2017). Genome-wide mapping of chromatin interactions by HiC (Lieberman-Aiden et al., 2009; Rao et al., 2014) has enabled comprehensive characterization of the 3D genome organization that reveals patterns of chromatin interactions between genomic loci. However, unlike bulk Hi-C data where signals are aggregated from cell populations, scHi-C provides unique information about chromatin interactions at single-cell resolution, thus allowing us to ascertain cell-to-cell variation of the 3D genome organization. Specifically, we propose that scHi-C makes it possible to model the cell-to-cell variation of chromatin interaction as a hyperedge, i.e., (cell, genomic locus, genomic locus). Note that the hyperedege here is “partially non-ordered”, namely (cell $i$ , locus $j$ , locus $k$ ) should be equivalent to (cell $i$ , locus $k$ , locus $j$ ). Our method is able to guarantee that while DHNE cannot achieve that directly. For the analysis of scHi-C, the most common strategy would be revealing the cell-to-cell variation by embedding the cells based on the contact matrix and then applying the clustering algorithms such as $K$ -means clustering on the embedded vectors. We performed the following evaluation to assess the effectiveness of HyperSAGNN on learning the embeddings of cells by representing the scHi-C data as hypergraphs. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We tested Hyper-SAGNN on two datasets. The first one consists of scHi-C from four human cell lines: HAP1, GM12878, K562, and HeLa (Ramani et al., 2017). The second one includes the scHiC that represents the cell cycle of the mouse embryonic stem cells (Nagano et al., 2017). We refer to the first dataset as “Ramani et al. data”, and the second as “Nagano et al. data” for abbreviation. We trained Hyper-SAGNN with the corresponding datasets. Due to the large average degrees of cell nodes, the random walk approach would take an extensive amount of time to sample the walks. Thus, we only applied the encoder version of our method. We visualize the learned embeddings by reducing them to 2 dimensions with PCA and UMAP (McInnes et al., 2018) (Fig. 6A-D). ",
+        "bbox": [
+            174,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We quantified the effectiveness of the embeddings by applying $K$ -means clustering on the Ramani et al. data and evaluating with Adjusted Rand Index (ARI). In addition, we also assessed the effectiveness of the embeddings with a supervised scenario. We used Logistic Regression as the classifier with $10 \\%$ of the cell as training samples and evaluated the multi-class classification task with Micro-F1 and Macro-F1. We did not run $K$ -means clustering on the Nagano et al. data as it represents a state of continuous cell cycle which is not suitable for a clustering task. We instead used the metric ACROC (Average Circular ROC) developed in the HiCRep/MDS paper (Liu et al., 2018) to evaluate the performance of the three methods on the Nagano et al. data. We compared the performance with two recently developed computational methods based on dimensionality reduction of the contact matrix, HiC-Rep/MDS (Liu et al., 2018) and scHiCluster (Zhou et al., 2019). Because Hyper-SAGNN is not a deterministic method for generating embeddings for scHi-C, we repeated the training process 5 times and averaged the score. All these results are in Fig. 6E. ",
+        "bbox": [
+            173,
+            285,
+            825,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e42575c08dd82a72351d9f23fffa4d7550e8993ed0dfe1a812f27b8b0b2ffd7f.jpg",
+        "image_caption": [
+            "Figure 6: (A) and (B): Visualization of the learned embedding based on Hyper-SAGNN for the Ramani et al. data. (C) and (D): Visualization of the learned embedding based on Hyper-SAGNN for the Nagano et al. data. Embedding vectors are projected to two dimensional space using either UMAP or PCA. (E): Quantitative evaluation of the Hyper-SAGNN on two scHi-C datasets "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            464,
+            810,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the Ramani et al. data (Fig. 6A-B), the visualization of the embedding vectors learned by HyperSAGNN exhibits clear patterns that cells with the same cell type are clustered together. Moreover, cell line HAP1, GM12878, and K562 are all blood-related cell lines, which are likely to be more similar to each other in terms of 3D genome organization as compared to HeLa. Indeed, we observed that they are also closer to each other in the embedding space. Quantitative results in Fig. 6E are consistent with the visualization as our method achieves the highest ARI, Micro-F1, MacroF1 score among all three methods. For the Nagano et al. data, as shown in Fig. 6C-D, we found that the embeddings exhibit a circular pattern that corresponds to the cell cycle. Also, both HiCRep/MDS and Hyper-SAGNN achieve high ACROC scores. All these results show the effectiveness of representing the scHi-C datasets as hypergraphs using Hyper-SAGNN, which has great potential to provide insights into the cell-to-cell variation of higher-order genome organization. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we developed a new graph neural network called Hyper-SAGNN for the representation learning of general hypergraphs. The model has the flexibility to deal with homogeneous and heterogeneous, and uniform and non-uniform hypergraphs. We demonstrated that Hyper-SAGNN can improve or match state-of-the-art performance for hypergraph representation learning while addressing the shortcomings of prior methods such as the inability to predict hyperedges for non- $k$ -uniform heterogeneous hypergraphs. Hyper-SAGNN is computationally efficient as the input size to the attention layer is bounded by the maximum hyperedge size as opposed to the number of neighbors. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            226
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One potential improvement of Hyper-SAGNN as future work would be to allow information aggregation over all the first-order neighbors before calculating the static/dynamic embeddings for a node with the additional computational cost. With this design, the static embedding for a node would still satisfy our constraint that it is fixed for a known hypergraph with varying input tuples. This would allow us to incorporate previously developed methods on graphs, such as GraphSAGE (Hamilton et al., 2017a) and GCN (Kipf & Welling, 2016), as well as methods designed for hypergraphs like HyperGCN (Yadati et al., 2018) into this framework for better link prediction performance. Such improvement may also extend the application of Hyper-SAGNN to semi-supervised learning. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            346,
+            375
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J.M. acknowledges support from the National Institutes of Health Common Fund 4D Nucleome Program grant U54DK107965, National Institutes of Health grant R01HG007352, and National Science Foundation grant 1717205. Y.Z. (Yao Class, IIIS, Tsinghua University) contributed to this work as a visiting undergraduate student at Carnegie Mellon University during summer 2019. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            440
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            285,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Bai, Feihu Zhang, and Philip HS Torr. Hypergraph convolution and hypergraph attention. arXiv preprint arXiv:1901.08150, 2019. ",
+        "bbox": [
+            173,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Inci M Baytas, Cao Xiao, Fei Wang, Anil K Jain, and Jiayu Zhou. Heterogeneous hyper-network embedding. In 2018 IEEE International Conference on Data Mining (ICDM), pp. 875–880. IEEE, 2018. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In Advances in Neural Information Processing Systems 26, pp. 2787–2795. Curran Associates, Inc., 2013. ",
+        "bbox": [
+            176,
+            218,
+            823,
+            261
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fuli Feng, Xiangnan He, Yiqun Liu, Liqiang Nie, and Tat-Seng Chua. Learning on partial-order hypergraphs. In Proceedings of the 2018 World Wide Web Conference, pp. 1523–1532. International World Wide Web Conferences Steering Committee, 2018. ",
+        "bbox": [
+            173,
+            270,
+            826,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. Hypergraph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3558–3565, 2019. ",
+        "bbox": [
+            174,
+            321,
+            825,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge Discovery and Data Mining, pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huan Gui, Jialu Liu, Fangbo Tao, Meng Jiang, Brandon Norick, and Jiawei Han. Large-scale embedding learning in heterogeneous event data. In 2016 IEEE 16th International Conference on Data Mining (ICDM), pp. 907–912. IEEE, 2016. ",
+        "bbox": [
+            173,
+            426,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017a. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William L Hamilton, Rex Ying, and Jure Leskovec. Representation learning on graphs: Methods and applications. arXiv preprint arXiv:1709.05584, 2017b. ",
+        "bbox": [
+            171,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "F. Maxwell Harper and Joseph A. Konstan. The movielens datasets: History and context. ACM Trans. Interact. Intell. Syst., 5(4):19:1–19:19, December 2015. ISSN 2160-6455. ",
+        "bbox": [
+            174,
+            556,
+            821,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jie Huang, Chuan Chen, Fanghua Ye, Jiajing Wu, Zibin Zheng, and Guohui Ling. Hyper2vec: Biased random walk for hyper-network embedding. In International Conference on Database Systems for Advanced Applications, pp. 273–277. Springer, 2019. ",
+        "bbox": [
+            174,
+            594,
+            825,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            173,
+            647,
+            821,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Erez Lieberman-Aiden, Nynke L Van Berkum, Louise Williams, Maxim Imakaev, Tobias Ragoczy, Agnes Telling, Ido Amit, Bryan R Lajoie, Peter J Sabo, Michael O Dorschner, et al. Comprehensive mapping of long-range interactions reveals folding principles of the human genome. Science, 326(5950):289–293, 2009. ",
+        "bbox": [
+            173,
+            685,
+            825,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jie Liu, Dejun Lin, Galip Gurkan Yardımcı, and William Stafford Noble. Unsupervised embedding ¨ of single-cell hi-c data. Bioinformatics, 34(13):i96–i104, 2018. ",
+        "bbox": [
+            169,
+            751,
+            823,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Leland McInnes, John Healy, and James Melville. Umap: Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018. ",
+        "bbox": [
+            171,
+            790,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient Estimation of Word Representations in Vector Space. arXiv e-prints, art. arXiv:1301.3781, Jan 2013. ",
+        "bbox": [
+            171,
+            829,
+            823,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In C. J. C. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K. Q. Weinberger (eds.), Advances in Neural Information Processing Systems 26, pp. 3111–3119. Curran Associates, Inc., 2013. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Takashi Nagano, Yaniv Lubling, Csilla Varnai, Carmel Dudley, Wing Leung, Yael Baran, ´ Netta Mendelson Cohen, Steven Wingett, Peter Fraser, and Amos Tanay. Cell-cycle dynamics of chromosomal organization at single-cell resolution. Nature, 547(7661):61, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge Discovery and Data Mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            178,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vijay Ramani, Xinxian Deng, Ruolan Qiu, Kevin L Gunderson, Frank J Steemers, Christine M Disteche, William S Noble, Zhijun Duan, and Jay Shendure. Massively multiplex single-cell hi-c. Nature Methods, 14(3):263, 2017. ",
+        "bbox": [
+            179,
+            207,
+            821,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Suhas SP Rao, Miriam H Huntley, Neva C Durand, Elena K Stamenova, Ivan D Bochkov, James T Robinson, Adrian L Sanborn, Ido Machol, Arina D Omer, Eric S Lander, et al. A 3d map of the human genome at kilobase resolution reveals principles of chromatin looping. Cell, 159(7): 1665–1680, 2014. ",
+        "bbox": [
+            173,
+            257,
+            826,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liang Sun, Shuiwang Ji, and Jieping Ye. Hypergraph spectral learning for multi-label classification. In Proceedings of the 14th ACM SIGKDD international Conference on Knowledge Discovery and Data Mining, pp. 668–676. ACM, 2008. ",
+        "bbox": [
+            173,
+            323,
+            826,
+            366
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ke Tu, Peng Cui, Xiao Wang, Fei Wang, and Wenwu Zhu. Structural deep embedding for hypernetworks. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            375,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            412,
+            823,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017. ",
+        "bbox": [
+            169,
+            463,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Anand Louis, and Partha Talukdar. Hypergcn: Hypergraph convolutional networks for semi-supervised classification. arXiv preprint arXiv:1809.02589, 2018. ",
+        "bbox": [
+            174,
+            501,
+            823,
+            545
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chia-An Yu, Ching-Lun Tai, Tak-Shing Chan, and Yi-Hsuan Yang. Modeling multi-way relations with hypergraph embedding. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, pp. 1707–1710, 2018. ",
+        "bbox": [
+            176,
+            553,
+            823,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent W. Zheng, Bin Cao, Yu Zheng, Xing Xie, and Qiang Yang. Collaborative filtering meets mobile recommendation: A user-centered approach. In Proceedings of the Twenty-Fourth AAAI Conference on Artificial Intelligence, AAAI’10, pp. 236–241. AAAI Press, 2010. ",
+        "bbox": [
+            178,
+            604,
+            821,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dengyong Zhou, Jiayuan Huang, and Bernhard Scholkopf. Learning with hypergraphs: Clustering, ¨ classification, and embedding. In Advances in Neural Information Processing systems, pp. 1601– 1608, 2007. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jingtian Zhou, Jianzhu Ma, Yusi Chen, Chuankai Cheng, Bokan Bao, Jian Peng, Terrence J Sejnowski, Jesse R Dixon, and Joseph R Ecker. Robust single-cell hi-c clustering by convolutionand random-walk–based imputation. Proceedings of the National Academy of Sciences, pp. 201901423, 2019. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 DETAILS OF THE STRATEGIES FOR GENERATING FEATURE VECTORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            128,
+            686,
+            143
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We first define the functions used in the subsequent sections as follows: a hyperedge $e$ with weight $w ( e )$ is incident with a vertex $v$ if and only if $v \\in e$ . We denote the indicator function that represents the incident relationship between $v$ and $e$ by $h ( v , e )$ , which equals 1 when $e$ is incident with $v$ . The degree of vertex and the size of hyperedge are defined as: ",
+        "bbox": [
+            173,
+            151,
+            825,
+            208
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/743d8fbb20d31a6146169106c1776a75438101543481a225ecc39b039dd41522.jpg",
+        "text": "$$\n\\begin{array} { l } { { d ( v ) \\triangleq \\displaystyle \\sum _ { e \\in E } h ( v , e ) w ( e ) } } \\\\ { { \\delta ( e ) \\triangleq \\displaystyle \\sum _ { v \\in V } h ( v , e ) = | e | } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            213,
+            583,
+            284
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 ENCODER BASED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            297,
+            436,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As shown on the right side of Fig. 3, the first method to generate features is referred to as the encoder based approach, which is similar to the structure used in DHNE (Tu et al., 2018). We first obtain the incident matrix of the hypergraph $H \\in \\mathbb { R } ^ { | V | \\times | E | }$ with entries $h ( v , e ) = 1$ if $v \\in e$ and 0 otherwise. We also calculate the diagonal degree matrix $D _ { v }$ containing the vertex degree $\\begin{array} { r } { d ( v ) = \\sum _ { e \\in E } h ( v , e ) } \\end{array}$ . We thus have the adjacency matrix $A = H H ^ { T } - D _ { v }$ , of which the entries $a ( v _ { i } , v _ { j } )$ denote the concurrent times between each pair of nodes $( v _ { i } , v _ { j } )$ . The $i$ -th row of $A$ , denoted by $\\vec { a } _ { i }$ , shows the neighborhood structures of the node $v _ { i }$ , which then passes through a one-layer neural network to produce $\\vec { x } _ { i }$ : ",
+        "bbox": [
+            173,
+            320,
+            826,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a41983913a048d981b102d3bf96a72a94deff66078da0a1a3de5e039d95ff49d.jpg",
+        "text": "$$\n\\vec { x } _ { i } = \\operatorname { t a n h } \\left( W _ { \\mathrm { e n c } } \\cdot \\vec { a } _ { i } + \\vec { b } _ { \\mathrm { e n c } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            443,
+            598,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In DHNE, a symmetric structure was introduced where there are corresponding decoders to transform the $\\vec { x } _ { i }$ back to $\\vec { a } _ { i }$ . Tu et al. (2018) remarked that including this reconstruction error term would help DHNE to learn the graph structure better. We also include the reconstruction error term into the loss function, but with tied-weights between encoder and decoder to reduce the number of parameters that need to be trained. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            544
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.2 RANDOM WALK BASED APPROACH ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            478,
+            566
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Besides the encoder based approach, we also utilize a random walk based framework to generate the feature vectors $\\vec { x } _ { i }$ (shown on the left side of Fig. 3). We extend the biased 2nd-order random walks proposed in node2vec (Grover & Leskovec, 2016) to generalize to hypergraphs. For a walk from $v$ to $x$ then to $t$ , the strategies are described as follows. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            631
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The 1st-order random walk strategy given the current vertex $x$ is to randomly select a hyperedge $e$ incident with $x$ based on the weight of $e$ and then to choose the next vertex $y$ from $e$ uniformly (Zhou et al., 2007). Therefore, the 1st-order transition probability is defined as: ",
+        "bbox": [
+            173,
+            638,
+            825,
+            680
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/885e9d1772d18ca174b55f954148a8029ce5164e9da8651cf657d82389861813.jpg",
+        "text": "$$\n\\pi _ { 1 } ( t | x ) \\triangleq \\sum _ { e \\in E } w ( e ) { \\frac { h ( t , e ) h ( x , e ) } { \\delta ( e ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            685,
+            612,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We then generalize the 2nd-order bias $\\alpha _ { p q }$ from ordinary graph to hypergraph for a walk from $v$ to $x$ to $t$ as: ",
+        "bbox": [
+            173,
+            731,
+            823,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a8798d0be07371576e48672d7533c13c441cf7e4fb0004444b03bcd75250deb.jpg",
+        "text": "$$\n\\alpha _ { p , q } ( t , v ) = { \\left\\{ \\begin{array} { l l } { 1 / p , } & { { \\mathrm { i f ~ } } \\exists e \\in E { \\mathrm { , ~ s . t . ~ } } t , v , x \\in e } \\\\ { 1 { \\mathrm { , ~ } } } & { { \\mathrm { e l s e ~ i f ~ } } \\exists e \\in E { \\mathrm { , ~ s . t . ~ } } t , x \\in e } \\\\ { 1 / q , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            762,
+            663,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where the parameters $p$ and $q$ are to control the tendencies that encourage outward exploration and obtain a local view. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            840
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Next we add the above terms to set the biased 2nd-order transition probability as: ",
+        "bbox": [
+            174,
+            848,
+            707,
+            863
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88c35c57eb1b2402d42f4c869c995ee05bea1a2cd24c0ca3fd5a37359a7d5cbe.jpg",
+        "text": "$$\n\\pi ( t | v , x ) = { \\left\\{ \\begin{array} { l l } { { \\frac { \\pi _ { 1 } ( t | x ) \\cdot \\alpha _ { p q } ( t , v ) } { Z } } , } & { { \\mathrm { i f ~ } } \\exists e \\in E { \\mathrm { , ~ s . t . ~ } } v , x \\in e } \\\\ { 0 , } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            868,
+            681,
+            904
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $Z$ is a normalizing factor. ",
+        "bbox": [
+            174,
+            909,
+            387,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "With the well-defined 2nd-order transition probability $\\pi ( t | v , x )$ , we simulate a random walk of fixed length $l$ through a 2nd-order Markov process marked by $\\begin{array} { r } { \\dot { P } ( c _ { i } = t | c _ { i - 1 } = x , c _ { i - 2 } = v ) = \\pi ( t | v , x ) } \\end{array}$ , where $c _ { i }$ is the $i$ -th node in the walk. A Skip-gram model (Mikolov et al., 2013; Mikolov et al., 2013) is then used to extract the node features from sampled walks such that the nodes that appear in similar contexts would have similar embeddings. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 DETAILS OF THE DATASETS USED IN THIS WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            185,
+            552,
+            199
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The four datasets used in the first part of our evaluation are: ",
+        "bbox": [
+            174,
+            207,
+            563,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "• GPS (Zheng et al., 2010): GPS network. The hyperedges are based on (user, location, activity) relations.   \n• MovieLens (Harper & Konstan, 2015): Social network. The hyperedges are based on (user, movie, tag) relations, describing peoples’ tagging activities.   \n• drug: Medicine network from FAERS1. The hyperedges are based on (user, drug, reaction) relations.   \n• wordnet (Bordes et al., 2013): Semantic network from WordNet 3.0. The hyperedges are based on (head entity, relation, tail entity), expressing the relationships between words. ",
+        "bbox": [
+            215,
+            233,
+            825,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Details of the datasets are shown in Table A1. ",
+        "bbox": [
+            174,
+            376,
+            473,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/c8f57ad17c2083e90dce2c27943db42afa37caa92737d04263cb1702c4815e0b.jpg",
+        "table_caption": [
+            "Table A1: Datasets used in this work. Note that the columns under $\\ddot { \\# } ( \\mathrm { V } ) \\dot { \\cdot }$ ” correspond to the columns under “node type” for each dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>DATASETS</td><td colspan=\"4\">NODETYPE</td><td colspan=\"2\">#(V)</td><td>#(E)</td></tr><tr><td>GPS</td><td>user</td><td>location</td><td>activity</td><td>146</td><td>70</td><td>5</td><td>1,436</td></tr><tr><td>MovieLens</td><td>user</td><td>movie</td><td>tag</td><td>2,113</td><td>5,908</td><td>9,079</td><td>47,957</td></tr><tr><td>drug</td><td>user</td><td>drug</td><td>reaction</td><td>12</td><td>1,076</td><td>6,398</td><td>171,756</td></tr><tr><td>wordnet</td><td>head</td><td>relation</td><td>tail</td><td>40,504</td><td>18</td><td>40,551</td><td>145,966</td></tr></table>",
+        "bbox": [
+            264,
+            444,
+            732,
+            500
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 PARAMETER SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            370,
+            541
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We downloaded the source code of DHNE from its GitHub repository. The structure of the neural network of DHNE was set to be the same as what the authors described in Tu et al. (2018). We tuned parameters such as the $\\alpha$ term and the learning rate following the same procedure. We also tried adding dropout between representation vectors and the fully connected layer for better performance of DHNE. All these parameters were tuned until it was able to replicate or even improve the performance reported in the original paper. To make a fair comparison, for all the results below, we made sure that the training and validation data setups were the same across different methods. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            647
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For node2vec, we decomposed the hypergraph into pairwise edges and ran node2vec on the decomposed graph. For the hyperedge prediction task, we first used the learned embedding to predict pairwise edges. We then used the mean or min of the pairwise similarity as the probability for the tuple to form a hyperedge. We set the window size to 10, walk length to 40, the number of walks per vertex to 10, which are the same parameters used in DHNE for node2vec. However, we found that for the baseline method node2vec, when we tuned the hyper-parameter $p , q$ and also used larger walk length, window size and walks per vertex (120, 20, 80 instead of 40, 10, 10), it would achieve comparable performance for node classification task as DHNE. This observation is consistent with our designed biased hypergraph random walk. But this would result in a longer time for sampling the walks and training the skip-gram model. We therefore kept the parameters consistent with what was used in DHNE paper. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For our Hyper-SAGNN, we set the representation size to 64, which is the same as DHNE. The number of heads in the multi-head attention layer is set to 8. When using the encoder based approach to calculate $x _ { i }$ , we set the encoder structure to be the same as the encoder part in DHNE. When using the random walk based approach, we decomposed the hypergraph into a graph as described above. We set the window size to 10, walk length to 40, the number of walks per vertex to 10, to allow time-efficient generation of feature vector $\\vec { x } _ { i }$ . The results in Section 4.1 showed that even when the pre-trained embeddings are not so ideal, Hyper-SAGNN can still well capture the structure of the graph. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            897
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To train the model, we used the Adam optimizer with learning rate 1e-3. Each batch contains 96 positive hyperedges with 480 negative samples. The training is terminated when it reaches the maximum training epoch number (100) or the performance on the validation set no longer improves. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            181
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.4 EXPERIMENT SETTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            191,
+            377,
+            207
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To compare the performance of Hyper-SAGNN with other baseline methods, we used the same three tasks in the DHNE paper, i.e., network reconstruction, link prediction, and node classification. In this section, we describe the setting of these three tasks and the evaluation metrics. ",
+        "bbox": [
+            178,
+            215,
+            821,
+            257
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Network reconstruction aims to reconstruct the input hypergraph from the learned embedding. Specifically, a hypergraph $G = ( V , E )$ is used as input to the algorithm. After training, the model makes predictions for the original hyperedge set $E$ . Link prediction, on the other hand, aims to predict the unseen hyperedge set $E ^ { ' }$ based on the model trained with hypergraph $G = ( V , E )$ . These two tasks can be regarded as binary classification tasks and thus can be evaluated by metrics such as AUROC and AUPR. For both tasks, the negative samples are set to be 5 times the amount of the positive samples following the same setup of DHNE. ",
+        "bbox": [
+            174,
+            263,
+            823,
+            363
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For the node classification, after training the model, the embeddings for the nodes are used to train a Logistic Regression classifier with targets as the pre-defined labels for the nodes. Here we have a multi-label classification and a multi-class classification task for dataset MovieLens and wordnet, respectively, making the metrics defined for binary classification not applicable. Therefore, the performances are evaluated by Micro and Macro F1 scores that are used for quantifying the performance of multi-label/multi-class classification. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.5 ANALYSIS OF THE DYNAMIC EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            465,
+            511,
+            479
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss the relationships between dynamic embeddings and static embeddings. As mentioned in the Method section, we design the model to establish the connection between the probability score for a tuple with how well the static embedding of each node can be approximated by the features of their neighbor within that tuple. If the model works as we designed, the dynamic embedding of node $i$ conditioned on an actual hyperedge $( i , j , . . . , k )$ should approximate the static embedding of node $i$ better. In contrast, the dynamic embedding of node $i$ when it is a member of a non-hyperedge tuple would not have a good “approximation”. To evaluate this, after training the model we collected all the dynamic embeddings for nodes when they are within the tuples of positive samples, which would be referred to as positive dynamic embeddings. We also collected the dynamic embeddings for nodes when conditioned on the “hard negative samples” (the negative samples that are generated by only changing one node in the positive samples), which would be referred to as negative dynamic embeddings. We tested whether the positive dynamic embeddings indeed resemble the static embeddings better by comparing the performance of node classification using dynamic embeddings and static embeddings. For each node, since the number of positive and negative dynamic embeddings is not finite, we sampled and averaged a number of them as the features. The remaining setting of node classification is the same as described in the main text. As shown in Fig. A1, in general, the positive dynamic embeddings can achieve much better performance as compared to the negative dynamic embeddings. Both the micro and macro F1 scores increase when more positive dynamic embeddings are sampled and averaged. When averaging all positive dynamic embeddings and using those as features, the node classification performance is close to what we achieved using static embeddings. This analysis demonstrates that the positive dynamic embeddings “approximate” the static embeddings as they contain sufficient information for accurate node classification. In addition, for the negative dynamic embeddings where only one node is changed when generating negative samples, it performs dramatically worse. Note that we exclude the $\\alpha _ { i i }$ term in the calculation of dynamic embeddings, which makes the dynamic embedding for node $i$ the combination of features of its neighbor within a given tuple. These results demonstrate that the probability scores for each node indicate the “distances” of static/dynamic embedding pairs that reflect how well the static embedding of each node can be approximated by the features of their neighbor within that tuple. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            890
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb460ae70ceeb9a325f12172826863dd0024c467475db80935c30b53d25ef7e7.jpg",
+        "image_caption": [
+            "Figure A1: Node classification performance comparison for static embeddings and dynamic embeddings. The results based on static embeddings are marked as “static”. Results based on positive/negative dynamic embeddings are marked as “dynamic P/dynamic $\\mathbf { N } ^ { \\ast }$ . The numbers of dynamic embeddings sampled during this process are also included in the legend. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            821,
+            220
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.6 COMPARISON OF HYPER-SAGNN VS. THE VARIANTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            310,
+            591,
+            324
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, unlike the standard GAT model, we exclude the $\\alpha _ { i i }$ term in the self-attention mechanism. To test whether this constraint would improve or reduce the model’s ability to learn, we implemented a variant of our model (referred to as variant type I) by including this term. Also, as mentioned in the Method section, another potential variant of our model would be directly using the $\\vec { d } _ { i } ^ { * }$ to calculate the probability score $p _ { i } ^ { * }$ . We refer to this variant as variant type II. For variant type II, on node classification task, since it does not have a static embedding, we used $W _ { v } ^ { T } x _ { i }$ . The rest of the parameters and structure of the neural network remain the same. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            434
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We then compared the performance of Hyper-SAGNN and two variants in terms of AUC and AUPR values for network reconstruction task and hyperedge link prediction task on the following four datasets: MovieLens, wordnet, drug, and GPS. We also compared the performance in terms of the Micro F1 score and Macro F1 score on the node classification task on the MovieLens and the wordnet dataset. For the MovieLens dataset, we used $90 \\%$ nodes as training data while for wordnet, we used $1 \\%$ of the nodes as training data. All the evaluation setup is the same as described in the main text. To avoid the effect of randomness from the neural network training, we repeated the training process for each experiment five times and made the line plot of the score versus the epoch number. To illustrate the differences more clearly, we started the plot at epoch 3 for the random walk based approach and epoch 12 for the encoder based approach. The performance of the model using the random walk based approach is shown in Fig. A2 to Fig. A5. The performance of the model using the encoder based approach is shown in Fig. A6 to Fig. A9. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            608
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For models with the random walk based approach, Hyper-SAGNN is the best in terms of all metrics for the GPS, MovieLens, and wordnet dataset. On the drug dataset, Hyper-SAGNN achieves higher AUROC and AUPR score on the network reconstruction task than two variants, but slightly lower AUROC score for the link prediction task (less than $0 . 5 \\%$ ). ",
+        "bbox": [
+            174,
+            614,
+            823,
+            670
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For models with the encoder based approach, the advantage is not that obvious. All 3 methods achieve similar performance in terms of all metrics for the GPS and the drug dataset. For the MovieLens and wordnet dataset, Hyper-SAGNN performs similar to variant type I, higher than variant type II on the network reconstruction and link prediction task. However, our model achieves slightly higher accuracy on the node classification task than variant type I. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            747
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Therefore, these evaluations show that the choice of the structure of Hyper-SAGNN can achieve higher or at least comparable performance than the two potential variants over multiple tasks on multiple datasets. ",
+        "bbox": [
+            176,
+            755,
+            823,
+            796
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/51e83ee47bb78e57d5d07a62922e2371e76bac3c9f5ba046f817cf40e271982a.jpg",
+        "image_caption": [
+            "Figure A2: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (GPS) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            121,
+            686,
+            320
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/9382330a834f8f978055a6ca4455646e2ac520152c58fcd1285082668294877f.jpg",
+        "image_caption": [
+            "Figure A3: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (MovieLens) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            393,
+            686,
+            595
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/593260bbf4d269b2e743f2b2302db1123091baf47f951389eea7223f51914fae.jpg",
+        "image_caption": [
+            "Figure A4: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (drug) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            672,
+            686,
+            872
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/77dbd2b072ced8c9d0eca0cc205863e3f7958ec022875ec18fed5eec74415cc9.jpg",
+        "image_caption": [
+            "Figure A5: Performance comparison of Hyper-SAGNN – Walk and Variant Type I, II (wordnet) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            122,
+            686,
+            320
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/62c4b08ae880e11812964c3db4cab98703489e417dbe87bf91139b323a320f57.jpg",
+        "image_caption": [
+            "Figure A6: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (GPS) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            397,
+            686,
+            595
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/047d6767bbdd4d374629324ce84b71ce57ca325ee96f6fa2721e2ec1fe9f8a5b.jpg",
+        "image_caption": [
+            "Figure A7: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (MovieLens) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            315,
+            672,
+            684,
+            872
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/73e154b86af5c356ef1314dc08e6b0cc394cc96efddeb08bc2aecbb52121848f.jpg",
+        "image_caption": [
+            "Figure A8: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (drug) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            310,
+            190,
+            686,
+            388
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd304b130b7f2610d04d5b246f96dab66458b07093fbaf55601a91075e353667.jpg",
+        "image_caption": [
+            "Figure A9: Performance comparison of Hyper-SAGNN – Encoder and Variant Type I, II (wordnet) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            312,
+            606,
+            686,
+            803
+        ],
+        "page_idx": 17
+    }
+]

parse/train/ryeHuJBtPH/ryeHuJBtPH_middle.json ADDED Viewed

The diff for this file is too large to render. See raw diff

parse/train/ryeHuJBtPH/ryeHuJBtPH_model.json ADDED Viewed

The diff for this file is too large to render. See raw diff