[딥러닝]CNN, RNN, LSTM 이론 및 구현

728x90

 

 

 

1. CNN(Convolutional Neural Network)

 

 

📌 CNN

CNN은 영상 처리 분야에서 시작된 신경망 구조이지만, 최근에는 음성 데이터를 2차원 형태(스펙트로그램, MFCC 등)로 변환하여 입력함으로써 음성인식에도 널리 활용되고 있다.

주로 음향 모델의 전처리 계층 또는 전체 모델로 사용되며, 공간적 특징(주파수 간 관계, 시간적 변화)을 효과적으로 추출한다.

 

✔️ Convolution의 개념

convolution은 신호 처리에서 특정 패턴이나 주파수 대역을 추출하거나, 노이즈를 제거하기 위해 사용하는 핵심 연산이다. 입력 신호에 대해, 필터 또는 커널을 적용하여 새로운 출력을 생성한다.

 

※ 화이트 노이즈 신호에 대해 3개의 대역통과 FIR 필터를 적용한 후, 시간 영역과 주파수 영역에서 필터링 결과를 시각화

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import firwin, lfilter
import librosa
import librosa.display

# 1. 입력 신호 생성 (화이트 노이즈) : 1초 동안 16,000개의 랜덤 샘플 
# 화이트 노이즈는 모든 주파수에 동일한 세기를 가지는 신호 
sr = 16000  # 샘플링 주파수
T = 1.0     # 1초
x = np.random.randn(int(sr * T))

# 2. FIR 대역통과 필터 설계 함수
# numtaps=101은 필터 계수 수로 클수록 선명하고 안정적이다 
def design_bandpass_filter(center_hz, sr, width=100, numtaps=101):
    nyq = sr / 2
    low = max((center_hz - width) / nyq, 1e-4)
    high = min((center_hz + width) / nyq, 0.9999)
    if low >= high:
        raise ValueError(f"잘못된 주파수 범위: low={low*nyq}, high={high*nyq}")
    return firwin(numtaps, [low, high], pass_zero=False)

# 3. 필터 계수 생성(3개의 중심 주파수 필터: 100Hz, 1kHz, 5kHz)
filters = {
    "100Hz": design_bandpass_filter(100, sr),
    "1000Hz": design_bandpass_filter(1000, sr),
    "5000Hz": design_bandpass_filter(5000, sr)
}

# 4. 필터 적용(각 필터를 x에 적용해서 출력 신호 생성)
# 출력: 중심 주파수 대역만 통과시킨 신호 
outputs = {k: lfilter(h, [1], x) for k, h in filters.items()}

# 5. 시각화 (시간 + 주파수)
plt.figure(figsize=(14, 10))

for i, (label, y) in enumerate(outputs.items()):
    # 시간 영역
    plt.subplot(len(filters), 2, 2*i + 1)
    librosa.display.waveshow(y, sr=sr)
    plt.title(f"{label} - Time Domain")
    plt.xlabel("Time (s)")
    plt.ylabel("Amplitude")

    # 주파수 영역 (FFT)
    Y = np.abs(np.fft.rfft(y))
    freqs = np.fft.rfftfreq(len(y), d=1/sr)
    plt.subplot(len(filters), 2, 2*i + 2)
    plt.plot(freqs, Y)
    plt.title(f"{label} - Frequency Spectrum")
    plt.xlabel("Frequency (Hz)")
    plt.ylabel("Magnitude")
    plt.xlim(0, 8000)  # Nyquist 제한

plt.tight_layout()
plt.show()

 

• 100Hz 필터 결과:
  • 파형이 매우 천천히 진동
  • 스펙트럼은 저역대에만 집중되어 있음
• 1000Hz 필터:
  • 파형이 중간 정도로 진동
  • 스펙트럼은 1kHz 근처에 봉우리에 있음
• 5000Hz 필터:
  • 파형이 매우 빠르게 진동(세밀한 진동)
  • 스펙트럼은 5kHz 대역만 강조됨

 

 

 

---

 

 

 

2. RNN(Recurrent Neural Network)

 

 

📌 RNN

RNN은 순차 데이터 처리에 특화된 인공신경망 구조이다. 자연어 처리, 음성 인식, 시계열 예측 등에 주로 사용된다.

기존의 신경망은 입력 간의 순서를 고려하지 않지만, RNN은 이전 시점의 출력을 다음 시점의 입력에 재귀적으로 전달함으로써 시간적인 맥락(기억)을 반영할 수 있다.

 

• 입력 벡터가 은닉층에 들어감
• 은닉층으로부터 출력 벡터가 생성됨
• 은닉층에서 나와 다시 은닉층으로 입력됨

 

📌 GSC 데이터셋의 일부 숫자 음성을 무작위로 선택해 3~5개를 이어 붙여 하나의 연속 음성을 만들고, 해당 음성을 MFCC로 변환하여 RNN 모델을 학습한 뒤, 문자 단위 예측을 수행하는 음성 인식 모델 구현

 

※ 데이터 다운로드

!mkdir -p gsc
%cd gsc
!wget -q https://storage.googleapis.com/download.tensorflow.org/data/speech_commands_v0.02.tar.gz
!tar -xf speech_commands_v0.02.tar.gz
%cd ..

 

※ 이어붙인 음성 샘플 생성

import os
import random
import librosa
import numpy as np
import soundfile as sf

digit_words = ['zero','one','two','three','four','five','six','seven','eight','nine']
src_root = "gsc"

# 이어붙인 연속 음성 샘플 생성
concat_dir = "gsc_concat"
os.makedirs(concat_dir, exist_ok=True)

samples = []
for i in range(200):
    digits = random.choices(digit_words, k=random.randint(3, 5))   # ex: ['one','six','nine'] 
    wavs = []
    for word in digits:
        folder = os.path.join(src_root, word)
        files = [f for f in os.listdir(folder) if f.endswith(".wav")]
        path = os.path.join(folder, random.choice(files))
        y, _ = librosa.load(path, sr=16000)
        wavs.append(y)
    full = np.concatenate(wavs)    # 여러 단어의 음성 데이터를 연결 
    out_path = os.path.join(concat_dir, f"sample_{i}.wav")
    sf.write(out_path, full, 16000)
    samples.append((out_path, " ".join(digits)))

print("샘플 생성 완료:", len(samples))

 

※ 문자 인덱스 매핑 및 전처리 

char_vocab = sorted(list("abcdefghijklmnopqrstuvwxyz '"))
char2idx = {ch: i for i, ch in enumerate(char_vocab)}
PAD_IDX = len(char2idx)   # 패딩용 인덱스 
idx2char = {i: ch for ch, i in char2idx.items()}

# 문자 시퀀스 정답을 인덱스로 변환 후 길이 100에 맞춰 패딩 
def text_to_seq(text, max_len=100):
    seq = [char2idx[c] for c in text if c in char2idx]
    seq += [PAD_IDX] * (max_len - len(seq))
    return seq[:max_len]

# MFCC 특징 추출
def extract_mfcc(path, max_len=100):
    y, sr = librosa.load(path, sr=16000)
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13)    # [13, T]
    if mfcc.shape[1] < max_len:
        pad = np.zeros((13, max_len - mfcc.shape[1]))
        mfcc = np.concatenate((mfcc, pad), axis=1)
    return mfcc[:, :max_len].T  # [T, F]    # [T, 13]

X, y = [], []
for path, label in samples:
    X.append(extract_mfcc(path))
    y.append(text_to_seq(label))

# 학습 데이터 구성 
X = np.array(X)     # [N, T=100, 13]
y = np.array(y)     # [N, 100]

 

※ 학습용 데이터로 변환

from sklearn.model_selection import train_test_split
import torch
from torch.utils.data import DataLoader, TensorDataset

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train = torch.tensor(X_train, dtype=torch.float32)
X_test = torch.tensor(X_test, dtype=torch.float32)
y_train = torch.tensor(y_train, dtype=torch.long)
y_test = torch.tensor(y_test, dtype=torch.long)

train_loader = DataLoader(TensorDataset(X_train, y_train), batch_size=32, shuffle=True)

 

※ RNN 모델 정의 

import torch.nn as nn

class RNNModel(nn.Module):
    def __init__(self, input_dim=13, hidden_dim=128, output_dim=len(char2idx)+1):
        super().__init__()
        self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True)     # [B, T, 13] -> [B, T, H]
        self.fc = nn.Linear(hidden_dim, output_dim)    # 각 시간마다 문자 분포 예측 

    def forward(self, x):
        out, _ = self.rnn(x)       # [B, T, H]
        out = self.fc(out)         # [B, T, V]
        return out

    def backward(self, loss):
        loss.backward()

 

※ 모델 학습 ( epoch = 1000)

import matplotlib.pyplot as plt

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = RNNModel().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss(ignore_index=PAD_IDX)    # 손실 계산 

loss_history = []  # 손실 저장용 리스트

for epoch in range(1000):
    model.train()
    total_loss = 0
    for xb, yb in train_loader:
        xb, yb = xb.to(device), yb.to(device)
        pred = model(xb)                    # [B, T, V]
        pred = pred.view(-1, pred.shape[-1])
        yb = yb.view(-1)                # 전체 시퀀스를 한 번에 계산 
        loss = criterion(pred, yb)
        model.backward(loss)            # 손실 계산 후 backpropagation 실행 
        optimizer.step()                
        optimizer.zero_grad()           # 파라미터 업데이트 및 초기화 
        total_loss += loss.item()

    avg_loss = total_loss / len(train_loader)
    loss_history.append(avg_loss)
    print(f"Epoch {epoch+1}: Loss={avg_loss:.4f}")

# 모델 저장
torch.save(model.state_dict(), "rnn_speech_model.pth")
print("모델 저장 완료: rnn_speech_model.pth")

# 손실 함수 그래프 출력
plt.figure(figsize=(10, 4))
plt.plot(loss_history, label="Train Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Loss over Epochs")
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()

※ 추론 및 오디오 재생함수 정의

from IPython.display import Audio, display

def load_model_for_inference(model_path="rnn_speech_model.pth"):
    model = RNNModel().to(device)
    model.load_state_dict(torch.load(model_path, map_location=device))
    model.eval()
    return model

def infer_and_play_audio(sample_path, label_text=None, model_path="rnn_speech_model.pth"):
    # 오디오 재생
    print(f"[음성 재생]: {sample_path}")
    display(Audio(sample_path))

    # 모델 로드
    model = load_model_for_inference(model_path)

    # 입력 전처리
    mfcc = extract_mfcc(sample_path)
    x = torch.tensor(mfcc, dtype=torch.float32).unsqueeze(0).to(device)  # [1, T, F]

    # 추론
    with torch.no_grad():
        output = model(x)  # [1, T, V]
        pred_idx = output.argmax(2)[0]     # 가장 확률 높은 문자 인덱스 
        pred_text = ''.join([idx2char[i.item()] for i in pred_idx if i.item() != PAD_IDX])

    # 출력
    if label_text:
        print("[정답 문장]:", label_text)
    print("[모델 예측]:", pred_text)

 

 

 

※ epoch = 10000으로 학습 시 

 

 

 

 

 

---

 

 

 

3. LSTM (Long Short-Term Memory)

 

📌 LSTM

순차적인 데이터를 처리할 때, 과거 정보를 장기적으로 보존하면서 필요한 정보만 학습에 반영할 수 있도록 고안된 RNN 계열의 신경망이다. 일반적인 RNN이 시퀀스 길이가 길어질수록 기울기 소실 문제로 인해 과거 정보를 잊는 문제를 개선한 구조이다.

LSTM은 시계열 데이터를 처리할 때, 매 시간 단계에서 아래와 같은 세 가지 정보 흐름을 처리한다.

• 셀 상태(cell state): 장기 기억을 전달하는 벡터
• 은닉 상태(hidden state): 다음 계층 또는 다음 시간 단계로 출력할 정보
• 게이트들: 정보를 얼마나 유지할지, 버릴지 출력할지를 결정

 

• 작동 방식
  • 입력 게이트는 현재 입력에서 셀 상태에 얼마나 반영할지를 결정
  • 망각 게이트는 이전 셀 상태의 정보를 얼마나 잊을지를 결정
  • 출력 게이트는 최종 은닉 상태를 얼마나 내보낼지를 조절
  • 이러한 게이트 연산은 시그모이드 함수로 0~1 값을 출력하여 정보 흐름을 조절 

 

import torch.nn as nn

class LSTMModel(nn.Module):
	# 모델 구조 정의 
    def __init__(self, input_dim=13, hidden_dim=128, output_dim=len(char2idx)+1):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

	# 예측 과정 정의
    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out)
        return out
        
	# 손실에 대한 역전파 수행
    def backward(self, loss):
        loss.backward()