MUSICNTWRK: data tools for music theory, analysis and composition

TL;DR

MUSICNTWRK is a comprehensive Python library offering tools for music theory analysis, network generation, deep learning-based timbre recognition, and data sonification, facilitating advanced music research and composition.

Contribution

It introduces a versatile, open-source Python toolkit integrating classification, network creation, deep learning, and sonification for music analysis and composition.

Findings

Provides algorithms for pitch class and rhythmic sequence classification

Enables generation of generalized music and sound networks

Includes deep learning models for timbre recognition

Abstract

We present the API for MUSICNTWRK, a python library for pitch class set and rhythmic sequences classification and manipulation, the generation of networks in generalized music and sound spaces, deep learning algorithms for timbre recognition, and the sonification of arbitrary data. The software is freely available under GPL 3.0 and can be downloaded at www.musicntwrk.com or installed as a PyPi project (pip install musicntwrk).

Figures

Equations

$$\text{distance}(I,J)=\sqrt{\sum _i{\left(x_i^I-x_i^J\right)}^2},$$

$$d(\mathbf{x},\mathbf{y})=\sqrt{\sum _i({\mathbf{x}}_i-{\mathbf{y}}_i{)}^2}$$

$$d_{\text{min}}(\mathbf{x},\mathbf{y})={\text{min}}_{{\text{TET}}_j}\sqrt{\sum _i({\mathbf{x}}_i-({\mathbf{y}}_j\pm {\text{TET}}_j){)}^2}$$

$$d(\mathbf{x},\mathbf{y})=\sqrt{\sum _i{n}_i^2}$$

$$\text{PSCC}={\left|F{T}^{-1}\left\{\log (|FT\{f(t)\right\}{|}^2)\right|}^2$$

Full text

1 Introduction

Big data tools have become pervasive in virtually every aspects of culture and society. In music, application of such techniques in Music Information Retrieval applications are common and well documented. However, a full approach to musical analysis and composition is not yet available for the music community and there is a need for providing a more general education on the potential, and the limitations, of such approaches. From a more fundamental point of view, the abstraction of musical structures (notes, melodies, chords, harmonic or rhythmic progressions, timbre, etc.) as mathematical objects in a geometrical space is one of the great accomplishments of contemporary music theory. Building on this foundation, we have generalized the concept of musical spaces as networks and derive functional principles of compositional design by the direct analysis of the network topology. This approach provides a novel framework for the analysis and quantification of similarity of musical objects and structures, and suggests a way to relate such measures to the human perception of different musical entities. The original contribution of this work is in the introduction of the representation of musical spaces as large-scale statistical mechanics networks: uncovering their topological structure is a fundamental step to understand their underlying organizing principles, and to unveil how classifications or rule-based frameworks (such as common-practice harmony, for instance) can be interpreted as emerging phenomena in a complex network system. Results from this research, the theoretical and technical foundation for this paper and some application of this techniques in composition and analysis can be found in Ref.  [1, 2, 3]. In the following we give the full API of the software library after summarizing some important definitions.

2 Background

Network analysis methods exploit the use of graphs or networks as convenient tools for modeling relations in large data sets. If the elements of a data set are thought of as nodes, then the emergence of pairwise relations between them, edges, yields a network representation of the underlying set. Similarly to social networks, biological networks and other well-known real-world complex networks, entire data-set of sound structures can be treated as a network, where each individual descriptor is represented by a node, and a pair of nodes is connected by a link if the respective two objects exhibit a certain level of similarity according to a specified quantitative metric. Pairwise similarity relations between nodes are thus defined through the introduction of a measure of distance in the network: a metric. In MUSICNTWRK we use the Euclidean norm (generalized Pythagoras theorem in N-dimensions) to quantify similarity between descriptors:

[TABLE]

where ${\bf x}$ is the chosen sound descriptor for sound $I$ and $J$. We specialize in the following the metric for the two major musical spaces in MUSICNTWRK and define two of the operators that are central to many of the algorithms in the MUSICNTWRK package:

Metric in the interval vectors space: the distance operator for interval vectors can be written as:

[TABLE]

where x and y are interval vectors of dimension INT(NC/2), where NC is the cardinality of the pcs (number of total pitches). This is a quantity that measures the change in the harmonic content of two pcs, and thus contains a quantification of the rules of harmony in arbitrary musical spaces. 2. 2.

Metric in the ordered pcs space (voice leading): the distance operator for pcs provides instead a quantification of voice leading, the study of the linear progression of individual melodic lines at the foundation of counterpoint. For this we use minimal Euclidean voice leading distance [1] for arbitrary TET-notes temperaments (12, 24, etc.):

[TABLE]

Here x and y are the pcs in normal order and TET=(0,0,$\dots$,0,$\pm$TET,0,$\dots$), a vector of dimension NC that raises or lowers the $j^{\textrm{th}}$ pitch of the ordered pcs by TET. It is easy to verify that this definition of distance operator is equivalent to finding the minimal distance between all possible cyclic permutations of the pcs. Such definition is easily extended to non-bijective voice-leadings, by an iterative duplication of pitches in the smaller cardinality pcs, and then looking for the multiset that produces the minimal distance. Note that, although we use eucledean distance throughout this discussion, the metric can be chosen by the user from the full palette of metrics available in sklearn through the distance variable.

From the definition of metrics above we can introduce two essential operators in the vector spaces of interval vectors or ordered pcs:

The distance operators: O({$n_{i}$}) as defined in MUSICNTWRK is an operator that raises or lowers by an integer $n$ the $i^{\textrm{th}}$ component of a vector. In the interval vector space, these are vector operators of dimension INT(NC/2); in the voice-leading space, they have dimension NC. With this definition, if x is transformed into y by O({$n_{i}$}), then:

[TABLE]

The distance operator defined above is assumed to be raising or lowering by the specified amount one of the pitches of the pcs (or components of interval vector (IV)) with no information on the positional ordering (i is left unspecified). As such it is a function that acts upon the vector of all the permutations of the input pcs. For instance, the voice leading operator, O(1) applied to the [0,4,7] pcs (C Maj chord) generates the following chords: [0, 3, 7] (C min), [0, 4, 6] (C incomplete half-diminished seventh), [0, 4, 8] (C augmented), [5, 7, 0] (F quartal trichord), [1, 4, 7] (C# diminished), [4, 7, 11] (E min). If the number of specified components is smaller than the cardinality of the pcs or the dimension of the IV, all unspecified components are assumed to be 0. 2. 2.

Based on the metric in voice leading space, we can introduce the normal-ordered voice leading operator VL(n), that given a normal-ordered pcs, transform it into the successive normal-ordered pcs in the chord progression. Here n is an ordered vector of positive or negative integers where each component represents the minimal number of steps that need to be applied to the corresponding pitches of the ordered pcs. So, for instance, VL(-1,-2,0) applied to [0,4,7] produces [7,11,2] (the I-V progression from the C major triad to its dominant in the key of C).***A full treatment of the mathematical properties of VL operators will be the subject of a forthcoming publication.

3 MUSICNTWRK

The MUSICNTWRK package (www.musicntwrk.com), is a python library written by the author and available as a PyPi project at www.pypi.org/project/musicntwrk/ or on GitHub: https://github.com/marcobn/musicntwrk. musicntwrk is the main module of the project and contains helper classes for pitch class set classification and manipulation in any arbitrary temperament (PCSet, PCSetR and PCSrow), RHYTHMSeq for the manipulation of rhythmic sequences, and the main class musicntwrk that allows the construction of generalized musical space networks using distances between common descriptors (interval vectors, voice leadings, rhythm distance, etc.); the analysis of scores, the sonification of data and the generation of compositional frameworks. musicntwrk acts as a wrapper for the various functions organized in the following sub-projects:

networks - contains all the modules to construct dictionaries and networks of pitch class set spaces including voice leading, rhythmic spaces, timbral spaces and score network and orchestarion analysis 2. 2.

data - sonification of arbitrary data structures, including automatic score (musicxml) and MIDI generation 3. 3.

timbre - analysis and characterization of timbre from a (psycho-)acoustical point of view. In particular, it provides: the characterization of sound using, among others, Mel Frequency or Power Spectrum Cepstrum Coefficients (MFCC or PSCC); the construction of timbral networks using descriptors based on MF- or PS-CCs 4. 4.

harmony - helper functions for harmonic analysis, design and autonomous scoring 5. 5.

ml_utils - machine learning models for timbre recognition through the TensorFlow Keras framework 6. 6.

plotting - plotting function including a module for automated network drawing 7. 7.

utils - utility functions used by other modules

MUSICNTWRK is written in python 3 and requires installation of the following dependencies (done automatically when pip install musicntwrk): †††this step might be unnecessary if running on a cloud service like Google Colaboratory.

System modules: sys, re, time, os 2. 2.

Math modules: numpy, scipy 3. 3.

Data modules: pandas, sklearn, networkx, python-louvain, tensorflow, powerlaw, ruptures, numba 4. 4.

Music and audio modules: music21, librosa, pyo, pydub 5. 5.

Visualization modules: matplotlib, vpython, PySimpleGUI 6. 6.

Parallelization modules: mpi4py (optional)

The reader is encouraged to consult the documentation of each package to get acquainted with its purposes and use. In particular, MUSICNTWRK relies heavily on the music21 package for all the music theoretical and musicological functions.[4] In what follows we provide the full API of MUSICNTWRK only. The display of musical examples in musicxml format requires the installation of a score app like MuseScore (https://musescore.org/). See Section 08 of the music21 documentation for a step by step guide of installing a musicxml reader.

Finally a full set of examples and application of the library for a variety of tasks can be downloaded from the MUSICNTWRK repository on GitHub. ‡‡‡https://github.com/marcobn/musicntwrk/tree/master/musicntwrk-2.0/examples

3.1 musicntwrk

The PCSet class.

The PCSet class deals with the classification and manipulation of pitch set classes generalized to arbitrary temperament systems (arbitrary number of pitches). The following methods are available:

def class PCSet

• •

def init(self,pcs,TET=12,UNI=True,ORD=True)

• –

pcs (int)  pitch class set as list or numpy array

• –

TET (int)  number of allowed pitches in the totality of the musical space (temperament). Default = 12 tones equal temperament

• –

UNI (logical)  if True, eliminate duplicate pitches (default)

• –

ORD (logical)  if True, sorts the pcs in ascending order (default)

• •

def normalOrder(self)

Order the pcs according to the most compact ascending scale in pitch-class space that spans less than an octave by cycling permutations.

• •

def normal0Order(self)

As normal order, transposed so that the first pitch is 0

• •

def T(self,t=0)

Transposition by t (int) units (modulo TET)

• •

def zeroOrder(self)

transposed so that the first pitch is 0

• •

def M(self,t=1)

multiply pcs by an arbitrary scalar mod. 12

• •

def multiplyBoulez(self,b)

pitch class multiplication of self * b according to P. Boulez

• •

def I(self)

inverse operation: (-pcs modulo TET)

• •

def primeForm(self)

most compact normal 0 order between pcs and its inverse

• •

def intervalVector(self)

total interval content of the pcs

• •

def LISVector(self)

Linear Interval Sequence Vector: sequence of intervals in an ordered pcs

• •

def Op(self,name)

operate on the pcs with a distance operator

• –

name (str)  name of the operator O(ni)

• •

def VLOp(self,name)

operate on the pcs with a normal-ordered voice-leading operator

• –

name (str)  name of the operator R(n0,n1,$...$,n${}_{N_{c}}$)

• •

def forteClass(self)

Name of pcs according to the Forte classification scheme (only for TET=12)

• •

def commonName(self)

Display common name of pcs (music21 function - only for TET=12)

• •

def commonNamePrime(self)

As above, for prime forms

• •

def commonNamePitched(self)

Name of chord with first pitch of pcs in normal order

• •

def displayNotes(self,xml=False,prime=False)

Display pcs in score in musicxml format. If prime is True, display the prime form.

• –

xml (logical)  write notes on file in musicxml format

• –

prime (logical)  write pcs in prime form

The PCSetR class.

The PCSetR class and its methods (listed below) parallels the PCSet class by adding recursive capabilities to it: in practice any method returns an instance of the class itself. This facilitates the construction of method chains for compositional or analytical tasks. The following methods are available:

def class PCSetR

• •

def init(self,pcs,TET=12,UNI=True,ORD=True)

• –

pcs (int)  pitch class set as list or numpy array

• –

TET (int)  number of allowed pitches in the totality of the musical space (temperament). Default = 12 tones equal temperament

• –

UNI (logical)  if True, eliminate duplicate pitches (default)

• –

ORD (logical)  if True, sorts the pcs in ascending order (default)

• •

def normalOrder(self)

Order the pcs according to the most compact ascending scale in pitch-class space that spans less than an octave by cycling permutations.

• •

def normal0Order(self)

As normal order, transposed so that the first pitch is 0

• •

def T(self,t=0)

Transposition by t (int) units (modulo TET)

• •

def M(self,t=1)

multiply pcs by an arbitrary scalar mod. 12

• •

def I(self)

inverse operation: (-pcs modulo TET)

• •

def multiplyBoulez(self,b)

pitch class multiplication of self * b according to P. Boulez

• •

def zeroOrder(self)

transposed so that the first pitch is 0

• •

def inverse(self,pivot=0) invert pcs around a pivot pitch

• •

def primeForm(self)

most compact normal 0 order between pcs and its inverse

• •

def intervalVector(self)

total interval content of the pcs

• •

def LISVector(self)

Linear Interval Sequence Vector: sequence of intervals in an ordered pcs

• •

def Op(self,name)

operate on the pcs with a distance operator

• –

name (str)  name of the operator O(ni)

• •

def VLOp(self,name)

operate on the pcs with a normal-ordered voice-leading operator

• –

name (str)  name of the operator R(n0,n1,$...$,n${}_{N_{c}}$)

• •

def NROp(self,ops=None)

operate on the pcs with a Neo-Rienmanian operator

• –

ops (str)  name of the operator, P, L or R

• •

def opsNameVL(self,b,TET=12)

given a pcs returns the name of the normal-ordered voice-leading operator R that connects self to it

• •

def opsNameO(self,b,TET=12)

given a pcs returns the name of the distance operator O that connects self to it

The PCSrow class.

PCSrow is a helper class for 12-tone rows operations (T,I,R,M,Q)

def class PCSrow

• •

def init(self,pcs,TET=12)

• –

pcs (int)  12 tone row as list or numpy array

• •

def normalOrder(self)

Transpose the row so that first pitch class is 0

• •

def intervals(self)

vector of intervals of the row

• •

def T(self,t=0)

Transposition by t (int) units (modulo TET)

• •

def I(self)

inverse operation: (-pcs modulo TET)

• •

def R(self,t=1)

Retrograde plus transposition by t (int) units (modulo TET)

• •

def M(self,t=1)

Multiplication by t (int) units (modulo TET)

• •

def Q(self,t=1)

cyclic permutation of stride 6 so that the result is an All Interval Series in normal form

• •

star(self)

star of the row in prime form

• •

def constellation(self)

constellation of the row

The RHYTHMSeq class.

The RHYTHMSeq class and its methods (listed below) encode various functions for rhythmic network manipulations. The RHYTHMSeq class deals with the classification and manipulation of rhythmic sequences. The following methods are available:

def class RHYTHMSeq

• •

init( self,rseq,REF=’e’,ORD=False)

• –

rseq (str/fractions/floats)  rhythm sequence as list of strings or fractions or floats

• –

REF (str)  reference duration for prime form – the RHYTHMSeq class contains a dictionary of common duration notes that uses the fraction module for the definitions (implies import fraction as fr):

{’w’: fr.Fraction(1,1), ’h’: fr.Fraction(1,2),’q’: fr.Fraction(1,4), ’e’: fr.Fraction(1,8), ’s’: fr.Fraction(1/16),’t’: fr.Fraction(1,32), ’wd’: fr.Fraction(3,2), ’hd’: fr.Fraction(3,4),’qd’: fr.Fraction(3,8), ’ed’: fr.Fraction(3,16), ’sd’: fr.Fraction(3,32),’qt’: fr.Fraction(1,6), ’et’: fr.Fraction(1,12), ’st’: fr.Fraction(1,24), ’qq’: fr.Fraction(1,5), ’eq’: fr.Fraction(1,10), ’sq’: fr.Fraction(1,20)}.

This dictionary can be extended by the user on a case by case need.

• –

ORD (logical)  if True sort durations in ascending order

• •

def normalOrder(self)

Order the rhythmic sequence according to the most compact ascending form.

• •

def augment(self,t=’e’)

Augmentation by t units

• –

t (str)  duration of augmentation

• •

def diminish(self,t=’e’)

Diminution by t units

• –

t (str)  duration of diminution

• •

def retrograde(self)

Retrograde operation

• •

def isNonRetro(self)

Check if the sequence is not retrogradable

• •

def primeForm(self)

reduce the series of fractions to prime form

• •

def durationVector(self,lseq=None)

total relative duration ratios content of the sequence

• –

lseq (list of fractions)   reference list of duration for evaluating interval content; the default list is:

fr.Fraction(1/8), fr.Fraction(2/8), fr.Fraction(3/8), fr.Fraction(4/8), fr.Fraction(5/8), fr.Fraction(6/8), fr.Fraction(7/8), fr.Fraction(8/8), fr.Fraction(9/8)

• •

def durationVector(self,lseq=None)

inter-onset duration interval content of the sequence

• –

lseq (list of fractions)   reference list of duration for evaluating interval content; the default list is the same as above.

The musicntwrk class

Defines wrappers around calls to the main functions of the different packages. The variables passed in the defs are used to call the specific function requested. See documentation of the functions in the separate sections.

• •

def dictionary(self, space=None, N=None, Nc=None, order=None, row=None, a=None, prob=None, REF=None, scorefil=None, music21=None, show=None)

define dictionary in the musical space specified in ’space’. All other variables are as defined in pcsDictionary, rhythmDictionary, orchestralVector, and scoreDictionary, in Sec. 3.2 depending on the choice of ’space’

• –

space (string)  = ’pcs’, pitch class sets dictionary; ’rhythm’ or ’rhythmP’, rhythm dictionaries; ’score’, score dictionary; and ’orch’ orchestral vector.

*Returns

*See description in Sec. 3.2 for individual functions.

• •

def network(self, space=None, label=None, dictionary=None, thup=None, thdw=None, thup_e=None, thdw_e=None, distance=None, prob=None, write=None, pcslabel=None, vector=None, ops=None, name=None, ntx=None, general=None, seq=None, sub=None, start=None, end=None, grphtype=None, wavefil=None, cepstrum=None, color=None)

define networks in the musical space specified in ’space’:

• –

space (string)  = ’pcs’, pitch class sets network, both full and ego network from a given pcs; ’rhythm’ or ’rhythmP’, rhythm dictionaries (see below for details); ’score’, score dictionary; and ’orch’ orchestral vector. See description in Sec. 3.2.

*Returns

*See description in Sec. 3.2 for individual functions.

• •

def timbre(self, descriptor=None, path=None, wavefil=None, standard= None, nmel=None, ncc=None, zero=None, lmax=None, maxi= None, nbins = None, method=None, scnd=None, nstep=None)

Define sound descriptors for timbral analysis: MFCC, PSCC ASCBW in regular or standardized form. See description of variables in Sec. 3.3.

• •

def harmony(self,descriptor=None,mode=None,x=None,y=None)

handler for calculating tonal harmony models, tonnentz and to launch the tonal harmony calculator. See description of variables in Sec. 3.6.

• •

def sonify(self, descriptor=None, data=None, length=None, midi=None, scalemap=None, ini=None, fin=None, fac=None, dur=None, transp=None, col=None, write=None, vnorm=None, plot=None, crm=None, tms=None, xml=None)

sonification strategies - simple sound (spectral) or score (melodic progression). See description of variables in Sec. 3.5

3.2 networks

networks contains specific functions for network generation and analysis in different musical spaces.

Networks of pitch class sets

• •

def pcsDictionary(Nc,order=0,TET=12,row=False,a=None)

Generate the dictionary of all possible pcs of a given cardinality in a generalized musical space of TET pitches. Returns the dictionary as pandas DataFrame and the list of all Z-related pcs

• –

Nc (int)  cardinality

• –

order (logical)  if 0 returns pcs in prime form, if 1 retrns pcs in normal order, if 2, returns pcs in normal 0 order

• –

row (logical)  if True build dictionary from tone row, if False, build dictionary from all combinatorial pcs of Nc cardinality given the totality of TET.

• –

a (int)  if row = True, a is the list of pitches in the tone row

Returns

• –

dictionary (pandas dataframe object)  dictionary as dataframe (name, pitch class set, interval vector)

• –

ZrelT (list of strings)  pitch class sets that have a Z-relation

• •

def pcsNetwork(input_csv, thup= 1.5, thdw=0.0,TET=12, distance=

’euclidean’, col=2,prob=1)

generate the network of pcs based on distances between interval vectors

In output it writes the nodes.csv and edges.csv as separate files in csv format

• –

input_csv (str)  file containing the dictionary generated by pcsNetwork

• –

thup, thdw (float)  upper and lower thresholds for edge creation

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

• –

col (int)  metric based on interval vector, col = 1 can be used for voice leading networks in spaces of fixed cardinality (OBSOLETE)

• –

prob (float)  if not 1, defines the probability of acceptance of any given edge

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

• •

def pcsEgoNetwork(label, input_csv, thup_e=5.0, thdw_e=0.1, thup= 1.5, thdw=0.1, TET=12, distance=’euclidean’)

Generates the network for a focal node (ego) and the nodes to whom ego is directly connected to (alters). In output it writes the nodes_ego.csv, edges_ego.csv and edges_alters.csv as separate files in csv format

• –

label (str)  label of the ego node

• –

thup_e, thdw_e (float)  upper and lower thresholds for edge creation from ego node

• –

thup, thdw (float)  upper and lower thresholds for edge creation among alters

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

Returns

• –

nodes(ego), edges(ego), edges(alters) (pandas dataframe objects)  dataframes of nodes and edges of the ego network

• •

def vLeadNetwork(input_csv,thup=1.5,thdw=0.1,TET=12,w=True,

distance=’euclidean’,prob=1)

Generation of the network of all minimal voice leadings in a generalized musical space of TET pitches - based on the minimal distance operators - select by distance. In output returns nodes and edges tables as pandas DataFrames.

• –

input_csv (str)  file containing the dictionary generated by pcsNetwork

• –

thup, thdw (float)  upper and lower thresholds for edge creation

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

• –

w (logical)  if True it writes the nodes.csv and edges.csv files in csv format

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

• •

def vLeadNetworkByName(input_csv, thup=1.5, thdw=0.1, TET=12, w=True, distance= ’euclidean’, prob=1)

Generation of the network of all minimal voice leadings in a generalized musical space of TET pitches - based on the minimal distance operators - select by name. In output returns nodes and edges tables as pandas DataFrames. Available also in vector form for computational efficiency as vLeadNetworkByNameVec

• –

input_csv (str)  file containing the dictionary generated by pcsNetwork

• –

name (str)  name of operator for edge creation

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

• –

w (logical)  if True it writes the nodes.csv and edges.csv files in csv format

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

Score networks

• •

def scoreNetwork(seq, ntx, general, distance, TET)

Generates the directional network of chord progressions from any score in musicxml format, See Figure 1 for an illustration.

• –

seq (int)  list of pcs for each chords extracted from the score

• –

ntx (logical)  if True produces the network (directed and undirected) as a networkx graph object

• –

general (logical)  if True classifies the chord progressions with the voice-leading operators, else with the distance operators

• –

distance (string)  defines the metric using the definitions in sklearn.

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

• –

counts (list of integers)  number of occurrences for each chord (histogram)

• –

avgdeg, modul (floats)  if ntx = True: average degree and modularity

• –

Gx, Gxu (networkx graph objects)  if ntx = True: directed and undirected graph as networkx objects

• •

def scoreSubNetwork(seq, start, end, ntx, general, distance, TET)

Generates the directional sub- network of chord progressions from a range of pcs in the sequence defined by start and stop (int). All other variables as above. It returns the sub-network in the same format as above..

• •

def scoreDictionary(seq, TET=12)

Builds the dictionary of pcs in any score in musicxml format

• –

seq (list of lists)  list of the pitch class set sequence (from readScore)

Returns

• –

dictionary (pandas dataframe object)  dictionary as dataframe (name, pitch class set, interval vector)

• •

def readScore(inputxml,TET=12,music21=False)

Reads musicxml score and returns chord sequence

• –

inputxml (str)  score file

• –

music21 (logical)  if True search the music21 corpus

Returns

• –

seq (list of lists)  list of the pitch class set sequence

• –

chords (music21 chord object)  list of the chord sequence as extracted by music21

Rhythm networks

• •

def rhythmDictionary(Nc,a=None,REF=’e’)

Generates the dictionary of all possible rhythmic sequences of Nc length in a generalized meter space of N durations. Returns the dictionary as pandas DataFrame and indicates all non retrogradable and Z-related cells

• –

Nc (int)  cell length

• –

a (str)  list of durations in the rhythm sequence

Returns

• –

dictionary (pandas dataframe object)  dictionary as dataframe (name, rhythm sequence, duration vector)

• –

ZrelT (list of strings)  rhythm sequences that have a Z-relation

• •

def rhythmPDictionary(N,Nc,REF=’e’)

Generate the dictionary of all possible rhythmic sequences from all possible groupings of N REF durations. Returns the dictionary as pandas DataFrame and indicates all non retrogradable and Z-related cells

• –

Nc (int)  cell length

• –

N (int)  number of REF units

*Returns

*As above.

• •

def rhythmNetwork(input_csv, thup=1.5, thdw=0.0, distance= ’euclidean’, prob=1, w=False)

Generates the network of rhythmic cells based on distances between duration vectors. In output it writes the nodes.csv and edges.csv as separate files in csv format

• –

input_csv (str)  file containing the dictionary generated by rhythmNetwork

• –

thup, thdw (float)  upper and lower thresholds for edge creation

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

• –

prob (float)  if not 1, defines the probability of acceptance of any given edge

• –

w (logical)  if True it writes the nodes.csv and edges.csv files in csv format

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

• •

def rLeadNetwork(input_csv, thup=1.5, thdw=0.1, w=True, distance= ’euclidean’, prob=1)

Generation of the network of all minimal rhythm leadings in a generalized musical space of NC-dim rhythmic cells based on the rhythm distance operator. Returns nodes and edges tables as pandas DataFrames

• –

input_csv (str)  file containing the dictionary generated by rhythmNetwork

• –

thup, thdw (float)  upper and lower thresholds for edge creation

• –

distance (str)  choice of norm in the musical space, default is ’euclidean’

• –

prob (float)  if not 1, defines the probability of acceptance of any given edge

• –

w (logical)  if True it writes the nodes.csv and edges.csv files in csv format

*Returns

*As above.

Orchestration networks

• •

def orchestralVector(inputfile,barplot=True)

Builds the orchestral vector sequence from score in musicxml format. Returns the score sliced by beat; orchestration vector.

• –

barplot=True  plot the orchestral vector sequence as a matrix

Returns

• –

score (music21 object)  score sliced by beat

• –

orch (list of lists)  orchestral vectors for every beat (in binary format: 1 if instrument is playin, 0 if not)

• –

num (list)  beat vector identifier (integer corresponding to the binary number encoded in the orchestral vector)

• •

def orchestralNetwork(seq)

Generates the directional network of orchestration vectors from any score in musicxml format. Use orchestralVector to import the score data as sequence. Returns nodes and edges as Pandas DataFrames; average degree, modularity and partitioning of the network.

• –

seq (int)  list of orchestration vectors extracted from the score

*Returns

*As scoreNetwork.

• •

def orchestralVectorColor(orch, dnodes, part, color=plt.cm.binary)

Plots the sequence of the orchestration vectors color-coded according to the modularity class they belong. Requires the output of orchestralNetwork(). See Figure 2

• –

orch (int)  list of orchestration vectors extracted from the score

• –

dnodes (pandas dataframe object)  dataframe of nodes of the network (for labelling)

• –

part (list of int)  list of partitions for orchestration vectors

Timbral networks

• •

def timbralNetwork(waves,vector,thup=10,thdw=0.1)

generates the network of MFCC vectors from sound recordings. Returns the nodes and edges tables as pandas DataFrames

• –

seq (float)  list of MFCC vectors

• –

waves (str)  names of sound files

Returns

• –

nodes, edges (pandas dataframe objects)  dataframe of nodes and edges of the network

See Sec. 3.3 for a full discussion on the timbre modules.

3.3 timbre

timbre contains all the modules that deal with analysis and characterization of timbre from a (psycho-)acoustical point of view and provides the characterization of sound using, among others, Mel Frequency or Power Spectrum Cepstrum Coefficients (MFCC or PSCC) that can be used in the construction of timbral networks using these descriptors

Sound classification.

The sound classification section, timbre, comprises of modules for specific sound analysis that are based on the librosa python library for audio signal processing. We refer the interested reader to the librosa documentation at https://librosa.github.io/librosa/index.html. For a more complete discussion on the descriptors defined in MUSICNTWRK please refer to the work in Ref.  [5].

Audio descriptors and metrics in the generalized timbre space.

The Power Cepstrum of a signal gives the rate of change of the envelope of different spectrum bands and is defined as the squared magnitude of the inverse Fourier transform of the logarithm of the squared magnitude of the Fourier transform of a signal:

[TABLE]

MUSICNTWRK defaults to the first 13 cepstrum coefficients (PSCC), where the 0th coefficient corresponds to the power distribution of the sound over time. The number of coefficient can be controlled by the user.

The Mel Frequency Cepstrum of a signal is obtained as in the equation for the PSCC and differ from the power cepstrum by the choice of the spectrum bands that are mapped over the Mel scale using triangular overlapping windows. The mapping of the frequency bands on the Mel scale better approximates the human auditory system’s response than the linearly-spaced frequency bands used in the normal cepstrum. MUSICNTWRK defaults to 16 bands Mel filter. As for the PSCC, the 0-th coefficient corresponds to the power distribution of the sound over time. Both PSCC and MFCC are obtained using 64 bins in the short time Fourier transform (default).

As an illustration, in Figure 3 we show the network of the MFCC built from 1620 sounds produced by either wooden or metallic objects that were analyzed by a deep learning model trained on a perceptually salient acoustic descriptor or on a signal descriptor based on the energy contents of the signal for a study on automatic timbre characterization.[5] In the figure we display the principal component of the timbral network for which less than 2% of all possible edges are built, that is, we allow an edge only if two MFCCs are at a distance that is less than 3% of the maximum diameter of the network. This representation reveals that the classification is coherent with material categories, as it can be observed from the emergence of clusters of sounds belonging to the same material (see for instance the green cluster of wood sounds on the lower left part of the network and the cyan, pink and orange clusters of metallic sounds in the upper part). This result validates the corpus with respect to the sound quality.

• •

def computeMFCC(input_path,input_file,barplot=True,zero=True)

read audio files in repository and compute a normalized MEL Frequency Cepstrum Coefficients and single vector map of the full temporal evolution of the sound as the convolution of the time-resolved MFCCs convoluted with the normalized first MFCC component (power distribution). Returns the list of files in repository, MFCC0, MFCC coefficients.

• –

input_path (str)  path to repository

• –

input_file (str)  filenames (accepts "*")

• –

barplot (logical)  plot the MFCC0 vectors for every sound in the repository

• –

zero (logical)  If False, disregard the power distribution component.

Returns

• –

waves (list of strings)  filenames of the .wav files in the repository

• –

mfcc0 (list)  vector of MFCC0 (MFCC with DC component taken out)

• –

mfcc (list)  vector of MFCC (full MFCC)

• •

def computePSCC(input_path,input_file,barplot=True,zero=True)

Reads audio files in repository and compute a normalized Power Spectrum Frequency Cepstrum Coefficients and single vector map of the full temporal evolution of the sound as the convolution of the time-resolved PSCCs convoluted with the normalized first PSCC component (power distribution). Returns the list of files in repository, PSCC0, PSCC coefficients. Other variables and output as above.

• •

def computeStandardizedMFCC(input_path,input_file,nmel=16,

nmfcc=13,lmax=None,nbins=None)

read audio files in repository and compute the standardized (equal number of samples per file) and normalized MEL Frequency Cepstrum Coefficient. Returns the list of files in repository, MFCC coefficients, standardized sample length.

• –

nmel (int)  number of Mel bands to use in filtering

• –

nmfcc (int)  number of MFCCs to return

• –

lmax (int)  max number of samples per file

• –

nbins (int)  number of FFT bins

*Returns

*As above.

• •

def computeStandardizedPSCC(input_path,input_file,nmel=16,

psfcc=13,lmax=None,nbins=None)

read audio files in repository and compute the standardized (equal number of samples per file) and normalized Power Spectrum Frequency Cepstrum Coefficients. Returns the list of files in repository, PSCC coefficients, standardized sample length.

Variables defined as for MFCCs. *Returns

*As above.

3.4 Machine Learning Models (ml_utils)

The definition of machine learning models for sound recognition requires standard techniques of data science (like the separation of data entries in training and testing sets, definition of neural network architectures, etc.) that will not be discussed here. Basic knowledge of Keras is also assumed. ml_utils contains many auxiliary functions to deal with such tasks. We implemented a deep learning model based on convolutional neural network (CNN) architecture inspired by similar approaches used in image and sound recognition [8]. The CNN is built using the Keras kernel of Tensorflow [9] and it is trained on the full PSCC or MFCC data, after proper scaling and normalization. We retained only models with validation accuracy higher than 90%. After an appropriate model is chosen, it is tested on the set initially chosen for the human perception experiment. Each model chosen retains a similar accuracy on this set. A typical result of a training session on 30 epochs is shown in Fig. 5. Here we limit to report the API for the main machine learning functions and refer the user to the full example available of GitHub:

• •

def trainNNmodel(mfcc, label, gpu=0, cpu=4, niter=100, nstep = 10, neur = 16, test=0.08, num_classes=2, epoch=30, verb=0, thr=0.85, w=False)

train a 2 layer neural network model on the ful MFCC spectrum of sounds. Returns: model,training and testing sets,data for re-scaling and normalization,data to asses the accuracy of the training session.

• –

mfcc (float)  list of all the MFCCs (or PSCCs) in the repository

• –

gpu, cpu (int)  number of GPUs or CPUs used for the run

• –

niter (int)  max number of model fit sessions

• –

nstep (int)  how often the training and testing sets are redefined

• –

neur (int)  number of neurons in first layer (it is doubled on the second layer

• –

test (float)  defines the relative size of training and testing sets

• –

num_classes=2 (int)  dimension of the last layer

• –

epoch (int)  number of epochs in the training of the neural network

• –

verb (int)  verbose - print information during the training run

• –

thr (float)  keep the model if accuracy is > test

• –

w (logical)  write model on file if accuracy is above thr

• •

def trainCNNmodel(mfcc, label, gpu=0, cpu=4, niter=100, nstep=10, neur=16, test=0.08, num_classes=2, epoch=30, verb=0, thr=0.85, w = False)

train a convolutional neural network (CNN) model on the full MFCC/PSCC spectrum of sounds. Returns: model,training and testing sets,data for re-scaling and normalization,data to asses the accuracy of the training session.

Parameters are defined as above.

For a complete description and example see the notebook on GitHub.

3.5 data

data contains functions for the sonification of data in multi-column or csv format and produces output as WAV either via csound (it requires an installation of csound and direct reference to the ctcsound module), pyo or pure python, and musicxml or MIDI. Two sonification protocols are available: spectral - data are mapped to a single sound using subtractive synthesis (FIR filter); and linear - individual data points are mapped to pitches in a time-series structure. See Ref.  [6, 7] for a complete description of this protocol. data contains:

• •

def r_1Ddata(path,fileread)

Read data file in a multicolumn format (csv files can be easily put in this format using Pandas). Returns the data values as (x,y).

• –

path (str)  path to data file

• –

fileread (str)  data file

• •

def i_spectral2(xv,yv,itime,path=’./’,instr=’noise’)

Use subtractive synthesis to sonify data structure. Returns the sound file.

• –

xv,yv (float)  data structure to sonify

• –

path (str)  path to data file

• –

fileread (str)  data file

• •

def i_time_series(xv,yv,path=’./’,instr=’csb701’)

Use csound instruments to sonify data structures as time-series. Returns the sound file.

• –

xv,yv (float)  data structure to sonify

• –

path (str)  path to data file

• –

fileread (str)  data file

• –

instr (str)  csound instrument (it can be modified by user)

• •

def MIDImap(pdt,scale,nnote)

Data to MIDI conversion on a given scale defined in scaleMapping (see below). Returns the MIDI data structure.

• –

pdt (float)  data structure mapped to MIDI numbers

• –

scale (float)  scale mapping (from scaleMapping)

• –

nnote (int)  number of notes in the scale (from scaleMapping)

• •

def scaleMapping(scale)

Scale definitions for MIDI mapping. Returns: scale, nnote (see above).

• •

def MIDIscore(yvf,dur=2,w=None,outxml=’./music’,outmidi=’./music’)

Display score or writes to file

• –

yvf (float)  data structure mapped to MIDI numbers (from MIDImap)

• –

dur (int)  reference duration

• –

w (logical)  if True writes either musicxml or MIDI file)

• •

def MIDImidi(yvf,vnorm=80,dur=4,outmidi=’./music’)

Display score or writes to file

• –

yvf (float)  data structure mapped to MIDI numbers (from MIDImap)

• –

vnorm (int)  reference velocity

• –

outmidi (str)  MIDI file

3.6 harmony

Utilities for harmonic analysis, design and autonomous scoring

See example in the notebooks on GitHub and Ref. [2] for possible uses of the modules contained here.

Harmonic analysis functions:

• •

def scoreFilter(seq,chords,thr=0,plot=False)

filter out low recurring chords to facilitate change point detection and score partitioning in regions. Needs the output of readScore

• –

seq (int)  list of pcs for each chords extracted from the score

• –

chords (music21 object)  chords as extracted by music21

Returns

• –

value, valuef (int)  integer identifier for the full and filtered chord sequence

• –

filtered (int)  sequence of filtered chords (by identifier as defined above)

• –

fmeasure (int)  measure number to which the filtered chord belongs

• •

def changePoint(value, vmodel=’rbf’, penalty=1.0, vbrakepts=None, plot = False)

run a change point detection algorithm to isolate sections on the filtered score. Uses the implementation in ruptures.

• –

value (int)  list of pcs for each chords as extracted from scoreFilter

• –

other variables documentation for the other variables at https://pypi.org/project/ruptures/

Returns

• –

sections (list of int)  list of breakpoints in the score sectioning (by position in the filtered chord sequence)

• •

def keySections(sections, GxsecDi, dnodes)

region key identification

• –

sections (int)  list of region identified by the

changePoint algorithm

• –

GxsecDi (networkx graph object)  score sub-network as computed by scoreSubNetwork

• –

dnodes (pandas dataframe)  dataframe of node label of the full score network

Returns

• –

key (string)  key associated with given chord in the sequence as identified by a "prevalent chord" algorithm

• –

keySections (pandas dataframe)  dataframe that summarizes the key analysis results by ’section’,’chord range’,’prevalent_chord’,’region’

• •

def tonalAnalysis(chords, sections, key, enharm=[[’C’,’C’]], write=None)

roman numeral analysis of regions in the full score

• –

sections (int)  see above

• –

chords (music21 object)  see above

• –

key (string)  see above

• –

enharm (list of strings)  optional enharmonic table for pitch respelling

Returns

• –

analysis (pandas dataframe)  dataframe that summarizes the full analysis of the score, including roman numerals - the results can be visualized in musicxml format if write = True.

Harmonic design functions and autonomous scoring

• •

def chinese_postman(graph, starting_node)

solve the optimal routing problem of the Chinese postman on an assigned network

• –

graph (networkx graph object)  graph on which to find the optimal path

• –

starting_node (int)  node from where to start the path

Returns

• –

graph (networkx graph object)  directed graph with optimal path (used in harmonicDesign

• •

def networkHarmonyGen(mk, descriptor=None, dictionary=None, thup= None, thdw=None, names=None, distance=None, probs=None, write= None, pcslabel=None)

probabilistic chord distribution based on geometric distances. It is a wrapper around the modules in networks. See the discussion in Sec. 3.2 for the description of the variables. Only additions are:

• –

names (list of strings)  list of operators to slice the network of pitches using vLeadNetworkByName

• –

probs (list of floats)  list of probabilities to slice the network of pitches using vLeadNetwork by distance

Returns

• –

nodes, edges (pandas dataframe)  nodes and edges of the generated network

• •

def harmonicDesign(mk, nnodes, nedges, refnodes, refedges, nstart = None, seed=None, reverse=None, display=None, write= None)

generate a scale-free network according to the Barabasi-Albert model of preferential attachment and assign chords to nodes using the output of networkHarmonyGen

• –

mk (musicntwrk class)

• –

nnodes, nedges (int)  number of nodes and edges per node used to generate the scale free network using networkx.barabasi_albert_graph. See documentation on networkx for details.

• –

nodes, edges (pandas dataframe)  nodes and edges of the network generated by networkHarmonyGen

Returns

• –

pitches (list of lists of int)  chord sequence of the generated network. If display = True it draws the graph, if write = True it writes the sequence as musicxml.

• •

def rhythmicDesign(dictionary, nnodes, nedges, refnodes, refedges, nstart = None, seed=None, reverse=None, random=None)

builds a scale-free network according to the Barabasi-Albert model of preferential attachment and assign rhythmic figures to nodes. Details as above using the result of any of the rhythm network generation function of Sec. 3.2.

• –

durations (list of lists of int)  duration sequence of the generated network.

• •

def scoreDesign(pitches, durations, fac=1, TET=12, write=False)

using the sequences of pitches and rhythms from the above, generate a score in musicxml

Helper functions

• •

def tonalHarmonyCalculator()

multi-function harmony calculator: pitches, roman numerals, voice leading operations and more. See the in app HELP for a description of usage.

• •

def tonalHarmonyModel(mode=’minimal’)

build a minimal harmony model based on voice leading operators (to be used in the calculator)

• •

def tonnentz(x,y)

build the tonnentz for the specified x,y relation

3.7 Plotting and general utility functions

There are many utility functions (in utils) that are used by other modules and that should be transparent to the average user. We recall here only the ones that are used for computing distances in pitch space, since they relate directly to the discussion of Sec. 2:

• •

def minimalNoBijDistance(a, b, TET, distance)

calculates the minimal distance between two pcs of different cardinality (non bijective)

• –

a,b (int)  pcs as lists or numpy arrays

• –

distance (str)  choice of norm in the musical space

Returns

• –

dist (float)  minimal distance

• –

r (array of int)  multiset corresponding to minimal distance

• •

generalizedOpsName(a,b,TET,distance)

finds the voice leading operator that connects two pcs (also for non bijective transformations)

• –

a,b (int)  pcs as lists or numpy arrays

• –

distance (str)  choice of norm in the musical space

Returns

• –

r (array of int)  multiset corresponding to minimal distance

• –

Op (string)  VL operator that connects the two pcs

Finally, it is worth mentioning the network plotting utility drawNetwork in plotting:

• •

drawNetwork(nodes, edges, forceiter=100, grphtype=’undirected’, dx = 10, dy=10, colormap=’jet’, scale=1.0, drawlabels=True, giant=False)

draws the network using networkx and matplotlib

• –

nodes, edges (pandas dataframe)  nodes and edges of the network

• –

forceiter (floats)  iterations in the networks force layout

• –

grphtype (string)  ’directed’ or ’undirected’

• –

dx, dy (floats)  dimensions of the canvas

• –

colormap (string)  colormap for plt.get_cmap(colormap)

• –

scale (float)  scale factor for node radius

• –

drawlabels (logical)  draw labels on nodes

• –

giant (logical)  if True draws only the giant component of the network

The most computationally intensive parts of the modules can be run (optionally) on parallel processors using the MPI (Message Passing Interface) protocol. Communications are handled by two additional modules: communications and

load_balancing. Since the user will never have to interact with these modules, we omit here a detailed description of their functions.

4 Conclusions and acknowledgments

We have presented the API for the MUSICNTWRK software package. The software is freely available under GPL 3.0 and can be downloaded from GitHub and at www.musicntwrk.com, or installed directly via pip install musicntwrk. We acknowledge the support of Aix-Marseille University, IMéRA, and of Labex RFIEA+. It must be understood that MUSICNTWRK is a continuously evolving library, so it is likely that at the time of publication of this paper more functionalities will be available. We invite the reader to explore the GitHub distribution that will always provide the most recent version of the software. Finally, we thank Richard Kronland-Martinet, Sølvi Ystad, Mitsuko Aramaki, Jon Nelson, Joseph Klein, Scot Gresham-Lancaster, David Bard-Schwarz, Roger Malina and Alexander Veremyer for useful discussions.