Perception-Inspired Graph Convolution for Music Understanding Tasks

1 Introduction

Music data can be represented in computer applications in multiple formats, two popular ones being audio and symbolic representations. The first encodes a measure of the pressure/intensity of the sound wave over time, while the second explicitly encodes discrete musical events such as notes and rests (see [Foscarin et al., 2022] for an overview of different symbolic music formats). Due to this higher-level information, symbolic representations are generally considered better inputs/outputs for music analysis and generation tasks in the Music Information Research (MIR) field. Moreover, any musical task that starts from a musical score (sheet music) or from MIDI files is naturally in the symbolic domain.

In the MIR literature, symbolically encoded music is typically handled with techniques heavily inspired by computer vision (CV) or natural language processing (NLP) research. In the first case, music is represented in a so-called "piano roll" format (first developed in MIDI sequencers) and treated as a raster image, with the X axis being time, and the Y axis pitch. The pitch values are typically encoded as MIDI pitch, i.e., with integers in [0 - 127], which covers all notes that can be played by common well-tempered instruments (a range that is larger than the range of the piano, with 88 notes), and the time resolution is a parameter that is usually set to the expected shortest note duration. In its simpler version, each element of the 2D matrix is set to 1 if a note is sounding at the corresponding pitch and time, or 0 otherwise. The downside of this approach is that it creates a very large and very sparse input matrix since only a few notes will play at any time. The other common approach is treating music with sequential models fromNLP research. Although different tokenization techniques have been proposed [Fradet et al., 2021], it is easy to argue that music does not fit well into strictly sequential models, since more than one note can sound simultaneously, notes can partially overlap, and generally, the pitch-temporal relations between notes hold important musical information.

A few recent works [Hsiao and Su, 2021; Jeong et al., 2019; Karystinaios and Widmer, 2022; Karystinaios et al., 2023; Zhang et al., 2023] started to explore the use of graphs, and Graph Neural Networks (GNNs), to represent and process symbolic music. Significant advances have been reported on various musical tasks [Karystinaios et al., 2023; Karystinaios and Widmer, 2023]. However, the components that these papers use are "borrowed" from GNN research with other types of data.

We argue that this can lead to suboptimal results. As a solution, we design MusGConv, a new graph convolutional block specifically dedicated to music data, that is founded on fundamental music perception principles. We test our approach on four musical tasks: voice separation, composer classification, Roman numeral analysis, and cadence detection. This selection of tasks allows us to cover three major graph neural network classes of problems: graph classification, link prediction, and node classification. We compare our results with the state-of-the-art graph models for these tasks and show that the use of MusGConv leads to better results overall. Moreover, its simple design enables this performance boost without adding any additional computational cost.

2 Perceptual andModeling Considerations

We base our research on the perceptual principles of two fundamental musical dimensions: pitch and rhythm. Cognitive studies show that people are not very sensitive to the absolute pitch of individual notes and perceive mainly the distance between pitches [Deutsch, 2013]. Thus, we perceive the same musical pattern if it is shifted higher or lower in frequency. This is called relative pitch perception and has been formalized in music theory through measures of pitch distance called intervals, which are the basis of all musical concepts that involve combinations of pitches, such as chords and harmony. The position (and duration) of notes in time is also not important in itself but only relative to the position (and duration) of the other notes. This temporal organization is called rhythm and is typically composed of patterns that tend to be periodic and organized at different hierarchical levels.

While these principles are simple, producing relative features to use as input for deep learning systems is not an easy task. For the pitch representation, considering intervals between consecutive notes instead of absolute pitches, as proposed for example in the IDyOM framework [Pearce, 2018; Pearce, 2005], poses the problem of defining a note order. This is trivial for monophonic melodies but becomes problematic for polyphonic music, where multiple notes can fully or partially overlap in time. Figure 1 (c) exemplifies a possible ordering rule, but such rules may not be generally valid for different pieces and contexts or in general yield very different interval sequences for very similar patterns (e.g., if we remove the F), thus not helping with learning a general representation. Inserting interval information after the music has been tokenised in a sequential representation [Kermarec et al., 2022], creates similar ordering problems.

Another strategy is to rely on music theory and consider pitch distances relative to the fundamental note defined by the key of the piece (see Fig. 1 (b). This has a musicological limitation, as the key signature of a piece may not change when there are temporary modulations to other keys, and a practical one, as keys are not always notated in musical datasets and MIDI files. Not to mention all the music that falls outside the classic tonal framework, for which the definition of a key is not even meaningful. The most common alternative, e.g., [Nakamura et al., 2016; Foscarin et al., 2021], has been the use of data augmentation via transposition, assuming that if the network sees transpositions of the same piece, it will learn patterns that are general across all transpositions. However, this is far from ideal since the network will need to store similar patterns redundantly, thus making inefficient use of network capacity and drastically increasing training time.

For this reason, we believe that designing relative features to input to our system is not a viable option for general music modelling. We explore a different path, which is to customize the working mechanism of our network to take into account the relative perceptual properties of music through a dedicated message-passing mechanism that computes pairwise pitch and time representations. This is weakly related to recent work on audio representations of music that aims at learning transposition-invariant features [Lattner et al., 2018; Elowsson and Friberg, 2019; Lattner et al., 2019] and tempo-invariant rhythmic patterns [Di Giorgi et al., 2021]. Other related work targets graphs whose edges encode geometric information [Atzmon et al., 2018; Wang et al., 2019a; Satorras et al., 2021], intending to build representations that are invariant to operations such as translation. The ideas from these last approaches (with minor modifications) are also beneficial for musical tasks, but we show that our music-specific approach outperforms them.

Up to this point, we have highlighted the importance of relative pitch and time representations. However, their absolute values could also be important depending on the task at hand. For example, instruments would peculiarly change their timbre as they approach very low or very high notes in their range, which is recognisable by a listener. In tonal music, the absolute pitch of notes defines a key signature which could be relevant in the composer classification task (specific keys can have very specific meanings to composers, and within a musical tradition). The same goes for absolute time positions, for example, with patterns happening at the beginning or end of a piece. Finally, the output of our network may need to be an absolute pitch (for example, in the Roman numeral analysis task we describe later ), and therefore we need to retain this information in the network.

This need for considering both absolute and relative pitch and time positions motivates the design of our new convolutional block, to be described in detail in Section 4 below.

3 Graph Approaches toMusical Tasks

In this section, we describe existing graph modelling approaches to the four musical tasks we use to evaluate our proposal. They all have a common pipeline which involves building a graph from a given musical score (see Figure 2) and using a series of convolutional blocks to produce contextaware hidden representations for each node. We start by describing the graph-building procedure and a generic graph convolutional block; we then proceed by detailing the tasks and the specific network components used to target them.

3.1 Graph fromMusical Scores

A graph is defined as a set of nodes V and a set of edges E, where each edge (u, v) ∈ E connects the nodes v, u ∈ V . We extend this definition by considering labelled edges which we model as a triple (u, r, v), where u, v ∈ V and r ∈ R is a relation type. A graph with edges of multiple types (we don't use different types of nodes in this work) is called heterogeneous. Moreover, we consider an attributed graph, i.e., a graph where each node is described by a set of features, which we group in the columns of the matrix X. Our attributed heterogeneous graph is defined as G = (V, E, X).

We create such a directed graph from a musical score following the work of Karystinaios et al. [2023]. Each node v ∈ V corresponds to one and only one note in the musical score. R includes 4 types of relations: onset, during, follow, and silence, corresponding, respectively, to two notes starting at the same time, a note starting while the other is sounding, a note starting when the other ends, and a note starting after a time when no note is sounding. The inverse edges for during, follows, and silence relations are also created.

The feature matrix X is composed of the following features extracted from each note of the score: the pitch class, i.e., one of the 12 note names (C, C#, D, D#, etc.), the octave in [1, . . . , 7], the note duration, encoded as a single float value d ∈ [0, 1] computed as the ratio of the note and bar durations, passed through a tanh function to limit its value and give more resolution to shorter notes, as proposed by Karystinaios et al. [2023]. For the task of Roman Numeral Analysis and Cadence Detection, we add additional specialized features to be consistent with the approach in the literature we consider in our evaluation [Karystinaios and Widmer, 2023; Karystinaios and Widmer, 2022].

3.2 Graph Convolution Operation

We now present a generic graph convolutional block, to simplify the description of our music-dedicated approach in the next section. Given an attributed homogeneous graph G, a graph convolution block that updates the representation of node u for layer l + 1 can be described as:

where aggregate(·) denotes a differentiable, permutation invariant aggregation function, e.g., sum, mean, etc.; ϕ and ψ are called edge operation and node operation, respectively, and denote differentiable learnable functions such as concatenation, sum, or multiplication, followed by a linear transformation; σ denotes a non-linear function, N(u) denotes the neighbours of u; h(l) u is the hidden representation of node u at layer l.

Furthermore, if we want to leverage edge features, Equation 2 becomes:

where, euv are features of the directed edge connecting node v with node u.

When G is heterogeneous, the function N(u) in Equation 1 is modified as proposed in [Schlichtkrull et al., 2018] to return only the neighbours nodes which are connected with an edge of type r. Equations 1 and 3 are then computed |R| times and the results hr (l) u aggregated in an unique node latent representation h(l) u as:

where aggregate(·) denotes a differentiable, permutation invariant aggregation function such as sum or mean.

We now turn to describe the tasks that we will use for evaluation and the task-specific part of our graph model.

3.3 Monophonic Voice Separation

Voice separation is the task of segmenting a symbolic music piece into an unknown number of individual monophonic note streams according to musical and perceptual criteria. Duoane and Pardo [2009] framed the problem as a link prediction task in which two notes are linked if they are consecutive in the same voice. Karystinaios et al. [2023] proposed a GNN-based model that reached new state-of-the-art results.

Following their approach, we perform this task by adding a link predictor module, consisting of an MLP which takes as input the hidden representations of nodes and for each pair of nodes performs a binary classification between the "linked" and "not-linked" classes.

The evaluation metric is the binary F1 score, i.e. the F1 score for the positive class which represents the true links in the ground truth. Karystinaios et al. also consider the F1 score after a postprocessing phase, but we don't use it to keep the number of metrics of reasonable size, and because, as they report, postprocessing increases the metric in a way which does not always correlate perfectly with the network performance.

3.4 Composer Classification

Composer classification from a symbolic musical score is the task of identifying the composer of the score from a list of composers. In the graph problem taxonomy, this falls in the category of global graph classification tasks. Following the work of Zhang et al. [2023], we perform this task by adding a global mean pooling layer to our architecture, which averages the latent representations built by our GNN blocks, followed by an MLP which predicts probabilities over composer classes. The composer classification predictions are evaluated in terms of classification accuracy.

3.5 Roman Numeral Analysis

Roman numeral analysis is a branch of analytical musicology whose goal is to infer the underlying harmony and chord progressions from a musical score. The result is a set of complex composite labels (the Roman numerals) which annotate music at the onset level, i.e., for every score position that corresponds to one or more note onsets. Related work [Chen et al., 2018; Micchi et al., 2020; McLeod and Rohrmeier, 2021; L´opez et al., 2021] frames RN analysis as a multi-task classification problem where every label is broken down into 5 components (degree, inversion, root, key, and quality) which are predicted by different classifiers in hard-parameter-sharing setting. Of these components, degree, inversion, and quality are transposition invariant and the rest depend on the absolute pitches in the input. A recent approach [Karystinaios and Widmer, 2023] considers a graph input and obtains new state-of-the-art results.

Following this work, we perform this task by adding to our general architecture an onset edge pooling layer that contracts the latent representations from the note-wise level to the onsetwise, i.e., it creates a single vector per unique onset. All vectors are then ordered by time position and fed into a GRU layer whose output is finally used by the aforementioned MLP classifiers. In the taxonomy of graph problems, RN analysis falls in between node classification and subgraph classification because of the effect of the edge pooling layer.

The evaluation score is the so-called Chord Symbol Recall (CSR), i.e., the ratio of the total duration of segments where prediction equals annotation vs. the total duration of annotated segments [Harte, 2010].

3.6 Cadence Detection

Cadence detection is a music analysis task that consists of detecting cadences, i.e. phrase endings with a strong and specific melodic-harmonic closure effect, in a musical score. Cadences are important both musicologically and perceptually and it is known that they relate to particular voicings and chord progressions; however, their automatic predictions remain particularly challenging due to the high number of exceptions and corner cases. A recent graph approach [Karystinaios and Widmer, 2022] framed the problem as a multiclass node classification scenario, by predicting the presence of a cadence and its type for each note.

Following that work, we use a graph autoencoder architecture and the latent synthetic oversampling technique SMOTE [Chawla et al., 2002] to balance the heavily unbalanced class labels. For the same reason, the reported evaluation metric is the macro F1 score.

4 Our Approach: MusGConv

Similarly to previous works, we use stacked graph convolutions to create a hidden representation of notes that is then used as input for specific music tasks (see Figure 2). In our proposed approach, we replace the graph convolutional blocks in the stack with our novel convolutional block (see Figure 3).

In terms of the notation introduced in the general description of the graph convolution in Section 3.2, our convolutional block is characterised by two core contributions: a way to build the edge features e, and the choice of the edge operation ϕ in Equation 4.

4.1 Edge Features Computation

For each edge between nodes u, v, we consider three edge features: eonset vu , edur vu , epitch vu each of them encoded as a single scalar corresponding to the distance between onset, duration, and pitch, respectively.

This roughly corresponds to the computation of distance in papers that deal with geometrical data [Satorras et al., 2021] except that in their case it is a multidimensional space distance, while we compute a set of one-dimensional distances since it makes no sense to mix duration, pitch and onset information. To keep these values in a convenient numerical range, we normalise each feature with ℓ2 normalisation over all edges in a batch.

Additionally, we inform the network about the pitch-class interval (PCInt), i.e., the distance between notes without considering the octave, or the interval direction. This can be seen as a relative version of the chroma feature, which is commonly used in MIR tasks related to the harmonic content of the music. This integer in [0, . . . , 11] is passed through an embedding layer, i.e., a learnable look-up table which maps these integers to points ePCInt vu in a continuous multidimensional space.

For each edge, all the aforementioned edge features are concatenated in a single vector:

4.2 Edge Operation

Our second contribution, needed to properly leverage the edge feature information, is a new formulation of the message passing paradigm (see Figure 3 for a graphical representation). The new edge operation defines the edge operation ϕ in Equation 4 as follows:

where gΘ denotes a simple two-layer MLP with a Relu activation and layer-wise normalization.

Note how we concatenate the edge features here, while other approaches that deal with edge features tend to apply a permutation-invariant operation such as multiplication or addition [Satorras et al., 2021; Hu et al., 2019]. In this way, the transposition- and time-invariant information carried by the edge features is treated in the same way as the node feature when computing the pairwise representation ηuv. This is inspired by musicological considerations: we don't want to weight/modify the absolute representation according to the relative representation, but rather to just use it as input, as is done by cognitively plausible musical models [Pearce, 2018; Pearce, 2005]. This is similar to what we discuss in Section 1 but, by using MusGConv, we no longer have the problem of setting a (debatable) order of the input notes, since for each node, we will consider the relative features according to every other node connected to it (see Figure 4).

We consider two variants of our system which differ in the edge features which are passed to layers after the first. The first variant, named MusGConv uses the absolute difference of the node hidden embeddings, i.e. ∀l > 0,

The second variant, named MusGConv(+EF), uses the edge hidden representation from the previous layer as the edge features of the next layer:

4.3 Node Operation

To complete the explanation of our convolutional block, we specify the specific computation for the generic node operation ψ introduced in Equation 1:

The aggregation function is a sum, and we choose to concatenate the hidden representation of u with the messages ηvu from the other nodes. For heterogeneous convolutions (i.e. Equation 5), we use mean(·) as the aggregation function. Such choices are not motivated by musical reasoning, and experimenting with other operations could be an interesting direction, but are out of the scope of this paper.

5 Data

Musical score graph datasets are different from common datasets in the graph-related literature regarding the number and size of graphs. Node classification and link prediction datasets often only consist of a single huge graph, coupled with a sampling strategy to obtain subgraphs to train and evaluate the Graph Neural Network [Hamilton et al., 2017; Zou et al., 2019]. On the other hand, graph classification datasets often consist of a large number of small graphs, with less than 50 nodes [Wu et al., 2021]. Musical score graphs are neither small nor extremely large and may vary significantly in size; a Bach Chorale may have ∼ 100 notes whereas a Beethoven Sonata might have more than 5000 (with every note corresponding to a node in the graph).

Moreover, popular sampling strategies, such as node-wise sampling, subgraph sampling, random-walk sampling, and spectral sampling, may yield musically problematic note configurations, for example, by segregating notes that are played at the same time while grouping in the same subgraph notes that are very far apart. This is problematic, especially for musically-local tasks such as voice separation or Roman numeral analysis, where the system cannot be expected to produce a meaningful result, and could even learn to perform the task in the wrong way if some notes (and onsets for the roman numeral analysis) are missing.

In the previous works on graph scores that we are considering, the problem is avoided by training on mini-batches which consist of single pieces. However, this is not an efficient solution since it always leaves a big part of memory unused, thus unnecessarily prolonging the training time and decreasing the variability in the batch. We describe the new sampling mechanism we use in the following section, and then move on to detailing the datasets used in our experiments.

5.1 Data Sampling

While our nodes can be ordered by multiple features, the organizational aspect that is most prominent from a perceptual point of view is time. Indeed, people would still recognize a music piece if it is segmented over the time axis, while, for example, considering only pitches in a certain interval could lead to meaningless results. There is also perceptual evidence that the offset time of a note is much less salient than the onset time, especially for percussive instruments (including the piano) whose sound naturally decays over time [Klapuri and Davy, 2006]. Therefore, when we create our graphs from a musical score, we set the node order first by the absolute time of onset and then by pitch.

Once this ordering is set (and having defined an index function ind(·) that given a node returns its index in this ordering) we randomly sample a subgraph of size K > 1 from a piece with N notes, with the following procedure. If N > K we select the nodes u with ind(v) ≤ ind(u) ≤ ind(v) + N, where v is a random node which satisfies the inequality ind(v) < K - N. If N ≤ K we select all nodes in the piece. Note that we can still have the problem of segregating notes from the same chord, but this can now only happen at the temporal boundaries of our subgraph, limiting its impact on the network.

We can then create a batch consisting of B subgraphs of at most size N. Our batching mechanism uses the approach of Hamilton et al. [2017], i.e., all graphs are joined together in a single batched graph that will contain B disjoint subgraphs.

5.2 Datasets

We use four distinct datasets for our four tasks.

Voice Separation

The Graph Voice Separation dataset was introduced by Karystinaios et al. [2023]. This dataset contains graph data created from five collections: 370 Bach Chorales, 48 Preludes and 48 Fugues from the Bach Well-Tempered Clavier (Books I and II), 15 Bach Inventions, 15 Bach Sinfonias, and 210 movements from Haydn String Quartets. It contains in total 726, 246 nodes and 3, 408, 679 edges from 1, 054 unique score graphs. Karystinaios et al. only test on single collections to understand the differences in performance for different composing styles. To have a single general performance indicator, we introduce a new data split that uses 70% of the data for training, 10% for validation, and 20% for testing. This split preserves the percentage of pieces in each collection and is independent of the size of each score graph.

Composer Clasification

For composer classification, we use the scores from the DCML corpora dataset 1 . The dataset includes 10 composers, for a total of 419 scores, from where we build score graphs with collectively 710, 240 nodes and 3, 924, 655 edges. We create a random data split with 70% of the data for training, 10% for validation, and 20% for testing, which preserves the percentage of composers in each set.

Roman Numeral Analysis

The Roman numeral analysis dataset with data augmentation was introduced by Lopez et al. [2021]. We use their dataset (with augmentations on the train set). The created graphs collectively contain 8, 968, 413 nodes, 38, 390, 729 edges, and 5, 096, 853 unique onset positions from 7, 988 scores (after data augmentation).

1 https://github.com/DCMLab/dcml corpora

Cadence Detection

For the Cadence Detection task, we use four distinct annotated datasets, the Mozart Piano Sonatas [Hentschel et al., 2021], Haydn String Quartets [Sears et al., 2017], Mozart String Quartets [Allegraud et al., 2019], and Bach WTC Fugues [Giraud et al., 2015]. The created graph collectively contains 300, 602 nodes and 1, 392, 753 edges from 153 scores. We create a random data split with 70% of the data for training, 10% for validation, and 20% for testing.

6 Experiments

Our model for each of the four tasks is built on the respective current state-of-the-art model presented in Section 3. From here on forward, we refer to the previous state-of-the-art architecture as baseline model, and to the same architecture with the convolutional blocks replaced with our new ones, as MusGConv model. These original models serve as the baselines in the following experiment. We follow the implementations of the publicly available code with no major modifications, except for the sampling technique that we highlighted before. For each task, we consider the main evaluation metric proposed in the original paper (presented in Section 3).

All experiments for a certain task are run with the best hyperparameter setting specified in the respective papers; this includes 2 GNN layers, and the convolutional blocks being SageConv [Hamilton et al., 2017] for all tasks except the voice separation where ResGatedGraphConv [Bresson and Laurent, 2017] is used. We use a fixed training, validation, and test split for each task, and every experiment is run 10 times with different NN initialisations on a single GPU. We used one GTX 1080 Ti GPU with 11 GB of VRAM.

6.1 Main Results

The goal of our main experiment is to quantitatively verify whether the use of MusGConv can improve the results on the four tasks compared to the respective baseline, i.e., the architectures used in the corresponding state-of-the-art approaches. Each experiment is run 10 times with the fixed task-specific data split (as described in the previous section) and different random seeds. We report ASO significance [Del Barrio et al., 2018] with a confidence level α = 0.05 and ϵmin < 0.1.

The results, summarised in Table 1, show that MusGConv(+EF) produces statistically significant better results for the Voice Separation and Cadence Detection task. In the Composer Classification task, the best-performing model is MusGConv, while MusGConv(+EF) yields worse results than the baseline. We suspect that being this a global graph classification task, the edge features propagation is harder to train, and the simpler mechanism employed in MusGConv is a better choice. There is no statistically significant difference in the performance on the Roman Numeral Analysis task. We found two potential explanations for this behaviour: first, the RNA model is very complex, with multiple components which could hide the effect of a modification on the graph encoder. Moreover, the RNA dataset is augmented with transpositions in all keys, and therefore having transposition-invariant features may only yield minimal (if any) advantage. An experiment without augmentation is not possible, since the output of the RNA model depends on the absolute pitches at the input, and the not-augmented dataset is very small.

Regarding execution time, for each task, we compute the ratio between the average time of the 10 runs for baseline and the 10 runs with MusGConv and MusGConv(+EF). Aggregated across all tasks, this ratio has an average of 1 ± 0.05. Thus, the usage of MusGConv has a minimal impact on the final execution time.

6.2 Ablation Studies

We conduct four ablation studies to explore different model variations in terms of architecture and selection of edge features. The results are reported in Figure 5, where we also include the results for MusGConv and MusGConv(+EF) from our main experiment (see previous section) for comparison. For some variations we consider, there is not a clear winner, meaning that, while the usage of relative features as edges is beneficial overall, different versions of our system can perform better on different musical tasks.

No concatenation. We change the feature aggregation function ϕ (Eq. 2) from a concatenation (Eq. 8) to a multiplication, to mimic the operation used in convolutional blocks that deal with edge features, e.g., [Atzmon et al., 2018;

Wang et al., 2019a; Satorras et al., 2021]). The results show that this degrades the performance for the composer classification and cadence detection tasks while improving RN analysis and Voice Separation.

No Edge Input. In this study, we ignore our manually built edge features from Section 4.1 and use node feature difference (see Eq. 9) as edge features for all blocks (including the first). This is similar to the edge features employed in EdgeConv [Wang et al., 2019b] (though it has to be noted that our message passing is different from EdgeConv). This degrades the model performance on all tasks but RN.

No PCInt. We quantify the effect of the PCInt edge feature as a much more music-specific edge feature, compared to the "more standard" feature distances. We observe that the usage of this feature improves all tasks.

Signed Features. We evaluate the use of features obtained by removing the absolute value operation in Eq. 6. Indeed this is a more informative input; for example, with the absolute value we encode the difference between two note durations, but we lose the information about which is longer. On the other hand, it increases the input numerical range, and one could argue that the network already has access to absolute features, and PCInt and edge type encode similar information. The results show that using signed features is not beneficial.

7 Conclusion and FutureWork

This paper has presented a graph convolution block dedicated to music understanding tasks. Its working mechanism is inspired by perceptual considerations and permits the propagation of transposition-invariant and relative timing information in the message-passing process. More generally, our work enables an elegant and efficient way to use pairwise note features, which have been long studied and employed in monophonic music, for polyphonic music processing. Specifically, our approach can be summarized in two core contributions: pitch and time pairwise functions as edge features, and a new way of aggregating this information inside the convolutional block. The design of this block is kept simple to give us a performance advantage without increasing computation time. We experimentally verify the validity of our proposition on four rather diverse musical tasks covering three graph-related problems: graph classification, node classification, and link prediction.

As future work, it would be interesting to evaluate MusGConv on other kind of music and to investigate the impact of other pairwise note functions, like the one proposed in the cognitively plausible music model IDyOM [Pearce, 2018; Pearce, 2005].

Acknowledgements

This work was supported by the European Research Council (ERC) under the EU's Horizon 2020 research & innovation programme, grant agreement No. 101019375 (Whither Music?), and the Federal State of Upper Austria (LIT AI Lab).