Python for Music Analysis: Exploring Musical Structure and Composition

Introduction
Prerequisites
Setup and Installation
Analyzing Musical Structure
Analyzing Musical Composition
Conclusion

Introduction

Music analysis involves understanding the structure and composition of musical pieces. Python, with its powerful libraries and modules, provides an excellent platform for exploring and analyzing musical data. In this tutorial, we will learn how to leverage Python to analyze musical structure and composition. By the end of this tutorial, you will have a solid foundation for conducting music analysis tasks using Python.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python programming concepts. Familiarity with music theory and its terminology will also be helpful, but not mandatory. Prior experience with libraries like music21 and matplotlib would be beneficial, although we will cover the necessary installation and setup in the next section.

Setup and Installation

Before we delve into music analysis, we need to set up our Python environment and install the required libraries.

Python Installation: If you already have Python installed, skip this step. Otherwise, download the latest version of Python from the official Python website and follow the installation instructions for your operating system.
Installing Required Libraries: Open your terminal or command prompt and execute the following commands:
```
pip install music21
pip install matplotlib
```
These commands will install the music21 and matplotlib libraries, which we will use for music analysis and data visualization respectively.
Importing Libraries: In your Python script or Jupyter Notebook, import the necessary libraries:
```
import music21
import matplotlib.pyplot as plt
```
Analyzing Musical Structure

One fundamental aspect of music analysis is understanding its structure. We can analyze musical structure by examining elements such as melody, harmony, rhythm, and form. Let’s explore each of these elements using Python.

Melody Analysis

Melody refers to a sequence of single notes that together form a musical phrase. To analyze melodies in Python, we can use the music21 library.

Importing the Required Modules: In your Python script or Jupyter Notebook, import the necessary modules:
```
from music21 import converter, note
```
Loading a Music File: Use the converter module to load a music file:
```
score = converter.parse('path/to/music/file.mid')
```
Replace 'path/to/music/file.mid' with the actual path to your music file.
Extracting Melody Notes: To extract the melody notes from the music file, iterate over the score and filter out the elements that are instances of the note.Note class:
```
melody_notes = [element for element in score.recurse() if isinstance(element, note.Note)]
```
This will create a list of melody notes from the music file.

Analyzing Melody Characteristics: Now that we have the melody notes, we can analyze their characteristics. For example, we can calculate their duration, pitch distribution, or create a histogram of note frequencies.

durations = [note.duration.quarterLength for note in melody_notes]
pitches = [note.pitch.midi for note in melody_notes]

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.hist(durations, bins=20, edgecolor='black')
plt.xlabel('Duration')
plt.ylabel('Count')

plt.subplot(1, 2, 2)
plt.hist(pitches, bins=range(min(pitches), max(pitches) + 1), edgecolor='black')
plt.xlabel('Pitch (MIDI Number)')
plt.ylabel('Count')

plt.tight_layout()
plt.show()

This code snippet calculates the duration and pitch distribution of the melody notes and visualizes them using histograms.

Harmony Analysis

Harmony refers to the combination of multiple simultaneous notes or chords that support the melody. Analyzing harmony helps us understand the harmonic progression and chord structures in a music piece.

Importing the Required Modules: In your Python script or Jupyter Notebook, import the necessary modules:
```
from music21 import stream, chord
```
Extracting Harmony Chords: Similar to extracting melody notes, we can extract harmony chords from a music file by iterating over the score and filtering out the elements that are instances of the chord.Chord class:
```
harmony_chords = [element for element in score.recurse() if isinstance(element, chord.Chord)]
```
This will give us a list of harmony chords from the music file.

Analyzing Harmony Characteristics: We can analyze various characteristics of harmony chords, such as their root notes, voicings, and chord progressions. Here’s an example:

root_notes = [chord.root().midi for chord in harmony_chords]
chord_types = [chord.pitchedCommonName for chord in harmony_chords]

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.hist(root_notes, bins=range(min(root_notes), max(root_notes) + 1), edgecolor='black')
plt.xlabel('Root Note (MIDI Number)')
plt.ylabel('Count')

plt.subplot(1, 2, 2)
plt.hist(chord_types, bins=20, edgecolor='black')
plt.xlabel('Chord Type')
plt.ylabel('Count')

plt.tight_layout()
plt.show()

This code snippet calculates the root note distribution and chord type distribution of the harmony chords and visualizes them using histograms.

Rhythm Analysis

Rhythm refers to the timing and duration of musical events. To analyze rhythm, we can examine the rhythmic patterns and tempo of a music piece.

Importing the Required Modules: In your Python script or Jupyter Notebook, import the necessary modules:
```
from music21 import duration, stream
```
Extracting Rhythm Patterns: We can extract rhythm patterns by iterating over the score and filtering out the elements that are instances of the duration.Duration class:
```
rhythm_patterns = [element for element in score.recurse() if isinstance(element, duration.Duration)]
```
This will create a list of rhythm patterns from the music file.

Analyzing Rhythm Characteristics: We can analyze various characteristics of rhythm patterns, such as the distribution of note durations and tempo fluctuations. Here’s an example:

note_durations = [pattern.quarterLength for pattern in rhythm_patterns]
tempos = [element.number for element in score.flat.getElementsByClass(stream.MetronomeMark)]

plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.hist(note_durations, bins=20, edgecolor='black')
plt.xlabel('Note Duration')
plt.ylabel('Count')

plt.subplot(1, 2, 2)
plt.plot(tempos)
plt.xlabel('Time')
plt.ylabel('Tempo (BPM)')

plt.tight_layout()
plt.show()

This code snippet calculates the note duration distribution and plots the tempo fluctuations of the music piece.

Analyzing Musical Composition

Apart from analyzing individual music pieces, we can also analyze the composition of multiple music pieces. This analysis can involve comparing different compositions, identifying patterns, and extracting useful insights.

To analyze musical composition, we need a dataset of music pieces to work with. You can either use your own dataset or download a dataset from online repositories such as the KernScores dataset.

Importing the Required Modules: In your Python script or Jupyter Notebook, import the necessary modules:
```
from music21 import corpus, features
import pandas as pd
```

Loading and Preprocessing the Dataset: Use the corpus module to load the music pieces from the KernScores dataset:

compositions = corpus.getBachChorales()

Next, we can preprocess the dataset by extracting relevant features from each composition:

features_list = []
for composition in compositions:
    feature_vector = {
        'title': composition.metadata.title,
        'key': composition.analyze('key').name,
        'soprano_range': composition.parts['Soprano'].highestNote.pitch.ps - composition.parts['Soprano'].lowestNote.pitch.ps,
        'bass_range': composition.parts['Bass'].highestNote.pitch.ps - composition.parts['Bass'].lowestNote.pitch.ps
    }
    features_list.append(feature_vector)

df = pd.DataFrame(features_list)

This code snippet loads the Bach chorales dataset and extracts features such as composition title, key signature, soprano range, and bass range for each composition. We store the extracted features in a Pandas DataFrame for further analysis.

Analyzing Composition Characteristics: With the preprocessed dataset, we can analyze various characteristics of musical compositions. For example, we can calculate the distribution of key signatures or explore the relationship between soprano and bass ranges:
```
plt.figure(figsize=(10, 5))
plt.subplot(1, 2, 1)
df['key'].value_counts().plot(kind='bar', edgecolor='black')
plt.xlabel('Key Signature')
plt.ylabel('Count')

plt.subplot(1, 2, 2)
plt.scatter(df['soprano_range'], df['bass_range'])
plt.xlabel('Soprano Range')
plt.ylabel('Bass Range')

plt.tight_layout()
plt.show()
```
This code snippet generates a bar plot of the key signature distribution and a scatter plot of the soprano range versus the bass range for the compositions.

Conclusion

In this tutorial, we explored how to analyze musical structure and composition using Python. We learned how to analyze melody, harmony, and rhythm characteristics of music pieces. Additionally, we discovered how to analyze musical composition by comparing multiple pieces and extracting meaningful insights. With the knowledge gained from this tutorial, you can start exploring more advanced topics in music analysis and delve deeper into the fascinating field of digital musicology. Happy coding!

Note: This tutorial provides a basic introduction to music analysis using Python. Further exploration and research are encouraged to expand your understanding of this domain.

Published: 1 August 2019