extract_melfilter.py

# mean-normalized Mel filter bank log-energies

import torch
import torchaudio
import numpy as np
import torch.nn.functional as F

class AudioFeatureExtractor:
    def __init__(self,
                 sample_rate=16000,
                 n_fft=512,
                 win_length=400,  # 25ms
                 hop_length=240,  # 15ms
                 n_mels=72,
                 f_min=20,
                 f_max=7600,
                 pre_emphasis=0.97,
                 ref_level_db=20,
                 min_level_db=-100,
                 window_type='hann',
                 mel_scale='htk',
                 norm_type='per_feature',
                 eps=1e-6):
        
        self.pre_emphasis = pre_emphasis
        self.ref_level_db = ref_level_db
        self.min_level_db = min_level_db
        self.eps = eps
        
        # Mel 변환기 설정
        self.mel_transform = torchaudio.transforms.MelSpectrogram(
            sample_rate=sample_rate,
            n_fft=n_fft,
            win_length=win_length,
            hop_length=hop_length,
            f_min=f_min,
            f_max=f_max,
            n_mels=n_mels,
            window_fn=getattr(torch, f'{window_type}_window'),
            mel_scale=mel_scale,
            normalized=True
        )
        
        self.norm_type = norm_type

    def pre_emphasis_filter(self, x):
        return torch.cat((x[:, 0:1], x[:, 1:] - self.pre_emphasis * x[:, :-1]), dim=1)

    def normalize(self, x):
        if self.norm_type == 'per_feature':
            mean = torch.mean(x, dim=-1, keepdim=True)
            std = torch.std(x, dim=-1, keepdim=True)
        else:  # all_features
            mean = torch.mean(x)
            std = torch.std(x)
        return (x - mean) / (std + self.eps)

    def extract_features(self, waveform):
        # 프리엠파시스 적용
        emphasized = self.pre_emphasis_filter(waveform)
        
        # Mel spectrogram 계산
        mel_spec = self.mel_transform(emphasized)
        
        # Log-Mel 변환
        log_mel = torch.log(mel_spec + self.eps)
        
        # 정규화
        normalized = self.normalize(log_mel)
        
        return normalized