Sennheiser Momentum 5 vs. Bowers & Wilkins Px7 S3: I tested both, and one wins nearly every metric

Introduction

In this tutorial, we'll explore how to analyze and compare audio device performance using Python and machine learning techniques. Drawing from the recent comparison between Sennheiser Momentum 5 and Bowers & Wilkins Px7 S3, we'll build a practical system that can evaluate audio quality metrics and provide data-driven recommendations. This tutorial will teach you how to process audio files, extract meaningful features, and build a comparative analysis system that can help you make informed decisions when choosing audio equipment.

Prerequisites

Before beginning this tutorial, you should have:

• Basic Python programming knowledge
• Python 3.7 or higher installed
• Experience with audio processing libraries
• Understanding of machine learning concepts
• Basic familiarity with data analysis libraries

Required Python packages:

pip install numpy scipy librosa scikit-learn pandas matplotlib seaborn

Step-by-Step Instructions

1. Set up the Audio Analysis Environment

First, we need to create a structured environment for audio analysis. This involves importing necessary libraries and setting up our data processing pipeline.

import numpy as np
import pandas as pd
import librosa
import librosa.display
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
import warnings
warnings.filterwarnings('ignore')

# Set up plotting style
plt.style.use('seaborn-v0_8')
plt.rcParams['figure.figsize'] = (12, 8)

Why: This setup prepares our environment with essential audio processing and analysis tools. We're importing libraries that will help us analyze audio characteristics, visualize data, and perform machine learning operations.

2. Create Audio Feature Extraction Functions

Next, we'll develop functions to extract key audio features that are commonly used in audio device comparisons:

def extract_audio_features(audio_file, sr=22050):
    '''Extract comprehensive audio features from a file'''
    # Load audio file
    y, sr = librosa.load(audio_file, sr=sr)
    
    # Basic features
    features = {}
    
    # Spectral features
    features['spectral_centroid'] = np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))
    features['spectral_rolloff'] = np.mean(librosa.feature.spectral_rolloff(y=y, sr=sr))
    features['spectral_bandwidth'] = np.mean(librosa.feature.spectral_bandwidth(y=y, sr=sr))
    features['zero_crossing_rate'] = np.mean(librosa.feature.zero_crossing_rate(y))
    
    # Temporal features
    features['rms'] = np.mean(librosa.feature.rms(y=y))
    features['tempo'] = librosa.beat.tempo(y=y, sr=sr)[0]
    
    # MFCC features (important for audio quality assessment)
    mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    for i, mfcc in enumerate(mfccs):
        features[f'mfcc_{i}'] = np.mean(mfcc)
    
    return features

# Create a function to process multiple files
def process_audio_files(file_list):
    '''Process multiple audio files and return feature dataframe'''
    features_list = []
    
    for file in file_list:
        try:
            features = extract_audio_features(file)
            features['file_name'] = file
            features_list.append(features)
        except Exception as e:
            print(f"Error processing {file}: {e}")
            
    return pd.DataFrame(features_list)

Why: These functions extract key audio characteristics that help distinguish between different audio devices. Spectral features like centroid and rolloff indicate frequency distribution, while MFCCs capture perceptual aspects of audio quality that are important for comparing headphones like the Momentum 5 and Px7 S3.

3. Build Comparative Analysis Framework

Now we'll create a system that can compare different audio devices based on extracted features:

class AudioDeviceComparator:
    def __init__(self):
        self.scaler = StandardScaler()
        self.pca = PCA(n_components=0.95)  # Retain 95% of variance
        self.comparison_data = None
        
    def prepare_data(self, feature_df):
        '''Prepare data for analysis'''
        # Separate features from file names
        feature_columns = [col for col in feature_df.columns if col != 'file_name']
        X = feature_df[feature_columns]
        
        # Scale the features
        X_scaled = self.scaler.fit_transform(X)
        
        # Apply PCA for dimensionality reduction
        X_pca = self.pca.fit_transform(X_scaled)
        
        return X_pca, feature_columns
    
    def compare_devices(self, feature_df):
        '''Compare different audio devices'''
        X_pca, feature_columns = self.prepare_data(feature_df)
        
        # Perform clustering to group similar devices
        kmeans = KMeans(n_clusters=2, random_state=42)
        clusters = kmeans.fit_predict(X_pca)
        
        # Add cluster information to dataframe
        feature_df['cluster'] = clusters
        
        return feature_df, clusters
    
    def visualize_comparison(self, feature_df):
        '''Create visualizations for comparison'''
        # Create a heatmap of feature correlations
        plt.figure(figsize=(15, 10))
        
        # Correlation matrix
        feature_columns = [col for col in feature_df.columns if col != 'file_name' and col != 'cluster']
        corr_matrix = feature_df[feature_columns].corr()
        
        sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0)
        plt.title('Audio Feature Correlation Matrix')
        plt.tight_layout()
        plt.show()
        
        # Plot PCA results
        plt.figure(figsize=(10, 8))
        scatter = plt.scatter(feature_df['PC1'], feature_df['PC2'], c=feature_df['cluster'], cmap='viridis')
        plt.xlabel('First Principal Component')
        plt.ylabel('Second Principal Component')
        plt.title('Audio Device Comparison - PCA Visualization')
        plt.colorbar(scatter)
        plt.show()

Why: This framework allows us to systematically compare audio devices by extracting meaningful features and applying machine learning techniques. The PCA and clustering help identify patterns in how different devices perform across various audio characteristics.

4. Load and Analyze Sample Audio Data

Let's create a sample dataset to demonstrate the analysis:

# Create sample audio data structure
sample_files = [
    'momentum5_test1.wav',
    'momentum5_test2.wav',
    'momentum5_test3.wav',
    'px7s3_test1.wav',
    'px7s3_test2.wav',
    'px7s3_test3.wav'
]

# For demonstration, we'll create synthetic feature data
# In practice, you'd load actual audio files
np.random.seed(42)

# Generate synthetic features for Momentum 5
momentum5_features = {
    'spectral_centroid': np.random.normal(3000, 500),
    'spectral_rolloff': np.random.normal(8000, 1000),
    'spectral_bandwidth': np.random.normal(2000, 300),
    'zero_crossing_rate': np.random.normal(0.05, 0.01),
    'rms': np.random.normal(0.3, 0.05),
    'tempo': 120,
    'mfcc_0': np.random.normal(0.1, 0.02),
    'mfcc_1': np.random.normal(0.05, 0.01),
    'mfcc_2': np.random.normal(0.03, 0.01),
    'mfcc_3': np.random.normal(0.02, 0.01),
    'file_name': 'momentum5.wav'
}

# Generate synthetic features for Px7 S3
px7s3_features = {
    'spectral_centroid': np.random.normal(2800, 400),
    'spectral_rolloff': np.random.normal(7500, 800),
    'spectral_bandwidth': np.random.normal(2200, 250),
    'zero_crossing_rate': np.random.normal(0.045, 0.008),
    'rms': np.random.normal(0.32, 0.04),
    'tempo': 120,
    'mfcc_0': np.random.normal(0.12, 0.02),
    'mfcc_1': np.random.normal(0.06, 0.01),
    'mfcc_2': np.random.normal(0.04, 0.01),
    'mfcc_3': np.random.normal(0.03, 0.01),
    'file_name': 'px7s3.wav'
}

# Create DataFrame
data = pd.DataFrame([momentum5_features, px7s3_features])
print("Sample feature data:")
print(data)

Why: This synthetic data represents the kind of feature extraction we'd perform on real audio files. In a real implementation, you'd replace this with actual audio file processing, but this demonstrates the structure and workflow.

5. Run the Comparative Analysis

Finally, we'll execute our analysis to compare the two audio devices:

# Initialize comparator
comparator = AudioDeviceComparator()

# Process the data
try:
    # For demonstration, we'll work with our synthetic data
    feature_df = data.copy()
    
    # Add PCA components for visualization
    X_pca, feature_columns = comparator.prepare_data(feature_df)
    feature_df['PC1'] = X_pca[:, 0]
    feature_df['PC2'] = X_pca[:, 1]
    
    # Perform comparison
    comparison_result, clusters = comparator.compare_devices(feature_df)
    
    print("\nComparison Results:")
    print(comparison_result)
    
    # Visualize results
    comparator.visualize_comparison(comparison_result)
    
    # Print analysis summary
    print("\nAnalysis Summary:")
    print(f"Momentum 5 characteristics: {comparison_result[comparison_result['file_name'] == 'momentum5.wav'].iloc[0]['spectral_centroid']:.2f} Hz centroid")
    print(f"Px7 S3 characteristics: {comparison_result[comparison_result['file_name'] == 'px7s3.wav'].iloc[0]['spectral_centroid']:.2f} Hz centroid")
    
except Exception as e:
    print(f"Error in analysis: {e}")

Why: This step executes our complete analysis pipeline, showing how the system would process real audio data to make comparisons. The PCA visualization helps identify which audio characteristics distinguish one device from another.

Summary

This tutorial demonstrated how to build a systematic approach for comparing audio devices like the Sennheiser Momentum 5 and Bowers & Wilkins Px7 S3. We created a framework that extracts audio features, applies machine learning techniques for analysis, and provides visual comparisons. The system uses spectral features, temporal characteristics, and MFCCs to evaluate audio quality differences between devices.

The key learning outcomes include:

• Understanding how to extract meaningful audio features using librosa
• Applying data preprocessing and dimensionality reduction techniques
• Using clustering and PCA for device comparison
• Creating visualizations to interpret audio quality differences

This approach can be extended to analyze any number of audio devices, providing data-driven insights for audio equipment selection based on measurable performance characteristics rather than just subjective listening tests.