如何用Scikit-learn MLP分类器处理变长输入数据

Hey there! Let's break down how to train an MLP classifier on your variable-length audio dataset—since MLPs need fixed-size input features, the key is turning those 70-80 row signals into consistent vectors first. Here's a practical step-by-step approach:

1. Convert Variable-Length Signals to Fixed-Size Features #

MLPs can't process sequences of varying lengths directly, so we need to extract a fixed set of features from each signal file. Here are three reliable methods:

Option 1: Statistical Feature Extraction (Most Robust for Small Length Variations) #

Calculate summary statistics for each of the 2 signal columns. This preserves overall signal characteristics without losing context. For each file, compute metrics like:

• Mean, median, standard deviation
• Min/max values
• Skewness, kurtosis
• Root Mean Square (RMS), signal energy (sum of squares)
• 25th/75th percentiles

Example code to extract these features:

import numpy as np
import pandas as pd

def extract_stat_features(file_path):
    # Load your audio data (adjust based on your file format: csv, npy, etc.)
    signal = pd.read_csv(file_path).values  # Shape: (L, 2) where 70 ≤ L ≤80
    
    features = []
    for col in range(signal.shape[1]):
        col_data = signal[:, col]
        features.extend([
            np.mean(col_data),
            np.median(col_data),
            np.std(col_data),
            np.min(col_data),
            np.max(col_data),
            np.sqrt(np.mean(col_data**2)),  # RMS
            np.sum(col_data**2),  # Energy
            np.percentile(col_data, 25),
            np.percentile(col_data, 75),
            np.skew(col_data),
            np.kurtosis(col_data)
        ])
    return np.array(features)  # Shape: (22,) for 2 columns × 11 metrics

Option 2: Truncate/Padding (Quick Fix for Small Length Differences) #

Since your signals only vary between 70-80 rows, you can standardize the length by either:

• Truncating: Cut all signals to the shortest length (70 rows)
• Padding: Extend shorter signals to the longest length (80 rows) using zeros, or replicate the last few values to avoid introducing artificial silence

Example code for padding:

def pad_signal(signal, target_length=80):
    current_len = signal.shape[0]
    if current_len < target_length:
        # Pad with zeros at the end (adjust axis if needed)
        pad_width = ((0, target_length - current_len), (0, 0))
        return np.pad(signal, pad_width, mode='constant')
    elif current_len > target_length:
        # Truncate to target length
        return signal[:target_length, :]
    else:
        return signal

# After padding/truncating, flatten the 2D array to 1D for MLP input
flattened_signal = pad_signal(signal).flatten()  # Shape: (160,) for 80×2

Option 3: Sliding Window Features (Captures Local Patterns) #

If you want to retain more temporal detail, use sliding windows to extract local stats from each signal column. For example, a window size of 10 with step 5 would generate a fixed number of windows per signal.

Example code:

def sliding_window_features(signal, window_size=10, step=5):
    features = []
    for col in range(signal.shape[1]):
        col_data = signal[:, col]
        # Generate window indices
        windows = [col_data[i:i+window_size] for i in range(0, len(col_data)-window_size+1, step)]
        # Compute stats for each window
        for win in windows:
            features.extend([np.mean(win), np.std(win), np.max(win), np.min(win)])
    return np.array(features)  # Fixed length regardless of original signal length

2. Build Training & Test Sets #

Once you have a way to convert each file to a fixed feature vector, you can load all data and split it into training/test sets:

import os
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Assume your files are organized in folders by class (e.g., './class_a/', './class_b/')
data_dir = './your_data_directory/'
X = []
y = []

# Load all files and extract features
for class_label, class_folder in enumerate(os.listdir(data_dir)):
    folder_path = os.path.join(data_dir, class_folder)
    if not os.path.isdir(folder_path):
        continue
    for file_name in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file_name)
        features = extract_stat_features(file_path)  # Use your chosen feature function
        X.append(features)
        y.append(class_label)

# Convert to numpy arrays
X = np.array(X)
y = np.array(y)

# Split into train/test (use stratify to preserve class distribution)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Standardize features (critical for MLP performance!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

3. Train the MLP Classifier #

Now you can use scikit-learn's MLPClassifier with your fixed-size scaled features:

from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report

# Initialize MLP (adjust hidden layers/parameters based on your data)
mlp = MLPClassifier(
    hidden_layer_sizes=(64, 32),  # 2 hidden layers: 64 and 32 neurons
    activation='relu',
    solver='adam',
    max_iter=500,
    random_state=42,
    verbose=True
)

# Train the model
mlp.fit(X_train_scaled, y_train)

# Evaluate on test set
y_pred = mlp.predict(X_test_scaled)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred):.2f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

Pro Tips for Better Performance #

• Hyperparameter Tuning: Use GridSearchCV to optimize hidden_layer_sizes, learning_rate_init, alpha (regularization), etc.
• Cross-Validation: Instead of a single train/test split, use StratifiedKFold for more reliable evaluation.
• Class Imbalance: If some classes have fewer samples, use techniques like class weights (class_weight='balanced' in MLPClassifier) or oversampling.

内容的提问来源于stack exchange，提问作者ZEESHAN