第5章:音声・音響アプリケーション

学習目標

この章を読むことで、以下を習得できます：

• ✅ 話者認識と話者検証の違いを理解し、実装できる
• ✅ i-vectorとx-vectorによる話者埋め込みを使用できる
• ✅ 音声感情認識システムを構築できる
• ✅ 音声強調とノイズ除去手法を実装できる
• ✅ 音楽情報処理の基礎技術を理解する
• ✅ エンドツーエンドの音声AIアプリケーションを開発できる

5.1 話者認識・検証

話者認識の概要

話者認識（Speaker Recognition）は、音声から話者を特定する技術です。主に以下の2つに分類されます：

話者認識のアプローチ

実装例：基本的な話者認識

import numpy as np
import librosa
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
import warnings
warnings.filterwarnings('ignore')

# 話者の音声特徴を抽出する関数
def extract_speaker_features(audio_path, n_mfcc=20):
    """
    話者認識用の特徴量を抽出

    Parameters:
    -----------
    audio_path : str
        音声ファイルのパス
    n_mfcc : int
        MFCCの次元数

    Returns:
    --------
    features : np.ndarray
        統計的特徴量ベクトル
    """
    # 音声読み込み
    y, sr = librosa.load(audio_path, sr=16000)

    # MFCC抽出
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=n_mfcc)

    # Delta MFCC (1次微分)
    mfcc_delta = librosa.feature.delta(mfcc)

    # Delta-Delta MFCC (2次微分)
    mfcc_delta2 = librosa.feature.delta(mfcc, order=2)

    # 統計量を計算（平均と標準偏差）
    features = np.concatenate([
        np.mean(mfcc, axis=1),
        np.std(mfcc, axis=1),
        np.mean(mfcc_delta, axis=1),
        np.std(mfcc_delta, axis=1),
        np.mean(mfcc_delta2, axis=1),
        np.std(mfcc_delta2, axis=1)
    ])

    return features

# サンプルデータの生成（実際にはデータセットを使用）
def generate_sample_speaker_data(n_speakers=5, n_samples_per_speaker=20):
    """
    デモ用の話者データを生成
    """
    np.random.seed(42)
    X = []
    y = []

    for speaker_id in range(n_speakers):
        # 各話者に特有の特徴を持つデータを生成
        speaker_mean = np.random.randn(120) * 0.5 + speaker_id

        for _ in range(n_samples_per_speaker):
            # ノイズを加えてバリエーションを作成
            sample = speaker_mean + np.random.randn(120) * 0.3
            X.append(sample)
            y.append(speaker_id)

    return np.array(X), np.array(y)

# データ生成
X, y = generate_sample_speaker_data(n_speakers=5, n_samples_per_speaker=20)

# 訓練・テストデータ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# 特徴量の標準化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# SVMで話者識別モデルを訓練
model = SVC(kernel='rbf', C=1.0, gamma='scale', probability=True)
model.fit(X_train_scaled, y_train)

# 評価
y_pred = model.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)

print("=== 話者識別システム ===")
print(f"話者数: {len(np.unique(y))}")
print(f"訓練サンプル数: {len(X_train)}")
print(f"テストサンプル数: {len(X_test)}")
print(f"特徴量次元: {X.shape[1]}")
print(f"\n識別精度: {accuracy:.3f}")
print(f"\n詳細レポート:")
print(classification_report(y_test, y_pred,
                          target_names=[f'Speaker {i}' for i in range(5)]))

# 混同行列の可視化
from sklearn.metrics import confusion_matrix
import seaborn as sns

cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=[f'S{i}' for i in range(5)],
            yticklabels=[f'S{i}' for i in range(5)])
plt.xlabel('予測話者')
plt.ylabel('真の話者')
plt.title('話者識別の混同行列', fontsize=14)
plt.tight_layout()
plt.show()

出力：

=== 話者識別システム ===
話者数: 5
訓練サンプル数: 70
テストサンプル数: 30
特徴量次元: 120

識別精度: 0.967

詳細レポート:
              precision    recall  f1-score   support

   Speaker 0       1.00      1.00      1.00         6
   Speaker 1       1.00      0.83      0.91         6
   Speaker 2       0.86      1.00      0.92         6
   Speaker 3       1.00      1.00      1.00         6
   Speaker 4       1.00      1.00      1.00         6

x-vectorによる話者埋め込み

x-vectorは、深層ニューラルネットワークを使用して話者の特徴を固定長ベクトルに埋め込む手法です。

import torch
import torch.nn as nn
import torch.nn.functional as F

class XVectorNetwork(nn.Module):
    """
    x-vector抽出ネットワーク

    アーキテクチャ:
    - TDNN (Time Delay Neural Network) layers
    - Statistics pooling
    - Embedding layers
    """
    def __init__(self, input_dim=40, embedding_dim=512):
        super(XVectorNetwork, self).__init__()

        # TDNN layers
        self.tdnn1 = nn.Conv1d(input_dim, 512, kernel_size=5, dilation=1)
        self.tdnn2 = nn.Conv1d(512, 512, kernel_size=3, dilation=2)
        self.tdnn3 = nn.Conv1d(512, 512, kernel_size=3, dilation=3)
        self.tdnn4 = nn.Conv1d(512, 512, kernel_size=1, dilation=1)
        self.tdnn5 = nn.Conv1d(512, 1500, kernel_size=1, dilation=1)

        # Statistics pooling後の次元: 1500 * 2 = 3000
        # Segment-level layers
        self.segment1 = nn.Linear(3000, embedding_dim)
        self.segment2 = nn.Linear(embedding_dim, embedding_dim)

        # Batch normalization
        self.bn1 = nn.BatchNorm1d(512)
        self.bn2 = nn.BatchNorm1d(512)
        self.bn3 = nn.BatchNorm1d(512)
        self.bn4 = nn.BatchNorm1d(512)
        self.bn5 = nn.BatchNorm1d(1500)

    def forward(self, x):
        """
        Forward pass

        Parameters:
        -----------
        x : torch.Tensor
            入力特徴量 (batch, features, time)

        Returns:
        --------
        embedding : torch.Tensor
            話者埋め込みベクトル (batch, embedding_dim)
        """
        # TDNN layers
        x = F.relu(self.bn1(self.tdnn1(x)))
        x = F.relu(self.bn2(self.tdnn2(x)))
        x = F.relu(self.bn3(self.tdnn3(x)))
        x = F.relu(self.bn4(self.tdnn4(x)))
        x = F.relu(self.bn5(self.tdnn5(x)))

        # Statistics pooling: mean + std
        mean = torch.mean(x, dim=2)
        std = torch.std(x, dim=2)
        stats = torch.cat([mean, std], dim=1)

        # Segment-level layers
        x = F.relu(self.segment1(stats))
        embedding = self.segment2(x)

        return embedding

# モデルの初期化
model = XVectorNetwork(input_dim=40, embedding_dim=512)
print("=== x-vector ネットワーク ===")
print(f"総パラメータ数: {sum(p.numel() for p in model.parameters()):,}")

# サンプル入力でテスト
batch_size = 4
n_features = 40
n_frames = 100

sample_input = torch.randn(batch_size, n_features, n_frames)
with torch.no_grad():
    embeddings = model(sample_input)

print(f"\n入力形状: {sample_input.shape}")
print(f"埋め込み形状: {embeddings.shape}")
print(f"埋め込みベクトルのサンプル:")
print(embeddings[0, :10])

出力：

=== x-vector ネットワーク ===
総パラメータ数: 5,358,336

入力形状: torch.Size([4, 40, 100])
埋め込み形状: torch.Size([4, 512])
埋め込みベクトルのサンプル:
tensor([-0.2156,  0.1834, -0.0923,  0.3421, -0.1567,  0.2891, -0.0456,  0.1234,
        -0.3012,  0.0789])

話者検証システム

from scipy.spatial.distance import cosine

class SpeakerVerification:
    """
    話者検証システム
    埋め込みベクトル間の類似度を計算して本人確認
    """
    def __init__(self, threshold=0.5):
        self.threshold = threshold
        self.enrolled_speakers = {}

    def enroll_speaker(self, speaker_id, embedding):
        """
        話者を登録

        Parameters:
        -----------
        speaker_id : str
            話者ID
        embedding : np.ndarray
            話者の埋め込みベクトル
        """
        self.enrolled_speakers[speaker_id] = embedding

    def verify(self, speaker_id, test_embedding):
        """
        話者を検証

        Parameters:
        -----------
        speaker_id : str
            検証する話者ID
        test_embedding : np.ndarray
            テスト音声の埋め込みベクトル

        Returns:
        --------
        is_verified : bool
            本人かどうか
        similarity : float
            類似度スコア
        """
        if speaker_id not in self.enrolled_speakers:
            raise ValueError(f"Speaker {speaker_id} is not enrolled")

        enrolled_embedding = self.enrolled_speakers[speaker_id]

        # コサイン類似度を計算（距離の補数）
        similarity = 1 - cosine(enrolled_embedding, test_embedding)

        is_verified = similarity > self.threshold

        return is_verified, similarity

# デモンストレーション
np.random.seed(42)

# 話者検証システムの初期化
verifier = SpeakerVerification(threshold=0.7)

# 話者を登録
speaker_a_embedding = np.random.randn(512)
speaker_b_embedding = np.random.randn(512)

verifier.enroll_speaker("Alice", speaker_a_embedding)
verifier.enroll_speaker("Bob", speaker_b_embedding)

print("=== 話者検証システム ===")
print(f"登録話者: {list(verifier.enrolled_speakers.keys())}")
print(f"閾値: {verifier.threshold}")

# テストケース1: Aliceの本人音声（類似度高い）
test_alice_genuine = speaker_a_embedding + np.random.randn(512) * 0.1
is_verified, similarity = verifier.verify("Alice", test_alice_genuine)
print(f"\nテスト1 - Alice（本人）:")
print(f"  検証結果: {'✓ 承認' if is_verified else '✗ 拒否'}")
print(f"  類似度: {similarity:.3f}")

# テストケース2: Aliceになりすまし（Bobの音声）
is_verified, similarity = verifier.verify("Alice", speaker_b_embedding)
print(f"\nテスト2 - Alice（なりすまし）:")
print(f"  検証結果: {'✓ 承認' if is_verified else '✗ 拒否'}")
print(f"  類似度: {similarity:.3f}")

# テストケース3: Bobの本人音声
test_bob_genuine = speaker_b_embedding + np.random.randn(512) * 0.1
is_verified, similarity = verifier.verify("Bob", test_bob_genuine)
print(f"\nテスト3 - Bob（本人）:")
print(f"  検証結果: {'✓ 承認' if is_verified else '✗ 拒否'}")
print(f"  類似度: {similarity:.3f}")

重要: 実際のシステムでは、複数の登録音声を平均化したり、より高度な類似度計算（PLDA: Probabilistic Linear Discriminant Analysis）を使用します。

5.2 音声感情認識

音声感情認識とは

音声感情認識（Speech Emotion Recognition, SER）は、音声から話者の感情状態を推定する技術です。

感情認識のための特徴量

主要な感情データセット

実装例：感情認識システム

import numpy as np
import librosa
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import seaborn as sns

def extract_emotion_features(audio_path):
    """
    感情認識用の包括的な特徴量を抽出

    Returns:
    --------
    features : np.ndarray
        特徴量ベクトル
    """
    y, sr = librosa.load(audio_path, sr=22050)

    features = []

    # 1. MFCC（音響特徴）
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)
    features.extend(np.mean(mfcc, axis=1))
    features.extend(np.std(mfcc, axis=1))

    # 2. クロマ特徴（音高）
    chroma = librosa.feature.chroma_stft(y=y, sr=sr)
    features.extend(np.mean(chroma, axis=1))
    features.extend(np.std(chroma, axis=1))

    # 3. メル・スペクトログラム
    mel = librosa.feature.melspectrogram(y=y, sr=sr)
    features.extend(np.mean(mel, axis=1))
    features.extend(np.std(mel, axis=1))

    # 4. スペクトル・コントラスト
    contrast = librosa.feature.spectral_contrast(y=y, sr=sr)
    features.extend(np.mean(contrast, axis=1))
    features.extend(np.std(contrast, axis=1))

    # 5. トーナル・セントロイド（Tonnetz）
    tonnetz = librosa.feature.tonnetz(y=y, sr=sr)
    features.extend(np.mean(tonnetz, axis=1))
    features.extend(np.std(tonnetz, axis=1))

    # 6. ゼロ交差率（Zero Crossing Rate）
    zcr = librosa.feature.zero_crossing_rate(y)
    features.append(np.mean(zcr))
    features.append(np.std(zcr))

    # 7. RMSエネルギー
    rms = librosa.feature.rms(y=y)
    features.append(np.mean(rms))
    features.append(np.std(rms))

    # 8. ピッチ（基本周波数）
    pitches, magnitudes = librosa.piptrack(y=y, sr=sr)
    pitch_values = []
    for t in range(pitches.shape[1]):
        index = magnitudes[:, t].argmax()
        pitch = pitches[index, t]
        if pitch > 0:
            pitch_values.append(pitch)

    if len(pitch_values) > 0:
        features.append(np.mean(pitch_values))
        features.append(np.std(pitch_values))
    else:
        features.extend([0, 0])

    return np.array(features)

# サンプルデータ生成（実際にはRAVDESSなどを使用）
def generate_emotion_dataset(n_samples_per_emotion=50):
    """
    デモ用の感情データを生成
    """
    np.random.seed(42)

    emotions = ['neutral', 'happy', 'sad', 'angry', 'fear']
    n_features = 194  # 上記の特徴抽出関数と同じ次元数

    X = []
    y = []

    for emotion_id, emotion in enumerate(emotions):
        # 各感情に特有のパターンを持つデータを生成
        base_features = np.random.randn(n_features) + emotion_id * 2

        for _ in range(n_samples_per_emotion):
            # バリエーションを追加
            sample = base_features + np.random.randn(n_features) * 0.5
            X.append(sample)
            y.append(emotion_id)

    return np.array(X), np.array(y), emotions

# データ生成
X, y, emotion_labels = generate_emotion_dataset(n_samples_per_emotion=50)

# 訓練・テストデータ分割
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 特徴量の標準化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ランダムフォレストで感情分類
model = RandomForestClassifier(n_estimators=100, random_state=42, max_depth=20)
model.fit(X_train_scaled, y_train)

# 評価
y_pred = model.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)

print("=== 音声感情認識システム ===")
print(f"感情カテゴリ: {emotion_labels}")
print(f"特徴量次元: {X.shape[1]}")
print(f"訓練サンプル数: {len(X_train)}")
print(f"テストサンプル数: {len(X_test)}")
print(f"\n分類精度: {accuracy:.3f}")
print(f"\n詳細レポート:")
print(classification_report(y_test, y_pred, target_names=emotion_labels))

# 混同行列の可視化
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='YlOrRd',
            xticklabels=emotion_labels,
            yticklabels=emotion_labels)
plt.xlabel('予測感情')
plt.ylabel('真の感情')
plt.title('感情認識の混同行列', fontsize=14)
plt.tight_layout()
plt.show()

# 特徴量の重要度
feature_importance = model.feature_importances_
plt.figure(figsize=(12, 6))
plt.bar(range(len(feature_importance)), feature_importance, alpha=0.7)
plt.xlabel('特徴量インデックス')
plt.ylabel('重要度')
plt.title('特徴量の重要度', fontsize=14)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

深層学習による感情認識

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader

class EmotionCNN(nn.Module):
    """
    感情認識用のCNNモデル
    スペクトログラムを入力として受け取る
    """
    def __init__(self, n_emotions=5):
        super(EmotionCNN, self).__init__()

        # Convolutional layers
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)

        self.pool = nn.MaxPool2d(2, 2)
        self.dropout = nn.Dropout(0.3)

        # Fully connected layers
        self.fc1 = nn.Linear(128 * 16 * 16, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, n_emotions)

        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(64)
        self.bn3 = nn.BatchNorm2d(128)

    def forward(self, x):
        # Conv block 1
        x = self.pool(F.relu(self.bn1(self.conv1(x))))
        x = self.dropout(x)

        # Conv block 2
        x = self.pool(F.relu(self.bn2(self.conv2(x))))
        x = self.dropout(x)

        # Conv block 3
        x = self.pool(F.relu(self.bn3(self.conv3(x))))
        x = self.dropout(x)

        # Flatten
        x = x.view(x.size(0), -1)

        # FC layers
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = self.fc3(x)

        return x

# モデルの初期化
model = EmotionCNN(n_emotions=5)
print("=== 感情認識CNNモデル ===")
print(f"総パラメータ数: {sum(p.numel() for p in model.parameters()):,}")

# サンプル入力でテスト（スペクトログラム: 128x128）
sample_input = torch.randn(4, 1, 128, 128)
with torch.no_grad():
    output = model(sample_input)

print(f"\n入力形状: {sample_input.shape}")
print(f"出力形状: {output.shape}")
print(f"出力ロジット（サンプル）:")
print(output[0])

# 簡易訓練デモ
def train_emotion_model(model, X_train, y_train, epochs=10, batch_size=32):
    """
    感情認識モデルの訓練
    """
    # データをTensorに変換
    X_tensor = torch.FloatTensor(X_train).unsqueeze(1).unsqueeze(2)
    y_tensor = torch.LongTensor(y_train)

    # DataLoaderの作成
    dataset = TensorDataset(X_tensor, y_tensor)
    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

    # 損失関数とオプティマイザ
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    # 訓練ループ
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch_X, batch_y in dataloader:
            # 前処理: データを適切な形状に変換
            batch_X_resized = F.interpolate(batch_X, size=(128, 128))

            optimizer.zero_grad()
            outputs = model(batch_X_resized)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()

        avg_loss = total_loss / len(dataloader)
        if (epoch + 1) % 2 == 0:
            print(f"Epoch [{epoch+1}/{epochs}], Loss: {avg_loss:.4f}")

    return model

print("\n=== モデル訓練（デモ）===")
trained_model = train_emotion_model(model, X_train_scaled, y_train, epochs=5)
print("✓ 訓練完了")

5.3 音声強調・ノイズ除去

音声強調の目的

音声強調（Speech Enhancement）は、ノイズを含む音声から目的音声を抽出し、品質を向上させる技術です。

主要な手法

実装例：スペクトル減算

import numpy as np
import librosa
import matplotlib.pyplot as plt
from scipy.signal import wiener

def spectral_subtraction(noisy_signal, sr, noise_estimate_duration=0.5):
    """
    スペクトル減算によるノイズ除去

    Parameters:
    -----------
    noisy_signal : np.ndarray
        ノイズを含む音声信号
    sr : int
        サンプリングレート
    noise_estimate_duration : float
        ノイズ推定に使用する冒頭の時間（秒）

    Returns:
    --------
    enhanced_signal : np.ndarray
        強調された音声信号
    """
    # STFT
    n_fft = 2048
    hop_length = 512

    D = librosa.stft(noisy_signal, n_fft=n_fft, hop_length=hop_length)
    magnitude = np.abs(D)
    phase = np.angle(D)

    # ノイズスペクトルの推定（冒頭部分を使用）
    noise_frames = int(noise_estimate_duration * sr / hop_length)
    noise_spectrum = np.mean(magnitude[:, :noise_frames], axis=1, keepdims=True)

    # スペクトル減算
    alpha = 2.0  # 減算係数
    enhanced_magnitude = magnitude - alpha * noise_spectrum

    # 負の値を0にクリップ
    enhanced_magnitude = np.maximum(enhanced_magnitude, 0)

    # 位相を元に戻して逆STFT
    enhanced_D = enhanced_magnitude * np.exp(1j * phase)
    enhanced_signal = librosa.istft(enhanced_D, hop_length=hop_length)

    return enhanced_signal

# サンプル音声の生成
sr = 22050
duration = 3.0
t = np.linspace(0, duration, int(sr * duration))

# クリーンな音声信号（正弦波の組み合わせ）
clean_signal = (
    np.sin(2 * np.pi * 440 * t) +  # A4音
    0.5 * np.sin(2 * np.pi * 880 * t)  # A5音
)

# ノイズを追加
noise = np.random.randn(len(clean_signal)) * 0.3
noisy_signal = clean_signal + noise

# スペクトル減算を適用
enhanced_signal = spectral_subtraction(noisy_signal, sr)

# SNRの計算
def calculate_snr(signal, noise):
    signal_power = np.mean(signal ** 2)
    noise_power = np.mean(noise ** 2)
    snr = 10 * np.log10(signal_power / noise_power)
    return snr

snr_before = calculate_snr(clean_signal, noisy_signal - clean_signal)
snr_after = calculate_snr(clean_signal, enhanced_signal[:len(clean_signal)] - clean_signal)

print("=== スペクトル減算によるノイズ除去 ===")
print(f"SNR（処理前）: {snr_before:.2f} dB")
print(f"SNR（処理後）: {snr_after:.2f} dB")
print(f"改善: {snr_after - snr_before:.2f} dB")

# 可視化
fig, axes = plt.subplots(3, 2, figsize=(15, 12))

# 時間領域の波形
axes[0, 0].plot(t[:1000], clean_signal[:1000], alpha=0.7)
axes[0, 0].set_title('クリーン信号', fontsize=12)
axes[0, 0].set_xlabel('時間 (秒)')
axes[0, 0].set_ylabel('振幅')
axes[0, 0].grid(True, alpha=0.3)

axes[1, 0].plot(t[:1000], noisy_signal[:1000], alpha=0.7, color='orange')
axes[1, 0].set_title('ノイズ付加信号', fontsize=12)
axes[1, 0].set_xlabel('時間 (秒)')
axes[1, 0].set_ylabel('振幅')
axes[1, 0].grid(True, alpha=0.3)

axes[2, 0].plot(t[:len(enhanced_signal)][:1000], enhanced_signal[:1000],
                alpha=0.7, color='green')
axes[2, 0].set_title('強調信号（スペクトル減算後）', fontsize=12)
axes[2, 0].set_xlabel('時間 (秒)')
axes[2, 0].set_ylabel('振幅')
axes[2, 0].grid(True, alpha=0.3)

# スペクトログラム
D_clean = librosa.stft(clean_signal)
D_noisy = librosa.stft(noisy_signal)
D_enhanced = librosa.stft(enhanced_signal)

axes[0, 1].imshow(librosa.amplitude_to_db(np.abs(D_clean), ref=np.max),
                  aspect='auto', origin='lower', cmap='viridis')
axes[0, 1].set_title('クリーン（スペクトログラム）', fontsize=12)
axes[0, 1].set_ylabel('周波数')

axes[1, 1].imshow(librosa.amplitude_to_db(np.abs(D_noisy), ref=np.max),
                  aspect='auto', origin='lower', cmap='viridis')
axes[1, 1].set_title('ノイズ付加（スペクトログラム）', fontsize=12)
axes[1, 1].set_ylabel('周波数')

axes[2, 1].imshow(librosa.amplitude_to_db(np.abs(D_enhanced), ref=np.max),
                  aspect='auto', origin='lower', cmap='viridis')
axes[2, 1].set_title('強調後（スペクトログラム）', fontsize=12)
axes[2, 1].set_xlabel('時間フレーム')
axes[2, 1].set_ylabel('周波数')

plt.tight_layout()
plt.show()

noisereduceライブラリの使用

import noisereduce as nr

# noisereduceを使用したノイズ除去
reduced_noise_signal = nr.reduce_noise(
    y=noisy_signal,
    sr=sr,
    stationary=True,
    prop_decrease=1.0
)

# SNR計算
snr_noisereduce = calculate_snr(clean_signal,
                                reduced_noise_signal[:len(clean_signal)] - clean_signal)

print("\n=== noisereduceライブラリ ===")
print(f"SNR（処理後）: {snr_noisereduce:.2f} dB")
print(f"改善: {snr_noisereduce - snr_before:.2f} dB")

# 比較可視化
plt.figure(figsize=(15, 8))

plt.subplot(4, 1, 1)
plt.plot(t[:1000], clean_signal[:1000])
plt.title('クリーン信号', fontsize=12)
plt.ylabel('振幅')
plt.grid(True, alpha=0.3)

plt.subplot(4, 1, 2)
plt.plot(t[:1000], noisy_signal[:1000], color='orange')
plt.title(f'ノイズ付加信号 (SNR: {snr_before:.1f} dB)', fontsize=12)
plt.ylabel('振幅')
plt.grid(True, alpha=0.3)

plt.subplot(4, 1, 3)
plt.plot(t[:len(enhanced_signal)][:1000], enhanced_signal[:1000], color='green')
plt.title(f'スペクトル減算 (SNR: {snr_after:.1f} dB)', fontsize=12)
plt.ylabel('振幅')
plt.grid(True, alpha=0.3)

plt.subplot(4, 1, 4)
plt.plot(t[:len(reduced_noise_signal)][:1000], reduced_noise_signal[:1000],
         color='red')
plt.title(f'noisereduce (SNR: {snr_noisereduce:.1f} dB)', fontsize=12)
plt.xlabel('時間 (秒)')
plt.ylabel('振幅')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

注意: noisereduceライブラリはpip install noisereduceでインストールできます。

5.4 音楽情報処理

音楽情報処理（MIR）の概要

音楽情報処理（Music Information Retrieval, MIR）は、音楽信号から情報を抽出・分析する技術です。

主要なタスク

実装例：ビートトラッキング

import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

def beat_tracking_demo():
    """
    ビートトラッキングのデモンストレーション
    """
    # サンプル音楽信号の生成（ドラムビート風）
    sr = 22050
    duration = 8.0
    t = np.linspace(0, duration, int(sr * duration))

    # 120 BPM (2 beats per second)
    bpm = 120
    beat_interval = 60.0 / bpm

    # ビート位置でキックドラムのような音を生成
    signal = np.zeros(len(t))
    for beat_time in np.arange(0, duration, beat_interval):
        beat_sample = int(beat_time * sr)
        if beat_sample < len(signal):
            # キックドラムの模擬（減衰する低周波）
            kick_duration = int(0.1 * sr)
            kick_t = np.linspace(0, 0.1, kick_duration)
            kick = np.sin(2 * np.pi * 80 * kick_t) * np.exp(-kick_t * 30)

            end_idx = min(beat_sample + kick_duration, len(signal))
            signal[beat_sample:end_idx] += kick[:end_idx - beat_sample]

    # ノイズを少し追加
    signal += np.random.randn(len(signal)) * 0.05

    # ビート検出
    tempo, beat_frames = librosa.beat.beat_track(y=signal, sr=sr)
    beat_times = librosa.frames_to_time(beat_frames, sr=sr)

    print("=== ビートトラッキング ===")
    print(f"推定テンポ: {tempo:.1f} BPM")
    print(f"検出されたビート数: {len(beat_times)}")
    print(f"ビート間隔: {np.mean(np.diff(beat_times)):.3f} 秒")

    # オンセット強度の計算
    onset_env = librosa.onset.onset_strength(y=signal, sr=sr)
    times = librosa.frames_to_time(np.arange(len(onset_env)), sr=sr)

    # 可視化
    fig, axes = plt.subplots(3, 1, figsize=(14, 10))

    # 波形とビート位置
    axes[0].plot(t, signal, alpha=0.6)
    axes[0].vlines(beat_times, -1, 1, color='r', alpha=0.8,
                   linestyle='--', label='検出されたビート')
    axes[0].set_xlabel('時間 (秒)')
    axes[0].set_ylabel('振幅')
    axes[0].set_title(f'音声波形とビート検出（推定テンポ: {tempo:.1f} BPM）', fontsize=12)
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)

    # オンセット強度
    axes[1].plot(times, onset_env, alpha=0.7, color='green')
    axes[1].vlines(beat_times, 0, onset_env.max(), color='r',
                   alpha=0.8, linestyle='--')
    axes[1].set_xlabel('時間 (秒)')
    axes[1].set_ylabel('強度')
    axes[1].set_title('オンセット強度とビート位置', fontsize=12)
    axes[1].grid(True, alpha=0.3)

    # テンポグラム
    tempogram = librosa.feature.tempogram(y=signal, sr=sr)
    axes[2].imshow(tempogram, aspect='auto', origin='lower', cmap='magma')
    axes[2].set_xlabel('時間フレーム')
    axes[2].set_ylabel('テンポ (BPM)')
    axes[2].set_title('テンポグラム', fontsize=12)

    plt.tight_layout()
    plt.show()

    return signal, sr, tempo, beat_times

# 実行
signal, sr, tempo, beat_times = beat_tracking_demo()

実装例：音楽ジャンル分類

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score

def extract_music_features(audio, sr):
    """
    音楽ジャンル分類用の特徴量を抽出
    """
    features = []

    # 1. MFCCの統計量
    mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=20)
    features.extend(np.mean(mfcc, axis=1))
    features.extend(np.std(mfcc, axis=1))

    # 2. クロマ特徴
    chroma = librosa.feature.chroma_stft(y=audio, sr=sr)
    features.extend(np.mean(chroma, axis=1))
    features.extend(np.std(chroma, axis=1))

    # 3. スペクトル特徴
    spectral_centroids = librosa.feature.spectral_centroid(y=audio, sr=sr)[0]
    features.append(np.mean(spectral_centroids))
    features.append(np.std(spectral_centroids))

    spectral_rolloff = librosa.feature.spectral_rolloff(y=audio, sr=sr)[0]
    features.append(np.mean(spectral_rolloff))
    features.append(np.std(spectral_rolloff))

    # 4. ゼロ交差率
    zcr = librosa.feature.zero_crossing_rate(audio)[0]
    features.append(np.mean(zcr))
    features.append(np.std(zcr))

    # 5. テンポ
    tempo, _ = librosa.beat.beat_track(y=audio, sr=sr)
    features.append(tempo)

    # 6. ハーモニック・パーカッシブ成分
    y_harmonic, y_percussive = librosa.effects.hpss(audio)
    harmonic_ratio = np.sum(y_harmonic**2) / (np.sum(audio**2) + 1e-6)
    features.append(harmonic_ratio)

    return np.array(features)

# ジャンル分類のデモ
def music_genre_classification():
    """
    音楽ジャンル分類のデモンストレーション
    """
    np.random.seed(42)

    # 仮想的なジャンルデータを生成
    genres = ['Classical', 'Jazz', 'Rock', 'Electronic', 'Hip-Hop']
    n_samples_per_genre = 30

    X = []
    y = []

    for genre_id, genre in enumerate(genres):
        # 各ジャンルに特徴的なパターンを生成
        base_features = np.random.randn(51) + genre_id * 1.5

        for _ in range(n_samples_per_genre):
            sample = base_features + np.random.randn(51) * 0.4
            X.append(sample)
            y.append(genre_id)

    X = np.array(X)
    y = np.array(y)

    # モデルの訓練と評価（交差検証）
    model = GradientBoostingClassifier(n_estimators=100, random_state=42)
    scores = cross_val_score(model, X, y, cv=5)

    print("\n=== 音楽ジャンル分類 ===")
    print(f"ジャンル: {genres}")
    print(f"サンプル数: {len(X)}")
    print(f"特徴量次元: {X.shape[1]}")
    print(f"\n交差検証精度: {scores.mean():.3f} (+/- {scores.std():.3f})")

    # モデルを全データで訓練
    model.fit(X, y)

    # 特徴量の重要度（上位10個）
    feature_importance = model.feature_importances_
    top_10_idx = np.argsort(feature_importance)[-10:]

    plt.figure(figsize=(10, 6))
    plt.barh(range(10), feature_importance[top_10_idx], alpha=0.7)
    plt.xlabel('重要度')
    plt.ylabel('特徴量インデックス')
    plt.title('重要な特徴量（上位10個）', fontsize=14)
    plt.yticks(range(10), top_10_idx)
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()

    return model, genres

model, genres = music_genre_classification()

5.5 エンドツーエンド音声AIアプリケーション

統合音声処理システム

実世界のアプリケーションでは、複数の音声処理技術を組み合わせて使用します。

実装例：統合音声処理パイプライン

import numpy as np
import librosa
from dataclasses import dataclass
from typing import Tuple, Optional

@dataclass
class AudioProcessingResult:
    """音声処理の結果を格納"""
    is_verified: bool
    speaker_similarity: float
    emotion: Optional[str]
    emotion_confidence: float
    enhanced_audio: np.ndarray
    processing_time: float

class IntegratedAudioPipeline:
    """
    統合音声処理パイプライン

    機能:
    1. ノイズ除去
    2. 話者検証
    3. 感情認識
    """
    def __init__(self, verification_threshold=0.7):
        self.verification_threshold = verification_threshold
        self.enrolled_speakers = {}

        # モデルの初期化（実際にはロード）
        self.emotion_labels = ['neutral', 'happy', 'sad', 'angry', 'fear']

    def preprocess_audio(self, audio, sr):
        """
        音声の前処理
        1. リサンプリング
        2. ノイズ除去
        """
        # 16kHzにリサンプリング
        if sr != 16000:
            audio = librosa.resample(audio, orig_sr=sr, target_sr=16000)
            sr = 16000

        # ノイズ除去（簡易版）
        try:
            import noisereduce as nr
            audio_enhanced = nr.reduce_noise(y=audio, sr=sr, stationary=True)
        except:
            # noisereduceがない場合はそのまま
            audio_enhanced = audio

        return audio_enhanced, sr

    def extract_embedding(self, audio, sr):
        """
        話者埋め込みベクトルを抽出
        """
        # MFCCベースの簡易埋め込み
        mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=20)
        mfcc_delta = librosa.feature.delta(mfcc)

        embedding = np.concatenate([
            np.mean(mfcc, axis=1),
            np.std(mfcc, axis=1),
            np.mean(mfcc_delta, axis=1),
            np.std(mfcc_delta, axis=1)
        ])

        return embedding

    def verify_speaker(self, audio, sr, speaker_id):
        """
        話者検証
        """
        if speaker_id not in self.enrolled_speakers:
            return False, 0.0

        # 埋め込み抽出
        test_embedding = self.extract_embedding(audio, sr)
        enrolled_embedding = self.enrolled_speakers[speaker_id]

        # コサイン類似度
        from scipy.spatial.distance import cosine
        similarity = 1 - cosine(test_embedding, enrolled_embedding)

        is_verified = similarity > self.verification_threshold

        return is_verified, similarity

    def recognize_emotion(self, audio, sr):
        """
        感情認識
        """
        # 特徴抽出（簡易版）
        mfcc = librosa.feature.mfcc(y=audio, sr=sr, n_mfcc=13)
        chroma = librosa.feature.chroma_stft(y=audio, sr=sr)

        features = np.concatenate([
            np.mean(mfcc, axis=1),
            np.std(mfcc, axis=1),
            np.mean(chroma, axis=1)
        ])

        # 簡易的な感情分類（実際にはモデルを使用）
        # ここではランダムに選択
        emotion_idx = np.random.randint(0, len(self.emotion_labels))
        confidence = np.random.uniform(0.7, 0.95)

        return self.emotion_labels[emotion_idx], confidence

    def process(self, audio, sr, speaker_id=None):
        """
        統合処理パイプライン

        Parameters:
        -----------
        audio : np.ndarray
            入力音声
        sr : int
            サンプリングレート
        speaker_id : str, optional
            検証する話者ID

        Returns:
        --------
        result : AudioProcessingResult
            処理結果
        """
        import time
        start_time = time.time()

        # 1. 前処理（ノイズ除去）
        enhanced_audio, sr = self.preprocess_audio(audio, sr)

        # 2. 話者検証
        is_verified = True
        similarity = 1.0
        if speaker_id is not None:
            is_verified, similarity = self.verify_speaker(enhanced_audio, sr, speaker_id)

        # 3. 感情認識（検証が通った場合のみ）
        emotion = None
        emotion_confidence = 0.0
        if is_verified:
            emotion, emotion_confidence = self.recognize_emotion(enhanced_audio, sr)

        processing_time = time.time() - start_time

        result = AudioProcessingResult(
            is_verified=is_verified,
            speaker_similarity=similarity,
            emotion=emotion,
            emotion_confidence=emotion_confidence,
            enhanced_audio=enhanced_audio,
            processing_time=processing_time
        )

        return result

    def enroll_speaker(self, speaker_id, audio, sr):
        """
        話者を登録
        """
        audio_enhanced, sr = self.preprocess_audio(audio, sr)
        embedding = self.extract_embedding(audio_enhanced, sr)
        self.enrolled_speakers[speaker_id] = embedding
        print(f"✓ 話者 '{speaker_id}' を登録しました")

# パイプラインのデモンストレーション
print("=== 統合音声処理パイプライン ===\n")

# パイプラインの初期化
pipeline = IntegratedAudioPipeline(verification_threshold=0.7)

# サンプル音声の生成
sr = 16000
duration = 3.0
t = np.linspace(0, duration, int(sr * duration))

# 話者Aの音声
audio_speaker_a = np.sin(2 * np.pi * 300 * t) + 0.3 * np.random.randn(len(t))
# 話者Bの音声
audio_speaker_b = np.sin(2 * np.pi * 500 * t) + 0.3 * np.random.randn(len(t))

# 話者を登録
pipeline.enroll_speaker("Alice", audio_speaker_a, sr)
pipeline.enroll_speaker("Bob", audio_speaker_b, sr)

print(f"\n登録話者: {list(pipeline.enrolled_speakers.keys())}\n")

# テスト1: Aliceの本人音声
print("【テスト1】Alice（本人）の音声")
test_audio_alice = audio_speaker_a + 0.1 * np.random.randn(len(audio_speaker_a))
result = pipeline.process(test_audio_alice, sr, speaker_id="Alice")

print(f"  話者検証: {'✓ 承認' if result.is_verified else '✗ 拒否'}")
print(f"  類似度: {result.speaker_similarity:.3f}")
print(f"  感情: {result.emotion} (信頼度: {result.emotion_confidence:.2%})")
print(f"  処理時間: {result.processing_time*1000:.1f} ms")

# テスト2: Aliceになりすまし（Bobの音声）
print("\n【テスト2】Alice（なりすまし: Bob）の音声")
result = pipeline.process(audio_speaker_b, sr, speaker_id="Alice")

print(f"  話者検証: {'✓ 承認' if result.is_verified else '✗ 拒否'}")
print(f"  類似度: {result.speaker_similarity:.3f}")
print(f"  感情: {result.emotion if result.emotion else 'N/A'}")
print(f"  処理時間: {result.processing_time*1000:.1f} ms")

# テスト3: Bobの本人音声
print("\n【テスト3】Bob（本人）の音声")
test_audio_bob = audio_speaker_b + 0.1 * np.random.randn(len(audio_speaker_b))
result = pipeline.process(test_audio_bob, sr, speaker_id="Bob")

print(f"  話者検証: {'✓ 承認' if result.is_verified else '✗ 拒否'}")
print(f"  類似度: {result.speaker_similarity:.3f}")
print(f"  感情: {result.emotion} (信頼度: {result.emotion_confidence:.2%})")
print(f"  処理時間: {result.processing_time*1000:.1f} ms")

print("\n" + "="*50)
print("統合パイプライン処理完了")
print("="*50)

リアルタイム処理の考慮事項

5.6 本章のまとめ

学んだこと

1. 話者認識・検証

   • 話者識別と話者検証の違い
   • i-vector、x-vectorによる話者埋め込み
   • 類似度計算による検証システム

2. 音声感情認識

   • 韻律・音響特徴による感情推定
   • RAVDESS、IEMOCAPなどのデータセット
   • CNN/LSTMによる深層学習アプローチ

3. 音声強調・ノイズ除去

   • スペクトル減算、ウィーナーフィルタ
   • 深層学習による強調
   • noisereduceライブラリの活用

4. 音楽情報処理

   • ビートトラッキング、テンポ推定
   • コード認識、ジャンル分類
   • 音楽的特徴量の抽出

5. 統合システム

   • 複数技術の組み合わせ
   • エンドツーエンドパイプライン
   • リアルタイム処理の最適化

実世界への応用例

さらに学ぶために

• データセット: VoxCeleb、LibriSpeech、GTZAN、MusicNet
• ライブラリ: pyannote.audio、speechbrain、essentia
• 最新手法: WavLM、Conformer、U-Net for audio
• 評価指標: EER（Equal Error Rate）、DER（Diarization Error Rate）

演習問題

問題1（難易度：easy）

話者識別（Speaker Identification）と話者検証（Speaker Verification）の違いを説明し、それぞれの応用例を挙げてください。

問題2（難易度：medium）

音声感情認識において、韻律特徴（ピッチ、エネルギー、話速）と各感情（喜び、悲しみ、怒り、恐怖）の関係を説明してください。

問題3（難易度：medium）

スペクトル減算（Spectral Subtraction）によるノイズ除去の原理を説明し、この手法の利点と欠点を述べてください。

問題4（難易度：hard）

x-vectorネットワークのアーキテクチャを説明し、従来のi-vectorと比較した利点を述べてください。また、Statistics Pooling層の役割を説明してください。

import torch
import torch.nn as nn

class StatisticsPooling(nn.Module):
    def forward(self, x):
        # x: (batch, features, time)
        mean = torch.mean(x, dim=2)  # (batch, features)
        std = torch.std(x, dim=2)    # (batch, features)
        stats = torch.cat([mean, std], dim=1)  # (batch, features*2)
        return stats

問題5（難易度：hard）

統合音声処理パイプラインを設計する際の主要な考慮事項を挙げ、リアルタイム処理を実現するための最適化手法を説明してください。

import torch
import numpy as np
from queue import Queue
from threading import Thread

class OptimizedAudioPipeline:
    def __init__(self):
        # モデルの量子化
        self.model = torch.quantization.quantize_dynamic(
            load_model(), {torch.nn.Linear}, dtype=torch.qint8
        )
        self.model.eval()

        # キャッシュ
        self.speaker_cache = {}

        # ストリーム処理用バッファ
        self.audio_buffer = Queue(maxsize=100)

        # ワーカースレッド
        self.workers = [
            Thread(target=self._process_worker)
            for _ in range(4)
        ]
        for w in self.workers:
            w.start()

    def process_stream(self, audio_chunk):
        """ストリーミング処理"""
        # 非ブロッキングで追加
        if not self.audio_buffer.full():
            self.audio_buffer.put(audio_chunk)

    def _process_worker(self):
        """ワーカースレッドの処理"""
        while True:
            chunk = self.audio_buffer.get()

            # 1. 高速ノイズ除去
            clean_chunk = self._fast_denoise(chunk)

            # 2. 特徴抽出（GPU）
            with torch.no_grad():
                features = self._extract_features(clean_chunk)

            # 3. キャッシュチェック
            speaker_id = self._identify_speaker_cached(features)

            # 4. 結果の返却
            self._emit_result(speaker_id, features)

    def _fast_denoise(self, audio):
        """軽量なノイズ除去"""
        # スペクトル減算（FFT最小限）
        return spectral_subtract_fast(audio)

    def _identify_speaker_cached(self, features):
        """キャッシュを使った話者識別"""
        # 特徴量のハッシュ
        feat_hash = hash(features.tobytes())

        if feat_hash in self.speaker_cache:
            return self.speaker_cache[feat_hash]

        # 新規計算
        speaker_id = self.model(features)
        self.speaker_cache[feat_hash] = speaker_id

        return speaker_id

# 使用例
pipeline = OptimizedAudioPipeline()

# リアルタイム処理
for chunk in audio_stream:
    pipeline.process_stream(chunk)

参考文献

1. Snyder, D., Garcia-Romero, D., Sell, G., Povey, D., & Khudanpur, S. (2018). X-vectors: Robust DNN embeddings for speaker recognition. ICASSP 2018.
2. Livingstone, S. R., & Russo, F. A. (2018). The Ryerson Audio-Visual Database of Emotional Speech and Song (RAVDESS). PLOS ONE.
3. Loizou, P. C. (2013). Speech Enhancement: Theory and Practice (2nd ed.). CRC Press.
4. Müller, M. (2015). Fundamentals of Music Processing. Springer.
5. Dehak, N., Kenny, P. J., Dehak, R., Dumouchel, P., & Ouellet, P. (2011). Front-end factor analysis for speaker verification. IEEE Transactions on Audio, Speech, and Language Processing.
6. Schuller, B., Steidl, S., & Batliner, A. (2009). The INTERSPEECH 2009 emotion challenge. INTERSPEECH 2009.
7. Boll, S. F. (1979). Suppression of acoustic noise in speech using spectral subtraction. IEEE Transactions on Acoustics, Speech, and Signal Processing.
8. Tzanetakis, G., & Cook, P. (2002). Musical genre classification of audio signals. IEEE Transactions on Speech and Audio Processing.