不明瞭な録音を修復する方法：音声強調と修復の完全ガイド

---

一般的な音声問題を理解する

よくある音質の問題

1. 音量が小さい - 声が小さい、または遠い
2. 背景ノイズ - 交通音、ファン、キーボード入力音など
3. 歪み/クリッピング - 過増幅や飽和による歪み
4. エコー/リバーブ - 室内音響による反響
5. 周波数バランスの崩れ - 低域または高域の不足
6. 圧縮アーティファクト - 低品質エンコードによる劣化
7. DCオフセット - 電気的オフセットによる歪み
8. 音量のばらつき - 録音全体でレベルが不均一
9. こもった話し声 - 不明瞭でこもった音声
10. 電話品質 - 低サンプルレート（8 kHz）の録音

音声問題の診断

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

def diagnose_audio_issues(audio_path):
    """
    Analyze audio file and identify quality issues.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    issues = []
    
    # Check volume level
    max_amplitude = np.max(np.abs(audio))
    rms = np.sqrt(np.mean(audio**2))
    
    if max_amplitude < 0.1:
        issues.append("Low volume - audio is too quiet")
    elif max_amplitude > 0.95:
        issues.append("Clipping detected - audio may be distorted")
    
    if rms < 0.01:
        issues.append("Very low RMS - signal is very weak")
    
    # Check DC offset
    dc_offset = np.mean(audio)
    if abs(dc_offset) > 0.01:
        issues.append(f"DC offset detected: {dc_offset:.4f}")
    
    # Check for silence
    silence_ratio = np.sum(np.abs(audio) < 0.01) / len(audio)
    if silence_ratio > 0.5:
        issues.append(f"High silence ratio: {silence_ratio:.1%}")
    
    # Check sample rate
    if sr < 16000:
        issues.append(f"Low sample rate: {sr} Hz (recommended: 16 kHz+)")
    
    # Check dynamic range
    dynamic_range = 20 * np.log10(max_amplitude / (rms + 1e-10))
    if dynamic_range < 10:
        issues.append("Low dynamic range - audio may be over-compressed")
    
    return {
        "sample_rate": sr,
        "duration": len(audio) / sr,
        "max_amplitude": max_amplitude,
        "rms": rms,
        "dc_offset": dc_offset,
        "issues": issues
    }

# Usage
diagnosis = diagnose_audio_issues("unclear_recording.mp3")
print("Audio Issues Found:")
for issue in diagnosis["issues"]:
    print(f"  - {issue}")

---

修復 1: 音量の正規化と増幅

方法 1: ピーク正規化

import librosa
import soundfile as sf
import numpy as np

def normalize_volume(audio_path, output_path="normalized.wav", target_db=-3.0):
    """
    Normalize audio to target peak level.
    
    Args:
        audio_path: Input audio file
        output_path: Output file path
        target_db: Target peak level in dB (default -3dB for safety)
    """
    # Load audio
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Remove DC offset first
    audio = audio - np.mean(audio)
    
    # Calculate current peak
    max_val = np.max(np.abs(audio))
    
    if max_val > 0:
        # Calculate gain needed
        current_db = 20 * np.log10(max_val)
        gain_db = target_db - current_db
        gain_linear = 10 ** (gain_db / 20)
        
        # Apply gain
        normalized = audio * gain_linear
        
        # Prevent clipping
        normalized = np.clip(normalized, -1.0, 1.0)
    else:
        normalized = audio
    
    # Save
    sf.write(output_path, normalized, sr)
    
    print(f"✓ Normalized: {current_db:.1f} dB -> {target_db:.1f} dB")
    return output_path

# Usage
normalized = normalize_volume("quiet_recording.mp3", target_db=-3.0)

方法 2: RMS正規化（ラウドネス正規化）

def normalize_rms(audio_path, output_path="normalized_rms.wav", target_rms=0.1):
    """
    Normalize audio to target RMS level (loudness normalization).
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Remove DC offset
    audio = audio - np.mean(audio)
    
    # Calculate current RMS
    current_rms = np.sqrt(np.mean(audio**2))
    
    if current_rms > 0:
        # Calculate gain
        gain = target_rms / current_rms
        
        # Apply gain
        normalized = audio * gain
        
        # Prevent clipping
        normalized = np.clip(normalized, -1.0, 1.0)
    else:
        normalized = audio
    
    # Save
    sf.write(output_path, normalized, sr)
    
    print(f"✓ RMS normalized: {current_rms:.4f} -> {target_rms:.4f}")
    return output_path

# Usage
normalized = normalize_rms("variable_volume.mp3", target_rms=0.15)

方法 3: ダイナミックレンジ圧縮

def compress_dynamic_range(audio_path, output_path="compressed.wav", 
                          ratio=3.0, threshold=-12.0):
    """
    Apply dynamic range compression to even out volume levels.
    
    Args:
        audio_path: Input audio file
        output_path: Output file path
        ratio: Compression ratio (higher = more compression)
        threshold: Threshold in dB where compression starts
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Remove DC offset
    audio = audio - np.mean(audio)
    
    # Convert to dB
    threshold_linear = 10 ** (threshold / 20)
    
    # Apply compression
    compressed = np.copy(audio)
    
    # Find samples above threshold
    above_threshold = np.abs(audio) > threshold_linear
    
    if np.any(above_threshold):
        # Calculate compression
        excess = np.abs(audio[above_threshold]) - threshold_linear
        compressed_amount = excess / ratio
        
        # Apply compression
        sign = np.sign(audio[above_threshold])
        compressed[above_threshold] = sign * (threshold_linear + compressed_amount)
    
    # Normalize to prevent clipping
    max_val = np.max(np.abs(compressed))
    if max_val > 0.95:
        compressed = compressed * (0.95 / max_val)
    
    # Save
    sf.write(output_path, compressed, sr)
    
    print(f"✓ Dynamic range compressed (ratio: {ratio}, threshold: {threshold} dB)")
    return output_path

# Usage
compressed = compress_dynamic_range("inconsistent_volume.mp3", ratio=4.0, threshold=-10.0)

---

修復 2: ノイズ低減

方法 1: スペクトル減算

import noisereduce as nr
import librosa
import soundfile as sf

def reduce_noise_spectral(audio_path, output_path="denoised.wav", 
                         stationary=False, prop_decrease=0.8):
    """
    Reduce background noise using spectral subtraction.
    
    Args:
        audio_path: Input audio file
        output_path: Output file path
        stationary: True for constant noise, False for variable noise
        prop_decrease: Amount of noise to reduce (0.0-1.0)
    """
    # Load audio
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Reduce noise
    reduced_noise = nr.reduce_noise(
        y=audio,
        sr=sr,
        stationary=stationary,
        prop_decrease=prop_decrease
    )
    
    # Save
    sf.write(output_path, reduced_noise, sr)
    
    print(f"✓ Noise reduced (prop_decrease: {prop_decrease})")
    return output_path

# Usage
# For constant noise (fan, AC)
denoised = reduce_noise_spectral("noisy_recording.mp3", stationary=True, prop_decrease=0.7)

# For variable noise (traffic, crowds)
denoised = reduce_noise_spectral("noisy_recording.mp3", stationary=False, prop_decrease=0.8)

方法 2: VADを使った高度なノイズ低減

def reduce_noise_advanced(audio_path, output_path="denoised_advanced.wav"):
    """
    Advanced noise reduction with voice activity detection.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # First pass: aggressive noise reduction
    reduced = nr.reduce_noise(
        y=audio,
        sr=sr,
        stationary=False,
        prop_decrease=0.9
    )
    
    # Second pass: gentle cleanup
    reduced = nr.reduce_noise(
        y=reduced,
        sr=sr,
        stationary=True,
        prop_decrease=0.3
    )
    
    # Save
    sf.write(output_path, reduced, sr)
    
    print("✓ Advanced noise reduction applied")
    return output_path

# Usage
denoised = reduce_noise_advanced("very_noisy.mp3")

方法 3: 周波数別ノイズ低減

import scipy.signal as signal

def reduce_frequency_noise(audio_path, output_path="filtered.wav",
                          low_cut=80, high_cut=8000):
    """
    Remove noise outside speech frequency range.
    
    Args:
        audio_path: Input audio file
        output_path: Output file path
        low_cut: Low frequency cutoff (Hz)
        high_cut: High frequency cutoff (Hz)
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Design bandpass filter for speech frequencies
    nyquist = sr / 2
    low = low_cut / nyquist
    high = high_cut / nyquist
    
    # Butterworth bandpass filter
    b, a = signal.butter(4, [low, high], btype='band')
    filtered = signal.filtfilt(b, a, audio)
    
    # Save
    sf.write(output_path, filtered, sr)
    
    print(f"✓ Frequency filtered: {low_cut}-{high_cut} Hz")
    return output_path

# Usage
filtered = reduce_frequency_noise("noisy_recording.mp3", low_cut=100, high_cut=7000)

---

修復 3: DCオフセットとクリッピングを除去する

DCオフセットを除去する

def remove_dc_offset(audio_path, output_path="no_dc.wav"):
    """
    Remove DC offset from audio.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Calculate and remove DC offset
    dc_offset = np.mean(audio)
    corrected = audio - dc_offset
    
    # Save
    sf.write(output_path, corrected, sr)
    
    print(f"✓ DC offset removed: {dc_offset:.6f}")
    return output_path

# Usage
corrected = remove_dc_offset("distorted_audio.mp3")

クリッピングを修復する

def fix_clipping(audio_path, output_path="unclipped.wav"):
    """
    Attempt to fix clipped audio (limited effectiveness).
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Identify clipped samples
    clipped = np.abs(audio) >= 0.99
    clipped_ratio = np.sum(clipped) / len(audio)
    
    if clipped_ratio > 0.01:  # More than 1% clipped
        # Reduce overall level to prevent further clipping
        max_val = np.max(np.abs(audio))
        if max_val > 0.95:
            audio = audio * (0.9 / max_val)
        
        # Apply gentle smoothing to clipped regions
        from scipy.ndimage import gaussian_filter1d
        audio = gaussian_filter1d(audio, sigma=1.0)
    
    # Save
    sf.write(output_path, audio, sr)
    
    print(f"✓ Clipping addressed (clipped ratio: {clipped_ratio:.2%})")
    return output_path

# Usage
fixed = fix_clipping("clipped_audio.mp3")

---

修復 4: 音声明瞭度に重要な周波数を強調する

方法 1: スペクトル強調

def enhance_speech_frequencies(audio_path, output_path="enhanced.wav",
                              boost_db=3.0):
    """
    Enhance speech frequencies (300-3400 Hz) for clarity.
    
    Args:
        audio_path: Input audio file
        output_path: Output file path
        boost_db: Boost amount in dB
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Compute spectrogram
    stft = librosa.stft(audio)
    magnitude = np.abs(stft)
    phase = np.angle(stft)
    
    # Get frequency bins
    freq_bins = librosa.fft_frequencies(sr=sr)
    
    # Speech frequency range (300-3400 Hz)
    speech_mask = (freq_bins >= 300) & (freq_bins <= 3400)
    
    # Apply boost
    boost_linear = 10 ** (boost_db / 20)
    enhanced_magnitude = magnitude.copy()
    enhanced_magnitude[speech_mask] *= boost_linear
    
    # Reconstruct audio
    enhanced_stft = enhanced_magnitude * np.exp(1j * phase)
    enhanced_audio = librosa.istft(enhanced_stft)
    
    # Normalize to prevent clipping
    max_val = np.max(np.abs(enhanced_audio))
    if max_val > 0.95:
        enhanced_audio = enhanced_audio * (0.95 / max_val)
    
    # Save
    sf.write(output_path, enhanced_audio, sr)
    
    print(f"✓ Speech frequencies enhanced (+{boost_db} dB)")
    return output_path

# Usage
enhanced = enhance_speech_frequencies("muffled_audio.mp3", boost_db=4.0)

方法 2: プリエンファシスフィルター

def apply_preemphasis(audio_path, output_path="preemphasized.wav", coef=0.97):
    """
    Apply preemphasis filter to enhance high frequencies.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Apply preemphasis
    preemphasized = librosa.effects.preemphasis(audio, coef=coef)
    
    # Save
    sf.write(output_path, preemphasized, sr)
    
    print(f"✓ Preemphasis applied (coef: {coef})")
    return output_path

# Usage
enhanced = apply_preemphasis("muffled_audio.mp3", coef=0.97)

---

修復 5: エコーとリバーブを除去する

方法 1: 残響除去（De-reverberation）

def reduce_reverb(audio_path, output_path="deverbed.wav"):
    """
    Reduce reverb and echo using spectral gating.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    # Compute spectrogram
    stft = librosa.stft(audio, hop_length=512, n_fft=2048)
    magnitude = np.abs(stft)
    phase = np.angle(stft)
    
    # Estimate noise floor (assume reverb is in quieter parts)
    noise_floor = np.percentile(magnitude, 10, axis=1, keepdims=True)
    
    # Spectral gating: reduce components below threshold
    threshold = noise_floor * 2.0
    gate = magnitude > threshold
    gated_magnitude = magnitude * gate
    
    # Reconstruct audio
    gated_stft = gated_magnitude * np.exp(1j * phase)
    deverbed = librosa.istft(gated_stft)
    
    # Normalize
    max_val = np.max(np.abs(deverbed))
    if max_val > 0:
        deverbed = deverbed / max_val * 0.9
    
    # Save
    sf.write(output_path, deverbed, sr)
    
    print("✓ Reverb reduced")
    return output_path

# Usage
deverbed = reduce_reverb("echoey_recording.mp3")

---

修復 6: 低サンプルレート音声をアップサンプリングする

def upsample_audio(audio_path, output_path="upsampled.wav", target_sr=16000):
    """
    Upsample audio to target sample rate.
    
    Note: This doesn't restore lost quality, but helps with processing.
    """
    audio, sr = librosa.load(audio_path, sr=None)
    
    if sr < target_sr:
        # Resample to target sample rate
        upsampled = librosa.resample(audio, orig_sr=sr, target_sr=target_sr)
        
        # Save
        sf.write(output_path, upsampled, target_sr)
        
        print(f"✓ Upsampled: {sr} Hz -> {target_sr} Hz")
        return output_path
    else:
        print(f"Audio already at {sr} Hz (target: {target_sr} Hz)")
        return audio_path

# Usage
upsampled = upsample_audio("phone_recording.mp3", target_sr=16000)

---

完全な音声強調パイプライン

import librosa
import soundfile as sf
import numpy as np
import noisereduce as nr
from pathlib import Path

class AudioEnhancer:
    """Complete audio enhancement pipeline."""
    
    def __init__(self):
        self.temp_files = []
    
    def enhance(self, audio_path, output_path="enhanced.wav",
                normalize=True,
                remove_noise=True,
                enhance_speech=True,
                remove_dc=True,
                compress=False):
        """
        Complete audio enhancement pipeline.
        
        Args:
            audio_path: Input audio file
            output_path: Output file path
            normalize: Normalize volume
            remove_noise: Apply noise reduction
            enhance_speech: Enhance speech frequencies
            remove_dc: Remove DC offset
            compress: Apply dynamic range compression
        """
        try:
            # Load audio
            print(f"Loading: {audio_path}")
            audio, sr = librosa.load(audio_path, sr=None)
            original_max = np.max(np.abs(audio))
            
            # Step 1: Remove DC offset
            if remove_dc:
                print("  Removing DC offset...")
                audio = audio - np.mean(audio)
            
            # Step 2: Normalize volume
            if normalize:
                print("  Normalizing volume...")
                max_val = np.max(np.abs(audio))
                if max_val > 0:
                    target_db = -3.0
                    current_db = 20 * np.log10(max_val)
                    gain_db = target_db - current_db
                    gain_linear = 10 ** (gain_db / 20)
                    audio = audio * gain_linear
                    audio = np.clip(audio, -1.0, 1.0)
            
            # Step 3: Noise reduction
            if remove_noise:
                print("  Reducing noise...")
                audio = nr.reduce_noise(
                    y=audio,
                    sr=sr,
                    stationary=False,
                    prop_decrease=0.7
                )
            
            # Step 4: Enhance speech frequencies
            if enhance_speech:
                print("  Enhancing speech frequencies...")
                # Apply preemphasis
                audio = librosa.effects.preemphasis(audio, coef=0.97)
            
            # Step 5: Dynamic range compression
            if compress:
                print("  Compressing dynamic range...")
                threshold = -12.0
                threshold_linear = 10 ** (threshold / 20)
                above_threshold = np.abs(audio) > threshold_linear
                
                if np.any(above_threshold):
                    excess = np.abs(audio[above_threshold]) - threshold_linear
                    compressed_amount = excess / 3.0
                    sign = np.sign(audio[above_threshold])
                    audio[above_threshold] = sign * (threshold_linear + compressed_amount)
            
            # Final normalization
            max_val = np.max(np.abs(audio))
            if max_val > 0.95:
                audio = audio * (0.9 / max_val)
            
            # Save
            sf.write(output_path, audio, sr)
            
            # Report improvements
            new_max = np.max(np.abs(audio))
            print(f"
✓ Enhancement complete:")
            print(f"  Original peak: {original_max:.4f}")
            print(f"  Enhanced peak: {new_max:.4f}")
            print(f"  Saved to: {output_path}")
            
            return output_path
            
        except Exception as e:
            print(f"Error during enhancement: {e}")
            return None

# Usage
enhancer = AudioEnhancer()

enhanced = enhancer.enhance(
    "unclear_recording.mp3",
    output_path="enhanced_recording.wav",
    normalize=True,
    remove_noise=True,
    enhance_speech=True,
    remove_dc=True,
    compress=False
)

---

FFmpegを使ったクイック修復

音量を正規化する

# Normalize to -3dB peak
ffmpeg -i input.mp3 -af "volume=0dB:replaygain_norm=3" normalized.wav

ノイズを低減する

# High-pass filter to remove low-frequency noise
ffmpeg -i input.mp3 -af "highpass=f=80" filtered.wav

# Bandpass filter for speech frequencies
ffmpeg -i input.mp3 -af "bandpass=f=300:width_type=h:w=3000" filtered.wav

正規化とフィルタリング

# Complete enhancement pipeline
ffmpeg -i input.mp3   -af "highpass=f=80,lowpass=f=8000,volume=0dB:replaygain_norm=3"   enhanced.wav

DCオフセットを除去する

ffmpeg -i input.mp3 -af "highpass=f=1" no_dc.wav

---

不明瞭な録音を修復するためのベストプラクティス

1. まず診断する

2. 順序どおりに修復を適用する

1. DCオフセットを除去
2. 音量を正規化
3. ノイズを低減
4. 音声明瞭度に重要な周波数を強調
5. 圧縮を適用（必要な場合）

3. 過剰処理しない

4. 段階的にテストする

5. 元ファイルを保持する

6. 適切なツールを使う

• Python (librosa, noisereduce): プログラムでの処理に最適
• FFmpeg: コマンドラインでの素早い修復
• Audacity: 手動編集と微調整
• Professional tools: 重要用途向け

---

よくある問題と解決策

問題 1: 強調後も音声が不明瞭

• より大きなWhisperモデル（medium または large）を使う
• 文字起こし時にコンテキストプロンプトを与える
• ノイズ低減設定を変えて試す
• 重要な箇所は手動編集を検討する

問題 2: 処理でアーティファクトが発生する

• 処理強度を下げる
• 修復を1つずつ適用する
• より穏やかな設定を使う
• 別のアルゴリズムを試す

問題 3: 音量が非常に小さい音声

• -3dB（安全レベル）に正規化する
• 軽めの圧縮を適用する
• 音声明瞭度に重要な周波数を強調する
• large Whisperモデルを使う

問題 4: 電話品質の録音

• 16 kHzにアップサンプリングする
• medium または large Whisperモデルを使う
• ノイズ低減を適用する
• 音声明瞭度に重要な周波数を強調する

---

ユースケース

1. 静かな会議録音を修復する

enhancer = AudioEnhancer()
enhanced = enhancer.enhance(
    "quiet_meeting.mp3",
    normalize=True,
    remove_noise=True,
    enhance_speech=True
)

2. インタビューの背景ノイズを除去する

# Reduce variable noise (traffic, crowds)
denoised = reduce_noise_spectral(
    "noisy_interview.mp3",
    stationary=False,
    prop_decrease=0.8
)

3. 不均一な音量を修復する

# Normalize and compress
normalized = normalize_volume("variable_volume.mp3")
compressed = compress_dynamic_range(normalized, ratio=4.0)

4. 電話録音を強調する

# Upsample and enhance
upsampled = upsample_audio("phone_recording.mp3", target_sr=16000)
enhanced = enhance_speech_frequencies(upsampled, boost_db=3.0)

---

まとめ

1. 修復を適用する前に問題を診断する
2. 一貫したレベルにするため音量を正規化する
3. 必要に応じてノイズを低減する
4. 明瞭度向上のため音声明瞭度に重要な周波数を強調する
5. アーティファクトを除去する（DCオフセット、クリッピング）
6. 用途に合わせて適切なツールを使う

• まず音声問題を診断する
• 正しい順序で修復を適用する
• 過剰処理しない（少ないほうが良いことが多い）
• 比較のため元ファイルを保持する
• 段階的にテストして改善を確認する
• 強調済み音声にはより大きいWhisperモデルを使う

---