We’ve Got the Beat: Predicting Artist Collaboration with Homogeneous and Heterogeneous GNNs

By Ricky Rios, Mack Smith, and Sidd Wali as part of the Stanford CS224W course project.

1. Introduction

For decades, the Billboard Hot 100 has shown us which songs are already shaping popular music, but it does not tell us much about the creative possibilities that have not happened yet. Fans often imagine what it would sound like if two artists came together, and many people keep their own lists of dream pairings they hope will happen someday. This project takes that curiosity seriously and asks the following question: given past collaboration patterns and the characteristics of successful charting songs, which new artist pairs seem most likely to produce a hit if they worked together?

To answer this question, the project uses all Billboard Hot 100 weekly charts from 2005 to 2021, covering roughly 8,000 unique tracks and 5,500 artists. Each track is paired with detailed chart trajectories as well as audio features from the Spotify Web API and ReccoBeats, allowing the final graph to reflect both collaboration structure and the underlying sound of each song. Four models are then trained for link prediction on an artist–track graph: a baseline random forest classifier, GCNConv and GraphSAGE models with link predictors, and a heterogeneous R-GCN that distinguishes artists, tracks, and their relation types. Once trained, each model’s performance is evaluated using accuracy, precision, recall, F1-score, and ROC-AUC metrics to measure how well each approach recovers real collaborations and generalizes to unseen pairs. This provides the foundation for exploring which new artist pairings are most likely to produce future hits, and we’ll explore each step thoroughly in the sections to come.

2. Data

2.1 Data Preprocessing

The core dataset consists of all Billboard Hot 100 weekly charts from 2005 through 2021 [1], which include around 8,000 unique tracks and 5,500 unique artists. For each track, the raw chart information includes weekly rank, peak rank, total weeks on the chart, and whether the song appeared in the previous week. From these week-by-week rankings, several summary variables are engineered, such as average rank across the chart run, best rank achieved, and longest consecutive chart streak.

These chart-derived features help distinguish between songs with brief one-week appearances and those that show real staying power. After cleaning and standardizing artist and track names, each song is consolidated into a single record containing its chart statistics, which can then be merged with audio features.

To capture what each track actually sounds like, the project collects audio descriptors through the Spotify Web API [2] and ReccoBeats API [3]. Cleaned songs and artist names are matched to Spotify track IDs, which are then translated to ReccoBeats IDs containing additional metadata and a consistent set of audio features. The table below summarizes these features and what they capture:

Once merged with chart statistics, each track receives a single feature vector that later attaches to its track node in the graph. For labeling artist–artist edges, a collaboration is assigned a positive label if at least one joint track achieved a minimum peak Billboard rank of 20 or better. All other artist collaborations that do not meet this threshold, along with corrupted edges created during negative sampling, are treated as negative examples.

2.2 Graph Construction

The full artist-track ecosystem is represented as a graph built directly from collaboration credits on each Billboard track. After cleaning the metadata, every credited artist, including primary artists, featured artists, and group members, is treated as an individual artist node. Each track becomes its own track node with the audio and chart features attached.

Then, two types of edges are added. First, for every track, undirected edges connect all pairs of collaborating artists, forming cliques for duets, features, and larger ensembles. Second, edges link each artist to every track they contributed to, allowing information about the sound and commercial success of a song to flow back to the artists who created it.

Figure 1: Example Graph Construction from Billboard Hot 100 Songs

This structure supports both homogeneous and heterogeneous modeling. In the homogeneous setting, all nodes share the same type, with edges representing artist-artist collaborations or artist-track connections. In the heterogeneous setting, the graph distinguishes artists from tracks and includes three relation types: artist-artist collaborations, artist-to-track production edges, and track-to-artist production edges. This richer schema allows the R-GCN to learn different transformations for different types of relationships, better reflecting real differences between “who works with whom” and “which songs an artist performed.”

3. Methods

Before diving into the specific architectures, it is helpful to outline the setup that all models share. Each model is trained to perform artist-artist link prediction: given a pair of artists, the task is to predict whether they have a “successful” collaboration. Here, a successful collaboration is defined as having worked together on at least one track that reached a peak Billboard rank of 20 or better. Thus, edges between artists that meet this criterion are labeled as positive, while all other artist-artist pairs are treated as negative.

To improve the efficiency of training, we use negative sampling [7], which allows the model to learn from a smaller but more informative set of negative examples rather than considering every possible artist pair.

In practice, this means selecting a subset of artist pairs that are assumed to be negative and using them to contrast against the positive examples during training. To create a realistic set of these negative examples, the training data combines two sources: randomly corrupted edges (u, v’) that do not exist in the graph at all, and hard negatives formed by real collaborations that never reached the top 20 threshold. Ultimately, this negative sampling approach encourages the models not only to distinguish between collaborators and non-collaborators but also to separate highly successful collaborations from less successful ones.

Lastly, to ensure fair comparison among all methods, all models are trained and evaluated on the same train/validation/test edge splits.

3.1 Baseline Model

As a baseline, we use a feature-based Random Forest classifier that ignores graph structure entirely. For each ordered pair of artists, the model first aggregates the audio features of all tracks each artist has contributed to by taking simple averages, producing a fixed-length feature vector for each artist. These two vectors are then concatenated to form the input for the classifier, which predicts whether the pair has at least one top‑20 collaboration.

3.2 Homogeneous GNNs

The next step in our methodology is to explicitly incorporate the structure of the collaboration network using homogeneous graph neural networks, where all nodes share the same type and all edges are treated uniformly. To initialize artist node features, the same aggregation used in the baseline is applied: each artist’s features are the average of the audio features of the tracks they have performed on. Track nodes carry their full audio and chart feature vectors, and edges link artists to tracks and artists to other artists as described in the Data section.

Two homogeneous GNN encoders are considered: a GCN model and a GraphSAGE model, each with two layers and a hidden dimension of 64. Below is the update rule for a GCN layer [4]:

where the GCN layer updates all node embeddings by first aggregating a normalized sum of neighbor features (including the node itself), then applying a shared linear transformation and nonlinearity to produce the next-layer representations. Additionally, we present the update rule for a GraphSAGE layer [5]:

where the GraphSAGE layer updates each node by aggregating (e.g., averaging) transformed features from its neighbors, combining this neighborhood summary with a transformed version of the node’s own features, and then applying a nonlinearity to obtain the next-layer embedding. After message passing, the network produces a learned embedding for each artist. Candidate artist pairs are scored by a two-layer MLP link predictor that takes the concatenation of the two artist embeddings and outputs a scalar score interpreted as the probability of a successful collaboration. A threshold of 0.5 is applied during evaluation to convert scores into binary predictions.

The loss function combines Binary Cross‑Entropy (BCE) loss over positive and sampled negative edges with a de-correlation penalty on the artist embeddings.

Concretely, the covariance matrix of centered artist embeddings is computed, a small regularization term is added, and the negative log-determinant of this matrix is included in the loss [8].

This discourages the embeddings from collapsing onto a few dominant directions, which often correspond to high-degree, very popular artists. Without this term, message passing can cause neighboring artists to inherit nearly identical embeddings, making it harder for the model to learn distinct features. Standard techniques such as dropout (0.2) and ReLU activations are applied throughout the network to improve generalization.

For information regarding the implementation of homogeneous GNNs, the classes for each model is provided in the code block below:

class GCN(torch.nn.Module):
    """
    GCN implementation on a homogenous graph.
    Outputs embeddings for all the nodes after 2 layers of GCN.
    """
    def __init__(self, input_dim, hidden_dim, output_dim, num_layers,
                 dropout=0.5):
        super(GCN, self).__init__()
        self.convs = torch.nn.ModuleList()
        self.bns = torch.nn.ModuleList()

        self.convs.append(GCNConv(in_channels=input_dim, out_channels=hidden_dim))
        self.bns.append(torch.nn.BatchNorm1d(num_features=hidden_dim))

        for i in range(num_layers-2):
            self.convs.append(GCNConv(in_channels=hidden_dim, out_channels=hidden_dim))
            self.bns.append(torch.nn.BatchNorm1d(num_features=hidden_dim))

        self.convs.append(GCNConv(in_channels=hidden_dim, out_channels=output_dim))

        self.dropout = dropout

    def reset_parameters(self):
        for conv in self.convs:
            conv.reset_parameters()
        for bn in self.bns:
            bn.reset_parameters()

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        for i in range(len(self.convs) - 1):
            x = self.convs[i](x, edge_index)
            x = self.bns[i](x)
            x = F.relu(x)
            x = F.dropout(x, p=self.dropout, training=self.training)
        x = self.convs[-1](x, edge_index)
        x = F.normalize(x, p=2, dim=1)
        return x

class GNNStack(torch.nn.Module):
    """
    GNN Stack using PyG's SAGEConv with batch normalization.
    Outputs embeddings for all the nodes.
    """
    def __init__(self, input_dim, hidden_dim, num_layers=2, dropout=0.5):
        super(GNNStack, self).__init__()
        self.convs = nn.ModuleList()
        self.bns = nn.ModuleList()

        # First layer
        self.convs.append(SAGEConv(input_dim, hidden_dim))
        self.bns.append(nn.BatchNorm1d(hidden_dim))

        # Hidden layers
        assert (num_layers >= 1), 'Number of layers is not >=1'
        for l in range(num_layers-1):
            self.convs.append(SAGEConv(hidden_dim, hidden_dim))
            self.bns.append(nn.BatchNorm1d(hidden_dim))

        self.dropout = dropout
        self.num_layers = num_layers

    def forward(self, data):
        x, edge_index = data.x, data.edge_index

        for i in range(self.num_layers):
            x = self.convs[i](x, edge_index)
            x = self.bns[i](x)
            x = F.relu(x)
            x = F.dropout(x, p=self.dropout, training=self.training)

        # Normalize final embeddings for better link prediction
        x = F.normalize(x, p=2, dim=1)
        return x

3.3 Heterogeneous GNNs

Finally, we introduce a heterogeneous Relational Graph Convolutional Network (R‑GCN) that is tailored to the artist-track graph. In this setup, there are two node types (artists and tracks) and three relation types: artist-artist collaborations, artist-to-track “performed” edges, and track‑to‑artist “performed by” edges. Artist nodes are initialized with randomly initialized feature vectors, while track nodes carry their full audio and chart feature vectors. This allows the model to propagate track information to artists and artist interactions across the collaboration network, without forcing them into the same input space.

The R‑GCN encoder uses two heterogeneous convolution layers with 64 hidden units, ReLU activations, and dropout of 0.2. Each layer applies relation-specific transformations so that different edge types contribute differently to the updated node representations. Below is the update rule for an R-GCN layer [6]:

where, in words, the R‑GCN layer updates each node by aggregating transformed messages from its neighbors separately for every relation type, normalizing each relation-specific sum, adding a transformed self‑loop term, and then applying a nonlinearity to produce the next‑layer embedding.. Additionally, an attention mechanism weighs the contribution of each relation type, allowing the model to emphasize direct artist–artist collaborations over indirect connections when that is informative. Batch normalization was omitted in the final configuration because it led to better performance.

For decoding, the R‑GCN uses a hybrid link predictor that combines a bilinear similarity score with a small MLP applied to the two artist embeddings, summing both components to produce the final collaboration score. This approach captures more nuanced relationships between embedding dimensions than a simple dot product would.

As with the homogeneous GNNs, the primary loss is Binary Cross‑Entropy with negative sampling, augmented by the covariance-based regularization on artist embeddings to prevent dimensional collapse. The covariance matrix of centered, normalized artist embeddings is computed, a small diagonal regularization is added, and the log-determinant is maximized.

This encourages the embeddings to span a rich subspace, complementing the heterogeneous architecture and allowing the model to capture the complex structure of the artist–track ecosystem.

For information regarding the implementation of R-GCN, the class for the model is provided in the code block below:

class HeteroGCNConv(MessagePassing):
    def __init__(self, in_channels_src: int, in_channels_dst: int, out_channels: int):
        super().__init__(aggr="mean")

        self.in_channels_src = in_channels_src
        self.in_channels_dst = in_channels_dst
        self.out_channels = out_channels

        self.lin_src = nn.Linear(in_channels_src, out_channels, bias=False)
        self.lin_dst = nn.Linear(in_channels_dst, out_channels, bias=False)
        self.lin_update = nn.Linear(2 * out_channels, out_channels)

    def forward(
        self,
        node_feature_src: torch.Tensor,
        node_feature_dst: torch.Tensor,
        edge_index: torch.Tensor,
        size=None,
    ) -> torch.Tensor:
        if size is None:
            size = (node_feature_src.size(0), node_feature_dst.size(0))
        aggr_out = self.propagate(
            edge_index=edge_index,
            x=node_feature_src,
            node_feature_dst=node_feature_dst,
            size=size,
        )
        return aggr_out

    def message(self, x_j: torch.Tensor) -> torch.Tensor:
        return self.lin_src(x_j)

    def update(
        self, aggr_out: torch.Tensor, node_feature_dst: torch.Tensor
    ) -> torch.Tensor:
        h_dst = self.lin_dst(node_feature_dst)
        h_cat = torch.cat([h_dst, aggr_out], dim=-1)
        out = self.lin_update(h_cat)
        return out

class HeteroGCNWrapperConv(hetero_gnn.HeteroConv):
    def __init__(
        self,
        convs: Dict[Tuple[str, str, str], nn.Module],
        aggr: str = "mean",
        attn_size: int = None,
    ):
        super().__init__(convs, None)
        self.aggr = aggr
        self.mapping: Dict[int, Tuple[str, str, str]] = {}
        self.alpha = None

        example_conv = next(iter(convs.values()))
        out_dim = example_conv.out_channels

        if self.aggr == "attn":
            self.attn_proj = nn.Linear(out_dim, attn_size or out_dim, bias=False)
            self.attn_score = nn.Linear(attn_size or out_dim, 1, bias=False)
        else:
            self.attn_proj = None
            self.attn_score = None

    def forward(self, x, edge_index):
        self.mapping = {idx: k for idx, k in enumerate(edge_index.keys())}
        return super().forward(x, edge_index)

    def aggregate(self, xs):
        if len(xs) == 1:
            return xs[0]

        if self.aggr == "mean":
            return torch.stack(xs, dim=0).mean(0)

        if self.aggr == "sum":
            return torch.stack(xs, dim=0).sum(0)

        if self.aggr == "attn":
            x = torch.stack(xs, dim=0)  # [num_types, N, D]
            h = torch.tanh(self.attn_proj(x))
            z = self.attn_score(h).squeeze(-1)  # [num_types, N]
            z = z.mean(1)  # [num_types]

            alpha = torch.softmax(z, dim=0)
            self.alpha = alpha.detach().cpu().numpy()

            alpha = alpha.view(-1, 1, 1)
            out = (x * alpha).sum(0)
            return out

        raise ValueError(f"Unknown aggregation mode: {self.aggr}")

class HeteroGCNLayer(nn.Module):
    def __init__(
        self,
        hetero_graph: HeteroGraph,
        in_channels_dict: Dict[str, int],
        out_channels: int,
        aggr: str = "mean",
        dropout: float = 0.0,
        attn_size: Optional[int] = None,
        activation: str = "leaky_relu",
        use_bn: bool = True,
    ):
        super().__init__()

        self.node_types = list(hetero_graph.node_types)
        self.out_channels = out_channels

        convs: Dict[Tuple[str, str, str], nn.Module] = {}
        for (src, rel, dst) in hetero_graph.message_types:
            convs[(src, rel, dst)] = HeteroGCNConv(
                in_channels_src=in_channels_dict[src],
                in_channels_dst=in_channels_dict[dst],
                out_channels=out_channels,
            )

        self.conv = HeteroGCNWrapperConv(convs, aggr=aggr, attn_size=attn_size)
        self.use_bn = use_bn
        if use_bn:
            self.bns = nn.ModuleDict(
                {t: nn.BatchNorm1d(out_channels, eps=1.0) for t in self.node_types}
            )
        else:
            self.bns = None

        if activation == "relu":
            act = nn.ReLU()
        elif activation == "leaky_relu":
            act = nn.LeakyReLU()
        elif activation == "none" or activation is None:
            act = None
        else:
            raise ValueError(f"Unknown activation: {activation}")

        if act is not None:
            self.acts = nn.ModuleDict({t: act for t in self.node_types})
        else:
            self.acts = None

        self.dropout = nn.Dropout(dropout)

    def forward(self, x_dict, edge_index_dict):
        x = self.conv(x_dict, edge_index_dict)
        for t in x:
            if self.use_bn and t in self.bns:
                x[t] = self.bns[t](x[t])
            if self.acts is not None and t in self.acts:
                x[t] = self.acts[t](x[t])
            x[t] = self.dropout(x[t])
        return x

class CustomHeteroGCN(nn.Module):
    """
    Hetero GCN encoder. Returns embeddings per node type.
    """

    def __init__(
        self,
        hetero_graph: HeteroGraph,
        layer_dims: List[int],
        aggrs="mean",
        dropouts=0.0,
        activations="leaky_relu",
        attn_sizes=None,
        use_bn: bool = True,
    ):
        super().__init__()

        # Initialize base features
        self.node_types = list(hetero_graph.node_types)
        self.layer_dims = layer_dims

        def _as_list(x, name):
            if isinstance(x, (list, tuple)):
                assert len(x) == len(layer_dims), f"{name} must match len(layer_dims)"
                return list(x)
            return [x for _ in layer_dims]

        aggrs = _as_list(aggrs, "aggrs")
        dropouts = _as_list(dropouts, "dropouts")
        activations = _as_list(activations, "activations")
        if attn_sizes is None or isinstance(attn_sizes, int):
            attn_sizes = [attn_sizes for _ in layer_dims]
        else:
            assert len(attn_sizes) == len(layer_dims), "attn_sizes length mismatch"

        in_channels_dict = {
            t: hetero_graph.num_node_features(t) for t in self.node_types
        }

        # Create Layers
        layers = []
        for i, out_dim in enumerate(layer_dims):
            layer = HeteroGCNLayer(
                hetero_graph=hetero_graph,
                in_channels_dict=in_channels_dict,
                out_channels=out_dim,
                aggr=aggrs[i],
                dropout=dropouts[i],
                attn_size=attn_sizes[i],
                activation=activations[i],
                use_bn=use_bn,
            )
            layers.append(layer)
            in_channels_dict = {t: out_dim for t in self.node_types}

        self.layers = nn.ModuleList(layers)

    def forward(self, x_dict, edge_index_dict):
        x = x_dict
        for layer in self.layers:
            x = layer(x, edge_index_dict)
        return x  # dict[node_type] -> embeddings

    def encode(self, x_dict, edge_index_dict):
        return self.forward(x_dict, edge_index_dict)

4. Results

With the methodology for each model established, we can now turn to the results. Note that all graph-based models were trained for up to 1,000 epochs, with early stopping triggered when validation performance plateaued. Additionally, as mentioned above, each model was then evaluated using the same five metrics (accuracy, precision, recall, F1-score, and ROC-AUC) to allow for a consistent and fair comparison across approaches.

Table 2 summarizes the test performance of all four models on the artist–artist link prediction task, framed as a binary classification problem. The baseline Random Forest already performs quite well in terms of overall accuracy (0.8698) and ROC‑AUC (0.8851), showing that even a model based purely on track and artist features can distinguish positive from negative collaborations reasonably effectively. Its recall, however, is much lower at 0.3106, meaning that it fails to identify a large portion of actual collaborations, and the F1 score of 0.4556 reflects this imbalance between high precision and low recall. Simply put, the Random Forest model is cautious. When it predicts a collaboration, it is usually correct, but it avoids labeling many edges as positive, leaving numerous potential collaborations undetected. This conservative behavior makes it reliable when it does make predictions, but it also limits its usefulness for discovering new or less obvious artist pairings.

Introducing graph structure through the homogeneous GNN models improves this balance. GCN raises precision to 0.8814 and recall to 0.3939, resulting in an F1 score of 0.5445 and accuracy of 0.8711. These improvements suggest that leveraging information about the connections between artists allows the model to recover more true collaborations without sacrificing much precision. GraphSAGE takes this a step further, increasing precision to 0.8966 while maintaining the same recall. Its F1-score rises slightly to 0.5474 and accuracy to 0.8726. This shows that GraphSAGE is even more confident when it predicts a collaboration, though its slightly lower ROC‑AUC of 0.8308 indicates that it may not rank all potential edges as consistently as the other models. Overall, the homogeneous GNNs demonstrate that incorporating the network of past collaborations helps the model detect more true collaborations compared with using only feature-based information.

To get a sense of how the homogeneous models actually arrange artists in their learned representation spaces, we project the final embeddings into two dimensions using t-SNE and color each artist by the maximum number of weeks they have appeared on the Billboard chart in Figure 2. In both GraphSAGE and GCN, artists with longer chart presence tend to gather in their own neighborhoods, which suggests that the models are learning to distinguish long-running hit-makers from artists with shorter chart histories. The two visualizations also highlight some small stylistic differences between the models: GraphSAGE forms slightly tighter, more compact clusters, while GCN shows smoother, more gradual transitions between regions. This fits well with their performance metrics, where the two models behave similarly overall but differ a bit in how they rank potential collaborations.

Figure 2. t‑SNE visualization of artist embeddings learned by GraphSAGE (left) and GCN (right), colored by each artist’s maximum weeks on the Billboard Hot 100.

The heterogeneous R‑GCN exhibits a different performance profile altogether. While its overall accuracy is lower at 0.7142, it achieves extremely high recall at 0.9722 and the highest ROC‑AUC of all models at 0.9409. This indicates that the R‑GCN is very aggressive in predicting positive edges, capturing nearly all true collaborations even though it introduces more false positives, as reflected in its lower precision of 0.6413. Despite the drop in precision, its F1-score of 0.7728 is the highest overall, highlighting the advantage of explicitly modeling artists and tracks as separate node types and distinguishing between different kinds of relationships. By taking the heterogeneous structure into account, the R‑GCN can identify subtle patterns in how artists collaborate across tracks, making it particularly effective at uncovering true collaborations. Depending on the goal, such as suggesting new artist pairings in a recommendation setting, this high-recall, high-AUC approach may be preferable because it emphasizes coverage and captures a broad set of potential collaborations.

Together, these results illustrate the trade-offs between precision, recall, and overall ranking across models. The Random Forest provides a cautious but precise approach, the homogeneous GNNs offer modest improvements by incorporating graph structure, and the heterogeneous R‑GCN leverages the full richness of the artist–track network to capture nearly all true collaborations. Therefore, understanding these trade-offs can help guide how each model might be used depending on whether the priority is accuracy, coverage, or ranking quality.

5. Discussion

Moving forward, a natural extension of our work is to include temporal information in the model. Music trends shift over time, artists change their style as they progress in their careers, and collaborations often form when artists rise in popularity around the same period. Temporal graph networks provide a promising way to capture these patterns. By adding time-stamped data, such as Billboard Hot 100 entries, we can associate each song with a specific year and allow an artist’s representation to evolve rather than collapsing their entire career into one average embedding. This would help the model distinguish between different phases of an artist’s work and generate recommendations that feel more aligned with their current sound.

There are also two areas where the model itself could be strengthened. First, improving our negative sampling strategy could help the model learn more precise distinctions. Right now, we sample negatives uniformly at random. Using proximity based negatives, similar to the approach used in PinSage [9], would introduce harder examples and teach the model to pick up on finer differences. Second, it would be valuable to expand the features we use to describe each song. Acoustic features alone do not capture emotional tone or thematic content. Adding semantic information, for example from lyric analysis or user commentary, would allow the model to make recommendations based on similarities in writing style and overall feel, not just sound. This would lead to more thoughtful and expressive predictions.

6. Conclusion

Ultimately, this project validates the effectiveness of applying Graph Neural Networks, particularly the Heterogeneous R-GCN, to the complex task of artist collaboration prediction. By shifting from feature-based analysis to a model that explicitly captures the distinct relationships between artists and tracks, we demonstrate the potential to uncover collaboration opportunities missed by simpler methods. While our best-performing model prioritizes high coverage over precision, this work establishes a robust foundation for building advanced, high-recall recommendation systems. In the future, we intend to focus on integrating temporal dynamics and multimodal content features to create more nuanced and timely predictions.

Code

Our code for data preprocessing, training (homogeneous, heterogeneous), and evaluation is on Github

References

[1] “Billboard ‘The Hot 100’ Songs” dataset (historical charts). https://www.kaggle.com/datasets/dhruvildave/billboard-the-hot-100-songs

[2] Spotify Web API documentation (track metadata and IDs). https://developer.spotify.com/documentation/web-api​

[3] ReccoBeats Audio Feature Extraction API (acousticness, danceability, energy, etc.). https://reccobeats.com/docs/documentation/Analysis/audio-features-extraction​

[4] Kipf, T. N., & Welling, M. “Semi-Supervised Classification with Graph Convolutional Networks.” ICLR 2017. https://arxiv.org/abs/1609.02907​

[5] Hamilton, W. L., Ying, Z., & Leskovec, J. “Inductive Representation Learning on Large Graphs” (GraphSAGE). NeurIPS 2017. https://arxiv.org/abs/1706.02216​

[6] Schlichtkrull, M. et al. “Modeling Relational Data with Graph Convolutional Networks” (R-GCN). https://research.vu.nl/ws/files/246718572/Modeling_Relational_Data_with_Graph_Convolutional_Networks.pdf​

[7] Yang, C. et al. “Understanding Negative Sampling in Graph Representation Learning.” https://www.semanticscholar.org/paper/Understanding-Negative-Sampling-in-Graph-Learning-Yang-Ding/

​[8] Example of covariance-based and log-determinant regularization for representation decorrelation (discussing covariance and log-det penalties in deep models). https://arxiv.org/html/2407.20684v1

[9] Ying, R. et al. “Graph Convolutional Neural Networks for Web-Scale Recommender Systems” (PinSage). KDD 2018. https://arxiv.org/abs/1806.01973​