Analyzing Musical Scores and Identifying Motifs: A Computational Approach

Introduction

Musical motifs—short, recurring melodic patterns—are fundamental building blocks of musical composition. From classical sonatas to traditional folk music, motifs serve as the DNA of musical works, creating coherence, development, and narrative structure. In computational musicology, identifying and analyzing these motifs programmatically opens up new possibilities for understanding musical structure, style, and evolution.

In this post, we’ll explore a comprehensive approach to analyzing musical scores and identifying motifs using Python and the music21 library. This methodology forms the foundation of research into Arab-Andalusian music patterns, but the techniques are broadly applicable to any musical tradition.

Understanding Motifs in Music

Before diving into the code, let’s clarify what we mean by “motifs” in a computational context:

Melodic Motifs: Sequences of pitches that recur throughout a piece
Rhythmic Motifs: Patterns of note durations
Contour Motifs: Patterns of pitch direction (up, down, same)

For this analysis, we focus on melodic motifs—sequences of pitches that appear multiple times, potentially in different octaves or with slight variations. These patterns can reveal:

Structural organization of a piece
Thematic development and variation
Stylistic characteristics of a musical tradition
Relationships between different sections or movements

The Analysis Pipeline

Our approach follows a clear pipeline:

Load the Score: Parse MusicXML files into a structured format
Extract the Melody: Isolate the melodic line from the full score
Identify Motifs: Find recurring patterns of specified lengths
Visualize Results: Create plots showing motif occurrences

Let’s examine each step in detail.

Function 1: Loading Musical Scores

def load_score(file_path: Path | str) -> music21.stream.Score:
    logger.info(f"Loading score from {file_path}")
    try:
        score = music21.converter.parse(str(file_path))
        logger.info(f"Successfully loaded score with {len(score.parts)} parts")
        return score
    except Exception as e:
        logger.error(f"Failed to load score: {str(e)}")
        raise

What This Function Does

The load_score function is our entry point into the musical score. It takes a file path (either a Path object or string) and returns a music21.stream.Score object—a rich data structure representing the entire musical work.

Key Concepts

MusicXML is a standard format for representing musical notation in XML. It’s widely supported by music notation software (Finale, Sibelius, MuseScore) and provides a structured way to encode:

Notes and their pitches
Rhythmic values
Dynamics and articulations
Structural elements (measures, parts, etc.)

music21 is a powerful Python toolkit for computer-aided musicology. It can parse MusicXML, MIDI, ABC notation, and other formats, providing a unified interface for musical analysis.

Why Logging Matters

Notice the logging statements throughout the function. In computational musicology workflows, you might process hundreds of scores. Logging helps you:

Track progress through large datasets
Debug issues with specific files
Understand the structure of loaded scores (number of parts, measures, etc.)

Error Handling

The function uses try-except blocks to handle common issues:

FileNotFoundError: The file doesn’t exist at the specified path
Music21Exception: The file exists but isn’t valid MusicXML
Parsing errors: The file is corrupted or in an unexpected format

Proper error handling is crucial when working with real-world data, which may be inconsistent or incomplete.

Function 2: Extracting the Melody

def extract_melody(score: music21.stream.Score) -> music21.stream.Part:
    logger.info("Extracting melody from score")
    try:
        melody_part = score.parts[0]
        n_notes = len(melody_part.recurse().notes)
        logger.info(f"Successfully extracted melody with {n_notes} notes")
        return melody_part
    except Exception as e:
        logger.error(f"Failed to extract melody: {str(e)}")
        raise

Understanding Musical Structure

A musical score typically contains multiple parts (instruments or voices). For motif analysis, we often focus on a single melodic line—usually the first part, which commonly contains the main melody in many musical traditions.

The `recurse()` Method

The recurse() method is a powerful feature of music21 that allows you to traverse the hierarchical structure of a musical score:

Score
  └── Part (Voice/Instrument)
      └── Measure
          └── Note/Rest

By calling melody_part.recurse().notes, we flatten this hierarchy and get all notes in sequence, regardless of which measure they’re in. This is essential for motif identification, which operates on linear sequences of pitches.

Why Extract Just the Melody?

While a full score contains rich information, focusing on a single melodic line simplifies motif analysis:

Reduces complexity: One-dimensional pitch sequences are easier to analyze
Focuses on melodic patterns: Many musical traditions emphasize melodic development
Enables comparison: Single-line analysis allows direct comparison across pieces

For more advanced analysis, you could extend this to:

Analyze multiple parts simultaneously
Identify harmonic motifs (chord progressions)
Track motifs across different voices

Function 3: Identifying Motifs

def identify_motifs(
    melody: music21.stream.Part, min_length: int = 3, max_length: int = 8
) -> List[List[music21.note.Note]]:
    if min_length > max_length:
        raise ValueError("min_length must be less than or equal to max_length")
    if min_length < 1 or max_length < 1:
        raise ValueError("Length parameters must be positive")

    logger.info(f"Identifying motifs (length {min_length}-{max_length})")
    try:
        notes = [n for n in melody.recurse().notes]
        motifs = []

        for length in range(min_length, max_length + 1):
            logger.debug(f"Processing motifs of length {length}")
            for i in range(len(notes) - length + 1):
                motif = notes[i : i + length]
                motifs.append(motif)

        logger.info(f"Found {len(motifs)} potential motifs")
        return motifs
    except Exception as e:
        logger.error(f"Failed to identify motifs: {str(e)}")
        raise

The Sliding Window Approach

This function uses a sliding window technique to extract all possible sequences of notes within the specified length range. For a melody with notes [A, B, C, D, E] and min_length=3, max_length=4, it would extract:

Length 3:

[A, B, C]
[B, C, D]
[C, D, E]

Length 4:

[A, B, C, D]
[B, C, D, E]

Why Multiple Lengths?

Musical motifs can vary in length:

Short motifs (3-4 notes): Often serve as building blocks, appearing frequently
Medium motifs (5-6 notes): May represent thematic material
Long motifs (7-8+ notes): Could be complete phrases or themes

By searching across a range, we capture motifs at different structural levels.

Current Limitations

The current implementation extracts all possible sequences but doesn’t yet:

Filter duplicates: The same motif appearing multiple times is stored separately
Normalize octaves: A motif in different octaves is treated as different
Handle transpositions: A motif transposed to a different key is treated as different

These are important considerations for real-world analysis. For example, in Arab-Andalusian music research, we might want to:

Count occurrences of the same pitch-class sequence regardless of octave
Identify motifs that appear in different keys (transpositional equivalence)
Group similar but not identical motifs (allowing for slight variations)

Extending the Function

Here’s how you might extend this to find unique motifs and count their occurrences:

def identify_unique_motifs(
    melody: music21.stream.Part, 
    min_length: int = 3, 
    max_length: int = 8,
    normalize_octave: bool = True
) -> dict:
    notes = [n for n in melody.recurse().notes]
    motif_counts = defaultdict(int)
    
    for length in range(min_length, max_length + 1):
        for i in range(len(notes) - length + 1):
            motif_notes = notes[i : i + length]
            
            if normalize_octave:
                # Use pitch class names (C, D, E, etc.) instead of full pitch names
                motif = tuple(note.pitch.name for note in motif_notes)
            else:
                # Use full pitch names (C4, D5, etc.)
                motif = tuple(note.pitch.nameWithOctave for note in motif_notes)
            
            motif_counts[motif] += 1
    
    return dict(motif_counts)

Function 4: Visualizing Motif Occurrences

def plot_motif_occurrences(
    score: music21.stream.Score,
    motifs: List[List[music21.note.Note]],
    output_path: Optional[str] = None,
) -> None:
    if not motifs:
        raise ValueError("Motifs list cannot be empty")

    logger.info("Plotting motif occurrences")
    try:
        plt.figure(figsize=(12, 6))
        # Implementation details would depend on how you want to visualize the motifs
        # This is a placeholder for the actual visualization logic

        if output_path:
            plt.savefig(output_path)
            logger.info(f"Saved plot to {output_path}")
        plt.close()
    except Exception as e:
        logger.error(f"Failed to plot motif occurrences: {str(e)}")
        raise

Visualization Strategies

While the function is a placeholder, here are effective visualization approaches for motif analysis:

1. Temporal Distribution Plot

Show where motifs appear across the timeline of the piece:

def plot_motif_timeline(score, motif_counts, motif_of_interest):
    """Plot when a specific motif appears in the score."""
    measures = score.parts[0].getElementsByClass('Measure')
    occurrences = []
    
    for measure_num, measure in enumerate(measures):
        # Count occurrences of motif in this measure
        count = count_motif_in_measure(measure, motif_of_interest)
        occurrences.append(count)
    
    plt.figure(figsize=(14, 4))
    plt.bar(range(len(occurrences)), occurrences)
    plt.xlabel('Measure Number')
    plt.ylabel('Motif Occurrences')
    plt.title(f'Occurrences of {motif_of_interest} across the score')
    plt.show()

2. Heatmap of All Motifs

Visualize the distribution of multiple motifs simultaneously:

def plot_motif_heatmap(score, motif_counts):
    """Create a heatmap showing all motifs across measures."""
    measures = score.parts[0].getElementsByClass('Measure')
    unique_motifs = list(motif_counts.keys())[:10]  # Top 10 motifs
    
    # Create matrix: rows = motifs, columns = measures
    matrix = np.zeros((len(unique_motifs), len(measures)))
    
    for i, motif in enumerate(unique_motifs):
        for j, measure in enumerate(measures):
            matrix[i, j] = count_motif_in_measure(measure, motif)
    
    plt.figure(figsize=(16, 8))
    sns.heatmap(matrix, 
                xticklabels=range(1, len(measures)+1, 20),
                yticklabels=[str(m) for m in unique_motifs],
                cmap='YlOrRd')
    plt.xlabel('Measure Number')
    plt.ylabel('Motif')
    plt.title('Motif Distribution Across Score')
    plt.tight_layout()
    plt.show()

3. Motif Frequency Bar Chart

Show which motifs appear most frequently:

def plot_motif_frequencies(motif_counts, top_n=15):
    """Plot the most frequent motifs."""
    sorted_motifs = sorted(motif_counts.items(), 
                          key=lambda x: x[1], 
                          reverse=True)[:top_n]
    
    motifs, counts = zip(*sorted_motifs)
    
    plt.figure(figsize=(12, 6))
    plt.barh(range(len(motifs)), counts)
    plt.yticks(range(len(motifs)), [str(m) for m in motifs])
    plt.xlabel('Occurrence Count')
    plt.title(f'Top {top_n} Most Frequent Motifs')
    plt.gca().invert_yaxis()
    plt.tight_layout()
    plt.show()

Putting It All Together: A Complete Example

Here’s how you might use these functions in a complete workflow:

from pathlib import Path
import matplotlib.pyplot as plt

# 1. Load the score
score_path = Path("data/Btaihi_Iraq_Ajam.mxl")
score = load_score(score_path)

# 2. Extract the melody
melody = extract_melody(score)

# 3. Identify motifs
motifs = identify_motifs(melody, min_length=3, max_length=5)

# 4. Analyze and visualize
# (Implementation of analysis and visualization would go here)

print(f"Analyzed {len(score.parts[0].getElementsByClass('Measure'))} measures")
print(f"Found {len(motifs)} potential motifs")

Applications in Music Research

This methodology has been applied to:

1. Arab-Andalusian Music Analysis

In my research on Arab-Andalusian motif development, this approach revealed:

Systematic patterns in traditional Iraqi Ajam repertoire
The distribution of melodic centos (motifs) across different sections
Relationships between structural markers (like “Tawchiya”, “Mshalia”) and motif usage

2. Style Analysis

By comparing motifs across different pieces or composers, you can:

Identify characteristic patterns of a musical style
Track the evolution of motifs over time
Compare different interpretations or arrangements

3. Music Information Retrieval

Motif analysis supports:

Music similarity: Pieces with similar motifs may be related
Genre classification: Different genres may have characteristic motifs
Cover detection: Versions of the same piece share core motifs

Challenges and Considerations

1. Octave Equivalence

Should C4-D4-E4 be considered the same as C5-D5-E5? In many analyses, yes—we care about the interval structure, not absolute pitch. The code can be extended to normalize octaves.

2. Transpositional Equivalence

A motif in C major might be the same as one in G major (transposed). For some analyses, you might want to identify these as equivalent.

3. Rhythmic Variation

The current code focuses on pitch sequences. Adding rhythmic information would make motif identification more precise but also more complex.

4. Computational Complexity

For long pieces, the number of potential motifs grows quickly. A 1000-note melody with motifs of length 3-8 generates thousands of sequences. Efficient algorithms and data structures become important at scale.

Extending the Analysis

Here are directions for further development:

1. Add Rhythmic Information

def identify_motifs_with_rhythm(melody, min_length=3, max_length=8):
    """Identify motifs including both pitch and rhythm."""
    notes = [n for n in melody.recurse().notes]
    motifs = []
    
    for length in range(min_length, max_length + 1):
        for i in range(len(notes) - length + 1):
            motif_notes = notes[i : i + length]
            motif = {
                'pitches': [n.pitch.name for n in motif_notes],
                'rhythms': [n.quarterLength for n in motif_notes],
                'intervals': [music21.interval.Interval(n1, n2) 
                            for n1, n2 in zip(motif_notes[:-1], motif_notes[1:])]
            }
            motifs.append(motif)
    
    return motifs

2. Fuzzy Matching

Allow for slight variations in motifs:

def find_similar_motifs(motif, all_motifs, similarity_threshold=0.8):
    """Find motifs similar to a given motif using edit distance or other metrics."""
    # Implementation using sequence alignment or other similarity measures
    pass

3. Hierarchical Analysis

Identify motifs at different structural levels:

Note-level: Individual pitch sequences
Measure-level: Patterns across measures
Section-level: Recurring sections or phrases

Conclusion

Computational motif analysis opens powerful avenues for understanding musical structure. The functions we’ve explored provide a foundation for:

Systematic pattern discovery in musical scores
Quantitative analysis of musical traditions
Comparative studies across pieces, styles, or time periods

While the current implementation is a starting point, the techniques can be extended to handle more complex scenarios: rhythmic patterns, harmonic progressions, multi-voice analysis, and fuzzy matching for variations.

For a complete implementation with visualizations and analysis of Arab-Andalusian music, see the interactive notebook and the GitHub repository.