김신건의 로그 - 위키 / voice

[Voice AI] Speech-to-Speech: OpenAI Realtime, Gemini Live, Moshi

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

S2S (Speech-to-Speech) = STT → LLM → TTS 직렬 파이프라인 우회, 오디오 → 오디오 직접 처리. 톤/감정 보존 + < 300ms latency.

주요 모델

모델	출시	한국어	latency	특징
OpenAI Realtime API (GPT-4o)	2024-10	우수	232ms 평균	WebRTC + WebSocket, function calling 일부
Gemini Live (2.5)	2024-12	우수	< 500ms	Google AI Studio, multimodal
Moshi (Kyutai)	2024-09	영어	160ms	OSS, full-duplex, 자체 호스팅
Hume EVI 2	2024	영어	700ms	emotion 인식

OpenAI Realtime API

flowchart LR
    Browser["Browser (WebRTC)"] -->|오디오 stream| RT[OpenAI Realtime]
    RT -->|오디오 stream| Browser
    RT -.tool calls.-> Backend[Your Backend]
    Backend -.tool results.-> RT

// WebRTC 연결
const pc = new RTCPeerConnection();

// 마이크 오디오 추가
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
stream.getTracks().forEach(t => pc.addTrack(t, stream));

// 음성 응답 받기
pc.ontrack = (e) => {
  audioEl.srcObject = e.streams[0];
};

// DataChannel (이벤트, function call)
const dc = pc.createDataChannel('oai-events');
dc.onmessage = (e) => {
  const event = JSON.parse(e.data);
  if (event.type === 'response.function_call_arguments.done') {
    // function calling
  }
};

// SDP offer
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);

// OpenAI 에 offer 전송
const resp = await fetch('https://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview', {
  method: 'POST',
  headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/sdp' },
  body: offer.sdp,
});
await pc.setRemoteDescription({ type: 'answer', sdp: await resp.text() });

Session 이벤트

{
  "type": "session.update",
  "session": {
    "modalities": ["text", "audio"],
    "voice": "alloy",
    "instructions": "You are a helpful Korean assistant. Speak naturally.",
    "input_audio_format": "pcm16",
    "output_audio_format": "pcm16",
    "input_audio_transcription": { "model": "whisper-1" },
    "turn_detection": { "type": "server_vad", "threshold": 0.5 },
    "tools": [...],
    "tool_choice": "auto",
    "temperature": 0.8
  }
}

이벤트	의미
`session.created`	시작
`input_audio_buffer.append`	오디오 추가
`input_audio_buffer.commit`	처리 트리거
`response.audio.delta`	음성 청크
`response.audio_transcript.delta`	응답 전사
`response.function_call_arguments.done`	tool call

Gemini Live

from google import genai

client = genai.Client(api_key=API_KEY)

config = {
    "response_modalities": ["AUDIO"],
    "system_instruction": "당신은 친절한 한국어 어시스턴트입니다.",
    "speech_config": {
        "voice_config": {
            "prebuilt_voice_config": {"voice_name": "Aoede"}
        }
    }
}

async with client.aio.live.connect(model="gemini-2.5-flash-live", config=config) as session:
    async def send_audio(audio_stream):
        async for chunk in audio_stream:
            await session.send_realtime_input(audio=chunk)

    async def receive():
        async for response in session.receive():
            if response.audio:
                play(response.audio)

    await asyncio.gather(send_audio(mic), receive())

Moshi (OSS, self-host)

flowchart LR
    User[User audio] -->|streaming| Moshi["Moshi (7B params)"]
    Moshi -->|streaming| User
    Moshi --> Mimi["Mimi audio codec<br/>(12.5Hz)"]

Full-duplex: 듣고 + 말하기 동시.
Mimi codec: 12.5Hz token rate (vs Encodec 75Hz).
Self-host 가능 (Apache 2.0).
영어 위주, 한국어 약함.

S2S vs Streaming Cascading 비교

flowchart LR
    subgraph S2S
        A1[Audio] --> M1[Multimodal LLM]
        M1 --> A2[Audio]
    end
    subgraph Cascading
        B1[Audio] --> STT --> LLM --> TTS --> B2[Audio]
    end

항목	S2S	Streaming Cascading
Latency	< 300ms	< 1s
톤/감정 보존	예	손실
Function calling	제한	완전
컴포넌트 교체	불가	자유
비용	높음 ($0.06-0.20/min)	저렴 ($0.01-0.05/min)
Privacy	외부 API	자체 가능
한국어	OpenAI Realtime 우수	모델 선택

적합 시나리오

flowchart TD
    Q{용도}
    Q -->|"친밀한 대화 (외국어 학습)"| S2S
    Q -->|"complex tool calling (예약, 결제)"| Cascade[Cascading streaming]
    Q -->|MVP / 다국어| S2S
    Q -->|비용 critical + 대량| Cascade
    Q -->|"커스텀 LLM (자체 모델)"| Cascade

Function Calling 제약

OpenAI Realtime API 의 function calling 은 지원하지만:

모델이 function call 중 음성 응답 안 함 (텍스트 → 음성 변환 별도 처리)
복잡한 멀티 단계 reasoning 은 약함
enterprise 시스템 통합 은 cascading 이 더 안정

[!IMPORTANT] S2S 모델 다수가 function calling 미지원. function 이 필수인 enterprise 는 cascading streaming 채택 (arXiv 참조).

비용 비교

모델	가격
OpenAI Realtime (gpt-4o)	input $40/M tok, output $80/M tok
Gemini Live	input $0.50/M, output $2.00/M
Cascading (Whisper + GPT-4o-mini + Cartesia)	~$0.01/min

Realtime API 가 5-10배 비싸다. 비용 sensitive 면 cascading.

흔한 함정

[!WARNING]

모든 시나리오에 S2S = 비용 폭증 + function 제약. 용도 분석 후.

WebRTC 설정 복잡 = Signaling, ICE, TURN. SDK 사용.

한국어 발음 = 모델 마다 차이 큼. audio sample 직접 들어보고 선택.

Realtime API 의 session 종료 = idle 시 자동 종료. heartbeat 필요.

[Voice AI] STT 모델: Whisper, Deepgram, AssemblyAI, CLOVA

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

STT (Speech-to-Text) / ASR (Automatic Speech Recognition) = 음성 → 텍스트 변환. 2026 시점 전사 정확도 인간 수준, 실시간 < 300ms 도 흔함.

주요 모델 매트릭스 (2026)

모델	종류	한국어	스트리밍	강점
OpenAI Whisper v3	open weights	우수	batch (스트리밍 별도)	99 언어, 견고, self-host 가능
Whisper-Live / WhisperX	OSS 변형	우수	가능	자체 호스팅 + VAD
Deepgram Nova-3	API	보통	최강 (300ms)	멀티턴, diarization, latency
AssemblyAI Universal-2	API	보통	우수	다국어, multispeaker, 가격 경쟁력
Google Speech-to-Text v2	API	우수	우수	한국어 정확도, telephony 특화
Azure Speech	API	우수	우수	enterprise 통합
Naver CLOVA Speech	API	압도적	gRPC, < 1s	한국어 1위, 도메인 사전
Kakao i Speech	API	우수	가능	한국어 + 카카오 생태계
Faster-Whisper / Distil-Whisper	OSS	우수	가능	Whisper 의 4x 속도 + 작은 모델
NVIDIA NeMo Parakeet	open	영어	우수	edge, low-latency
GPT-4o transcribe	API	우수	가능	GPT-4o 의 audio 통합

Whisper 의 위치

flowchart TB
    Whisper["Whisper v3 (2023, OpenAI)"]
    Whisper --> Vanilla["원본 (PyTorch)"]
    Whisper --> Faster["Faster-Whisper (CTranslate2)<br/>~4x 빠름"]
    Whisper --> Distil["Distil-Whisper<br/>~6x 빠름, 49% 작음"]
    Whisper --> WhisperX["WhisperX<br/>+ word-level timestamps + diarization"]
    Whisper --> Live["WhisperLive / WhisperLink<br/>스트리밍 wrapper"]

2026 시점 자체 호스팅 = Faster-Whisper + Silero VAD 가 거의 표준. Distil-Whisper 가 영어 한정 으로 더 빠름.

모델 사이즈 vs 정확도 vs 속도 (Whisper)

한국어 STT 선택 가이드

flowchart TD
    Q{환경}
    Q -->|관리형 + 한국어 최고 정확도| CLOVA[Naver CLOVA Speech]
    Q -->|관리형 + 다국어 동시| Deepgram[Deepgram / AssemblyAI]
    Q -->|자체 호스팅 + 적당히| Faster[Faster-Whisper large-v3]
    Q -->|Edge / 모바일| Distil[Distil-Whisper small]
    Q -->|음성+텍스트 통합 LLM| GPT4o[GPT-4o Realtime API]

[!IMPORTANT] 한국어 전사 정확도 = CLOVA > Whisper-large-v3 > Google > Deepgram. 단 latency 는 정반대.

Diarization (화자 분리)

"안녕하세요"          → speaker_1
"네 안녕하세요"        → speaker_2
"오늘 회의 시작합니다"  → speaker_1

도구	의미
pyannote.audio	OSS, Hugging Face
WhisperX	Whisper + pyannote
AssemblyAI	API 내장
Deepgram	API 내장

API vs Self-host

	API (Deepgram, AssemblyAI)	Self-host (Whisper)
Latency	매우 낮음 (300ms 가능)	GPU + 튜닝 필요
비용	분당 $0.005-0.015	GPU 시간
Privacy	데이터 외부	내부
가용성	99.9% SLA	자체 운영
커스터마이즈	제한	자유 (fine-tune)
한국어	CLOVA, Google	Whisper-large 충분

평가 지표

지표	의미
WER (Word Error Rate)	단어 단위 오류율
CER (Character Error Rate)	문자 단위 (한국어/중국어 적합)
RTF (Real-Time Factor)	처리 시간 / 오디오 시간
TTF (Time to Final)	발화 종료 → final transcript
TTP (Time to Partial)	첫 partial 까지

흔한 함정

[!WARNING]

Whisper batch 모드를 스트리밍처럼 = 전체 오디오 받고서 시작. 실시간 X.

언어 자동 감지 = 짧은 발화에서 오류. 언어 명시 권장 (language="ko").

Hallucination (Whisper) = 무음 / 노이즈 구간에서 없는 문장 생성. VAD 전처리 필수.

Sample rate = 16kHz 표준. 44.1kHz / 48kHz 보내면 내부 resampling 추가 latency.

[Voice AI] STT 스트리밍: partial vs final, endpointing, gRPC/WS

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

스트리밍 STT = 오디오 청크 가 들어올 때마다 부분 결과 (partial) 를 즉시 반환 + 발화 종료 시 최종 결과 (final) 확정.

[!IMPORTANT] 대화형 음성 AI 의 첫 단계. 종단 지연 1초 미만 의 시작점.

partial vs final

sequenceDiagram
    autonumber
    participant Mic
    participant STT
    participant App

    Mic->>STT: chunk 1 (100ms)
    STT-->>App: partial: "안녕"
    Mic->>STT: chunk 2
    STT-->>App: partial: "안녕하세"
    Mic->>STT: chunk 3
    STT-->>App: partial: "안녕하세요"
    Mic->>STT: chunk 4 (침묵)
    Note over STT: endpoint 감지
    STT-->>App: FINAL: "안녕하세요"
    App->>App: LLM 호출

	partial (interim)	final
의미	현재 추정 (변경 가능)	확정
빈도	매 100-300ms	endpointing 후 1회
정확도	낮음 (변경됨)	높음
사용	UI 라이브 자막	LLM 호출, action

[!CAUTION] partial 로 LLM 호출 금지. 반복 호출 + 변경된 텍스트 → 낭비 + 일관성 깨짐.

Endpointing (발화 종료 감지)

사용자 침묵 → 얼마나 기다린 후 final?

전략	의미
에너지 기반 VAD	침묵 N ms 후 종료
신경망 VAD (Silero)	음성/비음성 확률 기반
시맨틱 endpointing	문장 의미 + VAD (LiveKit 0.4)
고정 timeout	무조건 N초 후

일반: 침묵 500-800ms 후 final
short: 200-400ms (빠른 대화)
long: 1000-1500ms (사용자가 멈춤 많음)

시맨틱 endpointing 의 가치

❌ 순수 VAD: "내 번호는 010-..." [500ms 침묵] → final "내 번호는 010" → 사용자 끊김!
✓ 시맨틱: "내 번호는 010-1234-5678" 까지 *기다림* (전화번호 패턴 인식)

LiveKit, Pipecat 의 자체 모델 이 오디오 + 텍스트 보고 ~300ms 까지 단축.

프로토콜: WebSocket vs gRPC

flowchart LR
    Client[Client] -->|WebSocket binary frames| Server1["STT (WebSocket)"]
    Client -->|gRPC stream| Server2["STT (gRPC)"]
    Client -->|HTTP/2 + chunks| Server3["STT (HTTP/2)"]

프로토콜	장점	단점
WebSocket	브라우저 native, 단순	텍스트/binary 혼합 어색
gRPC bidi-stream	binary 효율적, schema	브라우저는 grpc-web 필요
HTTP/2 chunked	표준	session 관리 직접

2026 시점 서버↔서버 = gRPC (CLOVA, Google), 브라우저↔서버 = WebSocket (Deepgram, AssemblyAI) 분기.

WebSocket 예시 (Deepgram)

const ws = new WebSocket('wss://api.deepgram.com/v1/listen?model=nova-3&language=ko&interim_results=true&endpointing=500');

ws.binaryType = 'arraybuffer';

ws.onmessage = (e) => {
  const data = JSON.parse(e.data);
  if (data.channel?.alternatives[0]) {
    const transcript = data.channel.alternatives[0].transcript;
    const isFinal = data.is_final;
    if (isFinal) {
      onFinalTranscript(transcript);
    } else {
      onPartial(transcript);
    }
  }
};

// 마이크 → WebSocket 오디오 청크
const audioContext = new AudioContext({ sampleRate: 16000 });
const processor = audioContext.createScriptProcessor(2048, 1, 1);
processor.onaudioprocess = (e) => {
  const pcm = float32To16BitPCM(e.inputBuffer.getChannelData(0));
  ws.send(pcm);
};

gRPC 예시 (CLOVA, Python)

import grpc
import nest_pb2, nest_pb2_grpc

def request_generator(audio_stream):
    yield nest_pb2.NestRequest(
        type=nest_pb2.RequestType.CONFIG,
        config=nest_pb2.NestConfig(
            language='ko-KR',
            sample_rate=16000,
            encoding=nest_pb2.AudioEncoding.LINEAR16,
        )
    )
    for chunk in audio_stream:
        yield nest_pb2.NestRequest(
            type=nest_pb2.RequestType.AUDIO,
            audio=chunk,
        )

with grpc.secure_channel('clovaspeech-gw.ncloud.com:443', creds) as channel:
    stub = nest_pb2_grpc.NestServiceStub(channel)
    metadata = [('authorization', f'Bearer {token}')]
    for response in stub.Recognize(request_generator(audio_iter), metadata=metadata):
        if response.is_final:
            print('FINAL:', response.transcript)
        else:
            print('partial:', response.transcript)

지표

지표	의미	목표
TTP (Time-to-Partial)	첫 partial 까지	< 200ms
TTF (Time-to-Final)	발화 종료 → final	< 500ms
TTL (Time-to-Last partial)	마지막 partial 까지	< 100ms
Stability	partial 의 변경 빈도	< 5%

자세한 latency 분석은 [[latency-percentiles]].

흔한 함정

[!WARNING]

partial 로 LLM 호출 = 낭비. final 까지 기다리거나 시맨틱 endpointing.

endpointing 너무 김 (1.5초+) = 대화 어색. 사용자가 답답함.

endpointing 너무 짧음 (200ms) = 사용자 말끊김. 시맨틱 권장.

WebSocket idle timeout = 침묵 시 connection close. ping/pong 주기적.

언어 자동 감지 = 짧은 발화 / 다국어 혼용 시 깨짐. 명시.

[Voice AI] TTS 모델: ElevenLabs, Cartesia, Edge TTS, 한국어

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

TTS (Text-to-Speech) = 텍스트 → 음성 합성. 2026 시점 사람과 구분 어려운 자연도 + < 200ms first audio + voice cloning 표준.

뉴럴 TTS 구조

flowchart LR
    Text["텍스트"] --> Norm["Text Normalization<br/>(숫자, 약어, 발음 사전)"]
    Norm --> Front["Front-end<br/>(grapheme → phoneme)"]
    Front --> Acoustic["Acoustic Model<br/>(mel-spectrogram)"]
    Acoustic --> Vocoder["Vocoder<br/>(mel → waveform)"]
    Vocoder --> Audio[음성 wav]

단계	역할
Normalization	”100$” → “백 달러”
G2P	grapheme → phoneme
Acoustic	Tacotron2, FastSpeech2, VITS, Glow-TTS
Vocoder	HiFi-GAN, WaveNet, BigVGAN
통합	VITS, StyleTTS2 (end-to-end)

2026 시점 상용 TTS 는 거의 모두 end-to-end (acoustic + vocoder 통합). Diffusion 기반도 활발.

주요 모델 매트릭스 (2026)

모델	종류	한국어	TTFB	클로닝	강점
ElevenLabs v3	API	우수	200-400ms	수초 샘플	자연도 1위, 다국어, 감정
Cartesia Sonic-2	API	보통	< 90ms	가능	최저 latency, 실시간 voice agent 표준
OpenAI TTS-1-HD / GPT-4o TTS	API	우수	300-500ms	제한	GPT 통합
Google Cloud TTS (Studio voices)	API	우수	300ms	제한	안정성
Azure Speech TTS	API	우수	200-400ms	Custom Neural Voice	enterprise
Microsoft Edge TTS	무료 (비공식 API)	우수	보통	X	비용 0, edge-tts 패키지
Naver CLOVA Voice	API	최우수	200-400ms	가능	한국어 1위
Typecast	API	우수	적당	강력	한국 voice cloning
Coqui XTTS-v2	OSS	우수	self-host	수초 샘플	자체 호스팅 + 클로닝
F5-TTS (2024)	OSS	보통	self-host	가능	flow matching, 빠름
MaskGCT (2024)	OSS	우수	self-host	가능	non-autoregressive
StyleTTS 2	OSS	영어	self-host	가능	high quality

TTFB (Time-to-First-Byte) 비교

Edge TTS (Microsoft 비공식 API)

import edge_tts
import asyncio

async def main():
    communicate = edge_tts.Communicate(
        text="안녕하세요. 음성 합성 테스트입니다.",
        voice="ko-KR-SunHiNeural"
    )
    await communicate.save("output.mp3")

# 스트리밍
async def stream_tts(text):
    communicate = edge_tts.Communicate(text, voice="ko-KR-InJoonNeural")
    async for chunk in communicate.stream():
        if chunk["type"] == "audio":
            yield chunk["data"]

장점	단점
무료	Microsoft 정책 변경 위험
다국어 (한국어 4 음성)	rate limit 불명확
빠름	enterprise SLA 없음
edge-tts 패키지 1줄	비공식 (API 변경 가능)

[!IMPORTANT] Edge TTS 는 비공식. Microsoft 가 Edge 브라우저 의 read-aloud 기능 을 외부 사용. 상용 서비스 사용은 위험. PoC, 개인 프로젝트 에 적합.

한국어 TTS 선택

flowchart TD
    Q{환경}
    Q -->|상용 + 한국어 자연도 최고| CLOVA[CLOVA Voice]
    Q -->|상용 + 클로닝 + 한국어| Typecast
    Q -->|상용 + 다국어 + 자연도| Eleven[ElevenLabs v3]
    Q -->|상용 + 최저 latency| Cartesia
    Q -->|무료 + PoC| EdgeTTS[Edge TTS]
    Q -->|자체 호스팅 + 클로닝| XTTS[Coqui XTTS-v2 / F5-TTS]

Voice Cloning

flowchart LR
    Sample["3-10초 음성 샘플"] --> Encoder[Speaker Encoder]
    Encoder --> Embed["Speaker Embedding (256-dim)"]
    Text --> TTS[TTS 모델]
    Embed --> TTS
    TTS --> Output["Cloned 음성"]

도구	샘플 길이	품질
ElevenLabs Instant Voice	1분	최고
ElevenLabs Professional Voice	30분+	정밀 (스튜디오 녹음)
XTTS-v2	6초	좋음 (OSS)
F5-TTS	10초	빠름
Coqui (옛)	10분+	옛

[!CAUTION] 허락 없는 voice cloning 은 법적 / 윤리적 문제. 공인 / 유명인 음성 무단 사용 금지. 생성 음성에 워터마크 권장 (Resemble AI 의 PerthNet 등).

발음 교정 사전 (lexicon)

<!-- SSML -->
<lexicon uri="https://example.com/lex.pls"/>

<!-- lex.pls -->
<lexicon xmlns="http://www.w3.org/2005/01/pronunciation-lexicon">
  <lexeme>
    <grapheme>Karatsuba</grapheme>
    <phoneme>karatsˈuːba</phoneme>
  </lexeme>
</lexicon>

브랜드명, 인명, 기술 용어를 정확히 발음. 자세한 SSML 은 [[tts-streaming-ssml]].

평가 지표

지표	의미
MOS (Mean Opinion Score)	1-5, 인간 평가
CER	합성된 음성을 STT 로 다시 → 정확도
TTFB	첫 오디오까지
RTF (Real-Time Factor)	처리 시간 / 음성 시간 (< 1 = real-time 가능)
WER (TTS-STT round trip)	종합 정확도

흔한 함정

[!WARNING]

TTFB 만 보고 선택 = 자연도 떨어지면 사용자 외면. 둘 다 확인.

숫자 발음 = “100” → “100” 또는 “백” 가는지 모델 마다 다름. SSML <say-as> 명시.

긴 문장 한 번에 = 첫 오디오 지연. 문장 단위 청킹 후 스트리밍. 자세한 건 [[tts-streaming-ssml]].

클로닝 음질 = 샘플 노이즈에 민감. 조용한 환경 + 16kHz+ 녹음.

[Voice AI] TTS 스트리밍 + SSML: TTFB, sentence aggregation, 청킹

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

TTS 스트리밍 = 텍스트 일부만 받아도 즉시 합성 + 오디오 청크 단위 전송. TTFB (Time-to-First-Audio) 최소화 = 대화 자연스러움의 핵심.

TTFB 의 중요성

flowchart LR
    LLM[LLM 토큰] -->|"문장 1: 'A.'"| TTS
    TTS -->|즉시 합성 시작| Audio1[오디오 청크]
    LLM -->|"문장 2: 'B.'"| TTS
    TTS -->|병렬| Audio2[오디오 청크]
    Audio1 --> Speaker
    Audio2 --> Speaker

[!IMPORTANT] 사람 대화는 응답 < 500ms. TTS 가 문장 전체 끝나고 합성 시작 하면 (예: 5초 응답) → 5초 + 합성 latency = 불가능. 문장 단위 스트리밍 필수.

Sentence Aggregation

sequenceDiagram
    autonumber
    participant LLM
    participant Agg as Sentence Aggregator
    participant TTS

    LLM->>Agg: "안녕"
    LLM->>Agg: "하세요"
    LLM->>Agg: ", 오늘"
    LLM->>Agg: " 날씨가"
    LLM->>Agg: " 좋네요."
    Note over Agg: '.' 감지 → 문장 완성
    Agg->>TTS: "안녕하세요, 오늘 날씨가 좋네요."
    TTS-->>App: 오디오 chunk 1
    TTS-->>App: 오디오 chunk 2
    LLM->>Agg: "더 도와드릴까요?"
    Note over Agg: '?' 감지
    Agg->>TTS: "더 도와드릴까요?"

class SentenceAggregator:
    def __init__(self):
        self.buffer = ""
        self.delimiters = ".!?。!?"

    def feed(self, token: str):
        self.buffer += token
        # 문장 끝 감지
        for i, ch in enumerate(self.buffer):
            if ch in self.delimiters:
                # 다음 글자가 공백 또는 끝 → 문장 종료
                if i == len(self.buffer) - 1 or self.buffer[i+1] in ' \n':
                    sentence = self.buffer[:i+1].strip()
                    self.buffer = self.buffer[i+1:].lstrip()
                    return sentence
        return None

Pipecat / LiveKit 의 내장 sentence aggregator. 직접 구현도 어렵지 않음.

SSML (Speech Synthesis Markup Language)

<speak version="1.1" xml:lang="ko-KR">
  안녕하세요. <break time="300ms"/>
  오늘 회의는 <emphasis level="strong">오후 3시</emphasis>입니다.
  <prosody rate="slow" pitch="+2st">천천히 또박또박 말합니다.</prosody>
  주문 번호는 <say-as interpret-as="characters">A1B2</say-as>입니다.
  금액은 <say-as interpret-as="currency" language="ko-KR">1500000</say-as>원입니다.
</speak>

주요 SSML 태그

태그	의미
`<break time="500ms"/>`	일시 정지
`<emphasis level="strong">`	강조 (강/중/약)
`<prosody rate="slow" pitch="+2st" volume="loud">`	운율 (속도, 높낮이, 음량)
`<say-as interpret-as="characters">`	글자 하나씩 (A1B2 → A 1 B 2)
`<say-as interpret-as="currency">`	통화
`<say-as interpret-as="date">`	날짜
`<say-as interpret-as="time">`	시간
`<say-as interpret-as="telephone">`	전화번호
`<phoneme alphabet="ipa" ph="kæɹətsˈuːba">Karatsuba</phoneme>`	음소 직접 명시
`<sub alias="에이아이">AI</sub>`	대체 발음
`<voice name="...">`	음성 변경
`<lang xml:lang="en-US">Hello</lang>`	다국어

스트리밍 프로토콜

flowchart LR
    LLM -->|토큰 stream| Agg
    Agg -->|"문장 (Server-Sent Events)"| TTS_API[TTS API]
    TTS_API -->|"오디오 청크 (chunked HTTP / WebSocket)"| Player[Audio Player]

프로토콜	의미
chunked HTTP	`Transfer-Encoding: chunked`
SSE (Server-Sent Events)	`text/event-stream`
WebSocket	양방향, 실시간
gRPC stream	효율적, schema

오디오 청크 형식

형식	의미
PCM 16-bit 16kHz	가장 작음 + 즉시 재생
MP3	압축 + 일반
Opus	효율적 + 음질
AAC	iOS 호환성
WebM Opus	브라우저 native

실시간 voice agent = PCM 또는 Opus 표준. MP3 는 encoder buffer 때문에 latency 추가.

ElevenLabs 스트리밍 예시

import requests

def stream_tts(text, voice_id):
    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}/stream"
    headers = {"xi-api-key": API_KEY, "Content-Type": "application/json"}
    body = {
        "text": text,
        "model_id": "eleven_turbo_v2_5",
        "voice_settings": {"stability": 0.5, "similarity_boost": 0.75},
        "output_format": "pcm_16000",
    }
    resp = requests.post(url, json=body, headers=headers, stream=True)
    for chunk in resp.iter_content(chunk_size=1024):
        yield chunk   # 즉시 재생기로 push

Cartesia 스트리밍 (WebSocket)

const ws = new WebSocket('wss://api.cartesia.ai/tts/websocket');

ws.send(JSON.stringify({
  model_id: 'sonic-2',
  voice: { mode: 'id', id: 'voice_id_xyz' },
  output_format: { container: 'raw', encoding: 'pcm_s16le', sample_rate: 16000 },
  language: 'ko',
  transcript: 'continue',   // streaming mode
}));

// 문장 단위 push
ws.send(JSON.stringify({ transcript: '안녕하세요. ', continue: true }));
ws.send(JSON.stringify({ transcript: '오늘 날씨가 좋네요.', continue: false }));

ws.onmessage = (e) => {
  // binary audio chunk
  player.feed(e.data);
};

발음 제어 패턴

# 숫자 → 한국어 변환
text = "주문번호 1234"
ssml = f'<speak>주문번호 <say-as interpret-as="characters">{order_id}</say-as></speak>'

# 금액
amount = 1500000
ssml = f'<speak>{amount:,}원</speak>'   # 또는 say-as currency

# 영문 약어
ssml = '<speak><sub alias="에이피아이">API</sub> 키를 발급받았습니다.</speak>'

# 강조
ssml = '<speak>주문 번호는 <emphasis level="strong">반드시</emphasis> 적어주세요.</speak>'

흔한 함정

[!WARNING]

전체 텍스트 받고 합성 시작 = 응답 5초 후 음성 시작. 문장 단위 streaming.

MP3 출력 = encoder buffer 100-300ms 추가. PCM 또는 Opus.

SSML escape 안 함 = <, & 가 본문에 있으면 XML parse 에러. xml.sax.saxutils.escape.

너무 짧은 청크 = “안녕.” 만 합성 시 자연도 떨어짐. 최소 수 단어 단위.

문장 분리 오인 = “Mr.” 의 . 을 문장 종료로 인식. 약어 사전 또는 최소 길이 + 휴리스틱.

[Voice AI] Turn Detection + Barge-in + AEC: 자연스러운 대화

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

자연스러운 음성 대화의 3 요소:

Turn Detection - 사용자가 말끝났는지 정확히 판단
Barge-in - 에이전트가 말하는 중에 사용자가 끼어들 수 있게
AEC - 에이전트의 자기 음성을 자기 마이크에서 제거

1. Turn Detection (시맨틱)

순수 VAD endpointing 의 한계

"내 전화번호는 010-1234-5678 입니다"

VAD endpointing (500ms 침묵):
"내 전화번호는 010-" [400ms 침묵, 사용자가 생각 중]
→ FINAL "내 전화번호는 010" → 사용자 끊김!

시맨틱 Turn Detection

flowchart LR
    Audio[Audio] --> VAD
    Audio --> STT
    STT --> Partial[Partial transcript]
    VAD --> Sil[Silence detected]
    Partial --> SemModel["Turn Detection Model<br/>(오디오 + 텍스트)"]
    Sil --> SemModel
    SemModel --> Decision{문장 종료 의도?}
    Decision -->|yes| End[Turn ended]
    Decision -->|no, 더 기다림| Wait[Continue waiting]

오디오 prosody (운율) + 텍스트 의미 보고 완성 문장인지 판단. ~300ms 까지 단축.

도구	의미
LiveKit Turn Detection	자체 모델
Pipecat End-of-utterance detector	통합
Cartesia turn detection	API

# LiveKit Agents 예시
from livekit.agents import VoiceAssistant
from livekit.plugins.turn_detector import EOUModel

assistant = VoiceAssistant(
    vad=silero.VAD.load(),
    stt=deepgram.STT(),
    llm=openai.LLM(),
    tts=cartesia.TTS(),
    turn_detector=EOUModel(),   # End-of-utterance 시맨틱 모델
    min_endpointing_delay=0.5,
    max_endpointing_delay=3.0,
)

2. Barge-in (끼어들기)

sequenceDiagram
    autonumber
    User->>Agent: "오늘 날씨 어때?"
    Agent->>User: "오늘 서울은 맑고..." (TTS 재생 중)
    User->>VAD: 발화 시작 ("아 잠깐")
    VAD->>Agent: interruption 이벤트
    Agent->>TTS: cancel
    Agent->>STT: 새 발화 처리
    User->>Agent: "근데 비 와?"

Barge-in 흐름

class VoiceAgent:
    def __init__(self):
        self.tts_playing = False
        self.tts_cancel = None

    async def on_user_speech_start(self):
        if self.tts_playing:
            await self.tts_cancel()       # 재생 중인 TTS 즉시 중단
            await self.flush_audio()       # 출력 buffer 비움
            self.tts_playing = False

    async def speak(self, text):
        self.tts_playing = True
        try:
            async for chunk in self.tts.stream(text):
                if self.cancel_event.is_set():
                    break
                await self.send_audio(chunk)
        finally:
            self.tts_playing = False

Disallow Interruptions (보호)

# Tool call (DB write 같은 되돌릴 수 없는 작업) 중에는 차단
@agent.function_tool
async def transfer_money(amount: int, to: str):
    with disallow_interruptions():
        await db.transfer(amount, to)        # 끼어들기 금지
    return f"{amount}원이 {to}님께 송금되었습니다."

[!IMPORTANT] DB write, 외부 API 호출 (결제) 같은 비가역 작업 중에는 반드시 disallow_interruptions.

3. Echo Cancellation (AEC)

문제: 자기 목소리가 다시 마이크로

flowchart LR
    Speaker[스피커] --> Air[공기]
    Air -.echo.-> Mic[마이크]
    Mic --> VAD
    VAD -->|에이전트 자기 목소리로 false positive| Interrupt[잘못된 interruption]

해결 3계층

flowchart TB
    L1[1. 클라이언트: getUserMedia echoCancellation=true]
    L1 --> L2["2. 디바이스: hardware AEC (이어폰 사용)"]
    L2 --> L3["3. 서버: echo gate (TTS 재생 중 마이크 무시)"]

서버측 Echo Gate

class EchoGate:
    """TTS 재생 중 마이크 입력 무시 (or 감쇠)"""
    def __init__(self, attenuation_db=20):
        self.tts_active = False
        self.atten = 10 ** (-attenuation_db / 20)

    def attenuate(self, audio_chunk):
        if self.tts_active:
            return audio_chunk * self.atten
        return audio_chunk

    async def on_tts_start(self):
        self.tts_active = True

    async def on_tts_end(self):
        self.tts_active = False

[!CAUTION] 순수 마이크 mute 면 진짜 barge-in 도 막힘. 부분 감쇠 (20dB) + VAD 임계값 상승 이 균형.

4. Sentence Aggregation (LLM 토큰 → TTS 문장)

class SentenceAggregator:
    def feed_token(self, token):
        self.buffer += token
        if any(self.buffer.endswith(p) for p in ['. ', '! ', '? ', '。', '!', '?']):
            sent = self.buffer.strip()
            self.buffer = ""
            return sent
        return None

# 사용
async for token in llm.stream(prompt):
    sent = aggregator.feed_token(token)
    if sent:
        async for audio in tts.stream(sent):
            yield audio

자세한 건 [[tts-streaming-ssml]].

통합 흐름

flowchart TB
    Mic --> AEC[AEC + Noise]
    AEC --> VAD
    VAD --> STT
    STT --> TD[Turn Detection]
    TD -->|"complete utterance"| LLM
    LLM -->|tokens| Agg[Sentence Aggregator]
    Agg -->|sentence| TTS
    TTS --> Speaker
    VAD -.barge-in.-> Cancel[TTS cancel]
    Cancel --> TTS

흔한 함정

[!WARNING]

AEC 없이 스피커 출력 = 무한 루프 (자기 목소리 → STT → LLM → TTS → …). 이어폰 또는 echo gate.

순수 VAD endpointing 만 = 전화번호 / 주소 발화 시 끊김. 시맨틱 turn detection.

Barge-in 시 TTS buffer 남음 = “끊었는데” 음성 1-2초 더 들림. 오디오 buffer flush.

Sentence aggregation 너무 길게 = 첫 음성 지연. 문장 1-2개 단위 (50-100 글자).

[Voice AI] VAD: Silero, 에너지 기반, endpointing 임계값

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

VAD (Voice Activity Detection) = 오디오 스트림에서 음성 vs 비음성 (침묵, 노이즈) 구분. 음성 에이전트의 발화 시작 / 종료 감지에 필수.

종류

flowchart TB
    VAD[VAD 종류]
    VAD --> Energy["Energy-based<br/>(RMS, ZCR)"]
    VAD --> Spectral[Spectral feature]
    VAD --> Neural["Neural network<br/>(Silero, Marble)"]
    VAD --> Webrtc["WebRTC VAD<br/>(GMM)"]
    Energy --> Simple["단순, 빠름, 노이즈에 약함"]
    Neural --> Robust["robust, 정확, 작은 모델"]

VAD	정확도	속도	노이즈 견고성
Energy (RMS)	낮음	매우 빠름	X
WebRTC VAD (GMM)	보통	빠름	보통
Silero VAD	높음	빠름 (2MB)	우수
Marble VAD	매우 높음	보통	우수
Whisper VAD	매우 높음	느림	우수

Silero VAD (사실상 표준)

import torch
torch.set_num_threads(1)

model, utils = torch.hub.load(
    repo_or_dir='snakers4/silero-vad',
    model='silero_vad',
    onnx=False,
)

# 32ms 청크 (16kHz, 512 sample) 단위로 처리
def is_speech(audio_chunk: torch.Tensor) -> float:
    """0.0 ~ 1.0 (음성 확률)"""
    return model(audio_chunk, 16000).item()

# 실시간 처리
chunk_size = 512   # 32ms at 16kHz
threshold = 0.5    # 0.5 이상 → 음성
for chunk in audio_stream:
    prob = is_speech(chunk)
    if prob > threshold:
        on_voice_active()
    else:
        on_silence()

Silero VAD 특징

속성	값
모델 크기	2MB (ONNX)
입력	32ms 청크 (512 samples at 16kHz)
추론 시간	< 1ms on CPU
정확도	96%+ on LibriSpeech
라이센스	MIT

[!IMPORTANT] 2026 시점 voice agent VAD 의 사실상 표준. Silero VAD 가 Pipecat, LiveKit Agents, faster-whisper-streaming 등의 기본.

Endpointing (발화 종료 결정)

flowchart LR
    Audio[오디오 stream] --> VAD
    VAD --> State{현재 상태}
    State -->|음성 중| Speak[Speaking]
    State -->|침묵 N ms 누적| End[Speech ended → final transcript trigger]
    Speak -->|침묵 시작| Track[Silence tracker]
    Track -->|N ms 경과| End
    Track -->|다시 음성| Speak

class EndpointDetector:
    def __init__(self, silence_threshold_ms=700):
        self.silence_ms = 0
        self.threshold = silence_threshold_ms
        self.in_speech = False

    def feed(self, vad_prob: float, chunk_ms: int = 32):
        is_voice = vad_prob > 0.5
        if is_voice:
            self.silence_ms = 0
            self.in_speech = True
        else:
            if self.in_speech:
                self.silence_ms += chunk_ms
                if self.silence_ms >= self.threshold:
                    self.in_speech = False
                    return "speech_ended"
        return None

Endpointing 임계값 튜닝

시나리오	silence ms
빠른 대화 (FAQ 봇)	300-500ms
일반 대화	500-800ms
사용자가 천천히 말함 (고연령)	1000-1500ms
전화번호 / 주소 dictation	시맨틱 endpointing (순수 VAD 부적합)

[!CAUTION] 순수 VAD endpointing 의 한계: “내 번호는 010…” [짧은 침묵] → final → 사용자 끊김. 시맨틱 turn detection 으로 보완. 자세한 건 [[turn-detection-barge-in]].

노이즈 감쇠 전처리

flowchart LR
    Mic --> NS["Noise Suppression<br/>(RNNoise, Krisp, getUserMedia)"]
    NS --> VAD
    VAD --> STT

도구	의미
`getUserMedia({ noiseSuppression: true })`	브라우저 내장
RNNoise	OSS, 신경망 기반
Krisp SDK	상용, 고성능
DeepFilterNet	OSS, real-time

VAD 실패 시나리오

flowchart TD
    Fail[VAD 실패 케이스]
    Fail --> Bg["배경 음성 (TV, 다른 사람)"]
    Fail --> Whisper["속삭임"]
    Fail --> Music[배경 음악]
    Fail --> NonSpeech["기침, 한숨, 침묵 호흡"]
    Fail --> Bg --> Sol1["방향성 마이크 + 화자 분리"]
    Fail --> Whisper --> Sol2["임계값 낮춤"]
    Fail --> Music --> Sol3["음악 vs 음성 분류기"]

getUserMedia 옵션

const stream = await navigator.mediaDevices.getUserMedia({
  audio: {
    echoCancellation: true,
    noiseSuppression: true,
    autoGainControl: true,
    sampleRate: 16000,
    channelCount: 1,
  },
});

브라우저 내장 신호처리 가 기본. 일부 OS 는 덮어쓰기 안 됨 (Chrome 의 hardware AEC).

VAD + STT 통합 패턴

flowchart LR
    Mic --> VAD
    VAD -->|음성 시작| Open[STT WebSocket 연결]
    VAD -->|음성 청크| Forward[STT 로 전달]
    VAD -->|침묵 N ms| Close[STT close → final]
    Close --> LLM

async def voice_pipeline(mic_stream):
    vad = SileroVAD()
    endpoint = EndpointDetector(silence_threshold_ms=700)
    stt_ws = None

    async for chunk in mic_stream:
        prob = vad.predict(chunk)

        if prob > 0.5 and not stt_ws:
            stt_ws = await connect_stt()

        if stt_ws:
            await stt_ws.send(chunk)

            transcript = await stt_ws.recv()
            if transcript.is_final:
                yield transcript.text

        result = endpoint.feed(prob)
        if result == "speech_ended":
            await stt_ws.close()
            stt_ws = None

흔한 함정

[!WARNING]

에너지 기반 VAD 의 한계 = 카페 / 키보드 소리에 활성. Silero 권장.

임계값 0.5 그대로 = 환경에 따라 조정. 조용한 곳 은 0.3, 시끄러운 곳 은 0.7.

VAD 없이 STT = 침묵 동안 전사 못 끝남 + 비용 폭증.

chunk size 가 16/32ms 가 아님 = Silero 가 512 samples (32ms at 16kHz) 만 받음. resampling 필요.

[Voice] Neural TTS 내부: Tacotron, FastSpeech, VITS, HiFi-GAN

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Neural TTS 의 진화: 2단계 (acoustic + vocoder) → end-to-end. 2026 시점 VITS 계열 + Flow matching 이 상용 표준.

개요는 [[tts-models-overview]] 참고. 본 페이지는 내부 아키텍처 + 코드.

2단계 파이프라인 (전통)

flowchart LR
    Text["텍스트"] --> Front["Front-end (G2P, normalization)"]
    Front --> Phone["Phonemes"]
    Phone --> Acoustic["Acoustic Model<br/>(text → mel spectrogram)"]
    Acoustic --> Mel["Mel-spectrogram<br/>(80 × T)"]
    Mel --> Vocoder["Vocoder<br/>(mel → waveform)"]
    Vocoder --> Audio["오디오 (24kHz)"]

단계	대표 모델
G2P	Sequence-to-sequence, Phonemizer
Acoustic	Tacotron 2, FastSpeech 2, Glow-TTS
Vocoder	WaveNet, WaveRNN, HiFi-GAN, BigVGAN

Tacotron 2 (2017-2018)

flowchart LR
    Char["Character embedding"] --> CNN["Conv layers"]
    CNN --> BiLSTM["Bidirectional LSTM"]
    BiLSTM --> Attn["Location-sensitive Attention"]
    Attn --> Dec["LSTM Decoder (autoregressive)"]
    Dec --> Mel["Mel spectrogram"]
    Mel --> WN["WaveNet vocoder"]
    WN --> Audio

Autoregressive: 매 mel frame 순차 생성.
Attention alignment: text ↔ audio 매핑 학습.
단점: 느림 (real-time factor > 1), robustness 문제 (repetition, skipping).

FastSpeech 2 (2020)

flowchart LR
    Phone["Phonemes"] --> PE["Position encoding"]
    PE --> Enc["Transformer Encoder"]
    Enc --> Dur["Duration Predictor<br/>(각 phoneme 몇 frame?)"]
    Enc --> P["Pitch Predictor"]
    Enc --> E["Energy Predictor"]
    Dur --> Expand["Length Regulator"]
    P & E --> Expand
    Expand --> Dec["Transformer Decoder"]
    Dec --> Mel

Non-autoregressive: 병렬 생성 → 수십 배 빠름.
Duration predictor 로 길이 예측 (attention 없음).
Pitch/Energy 예측으로 운율 제어.

VITS (2021, 상용 표준)

Variational Inference with adversarial learning for end-to-end Text-to-Speech

flowchart TB
    Text["Text"] --> Enc["Text Encoder"]
    Audio["Audio (training)"] --> PostEnc["Posterior Encoder<br/>(linear spec)"]
    Enc --> Prior["Prior distribution"]
    PostEnc --> Post["Posterior distribution"]
    Prior --> Flow["Normalizing Flow"]
    Post --> Flow
    Flow --> z["Latent z"]
    z --> Decoder["HiFi-GAN Decoder"]
    Decoder --> Waveform["Audio waveform"]

핵심 아이디어:

End-to-end: Mel intermediate 없이 바로 waveform.
VAE + Flow + GAN 결합.
Duration predictor + Stochastic (자연스러움).
상용 TTS 의 표준 base.

# Coqui XTTS-v2 사용
from TTS.api import TTS

tts = TTS(
    model_name="tts_models/multilingual/multi-dataset/xtts_v2",
    progress_bar=False,
).to("cuda")

tts.tts_to_file(
    text="안녕하세요. 음성 합성 테스트입니다.",
    speaker_wav="reference_voice.wav",   # voice cloning
    language="ko",
    file_path="output.wav",
)

HiFi-GAN (Vocoder)

Mel → waveform 변환. Generator + Multi-scale + Multi-period Discriminator.

flowchart LR
    Mel["Mel (80 × T)"] --> Gen["Generator<br/>(dilated convolutions + upsampling)"]
    Gen --> Wave["Waveform (24kHz)"]
    Wave -.학습 시.-> MSD["Multi-Scale Discriminator"]
    Wave -.학습 시.-> MPD["Multi-Period Discriminator"]

학습: adversarial + mel loss + feature matching.
추론: 생성기만 사용. real-time factor < 1.
Quality: WaveNet 수준, 100x 빠름.

StyleTTS 2 (2023)

flowchart TB
    Text --> Enc["Text Encoder"]
    Style["Reference audio<br/>(voice + style)"] --> SE["Style Encoder"]
    Enc --> Dur["Duration + Prosody Predictor"]
    SE --> Dur
    Dur --> Diff["Style Diffusion Model"]
    Diff --> Dec["Decoder + HiFi-GAN"]
    Dec --> Audio

Diffusion + adversarial hybrid.
Voice cloning 3초 sample.
Human-level quality (MOS 4.5+).

Flow Matching TTS (F5-TTS, 2024)

flowchart LR
    Noise["Random noise"] --> ODE["Flow Matching ODE"]
    Text --> ODE
    Ref["Reference audio (선택)"] --> ODE
    ODE --> Audio["Audio"]

Diffusion 의 더 효율적 변형.
3-shot voice cloning.
자체 호스팅 친화 (Apache 2.0).

Text Normalization

# 숫자, 기호, 약어 → 발음 가능 형태
"$5"    → "다섯 달러"
"100"   → "백" 또는 "일영영"
"AI"    → "에이아이"
"3:30"  → "세 시 삼십 분"

# Python: normalize
import re

def normalize_kr(text):
    text = re.sub(r'\$(\d+)', lambda m: number_to_kor(int(m.group(1))) + ' 달러', text)
    text = re.sub(r'(\d+)원', lambda m: number_to_kor(int(m.group(1))) + ' 원', text)
    text = text.replace('AI', '에이아이')
    text = text.replace('API', '에이피아이')
    return text

G2P (Grapheme-to-Phoneme)

한국어:

"안녕하세요"
→ 발음: "안녕하세요"
→ IPA: /an.njʌŋ.ha.se.jo/

라이브러리:

g2pK (한국어) - Rule-based
phonemizer (다국어) - eSpeak
KoG2P - Sequence-to-sequence

from g2pk import G2p
g2p = G2p()

print(g2p("안녕하세요"))          # "안녕하세요"
print(g2p("Hello 안녕"))           # "헬로 안녕"
print(g2p("2026년 6월"))           # "이천이십육년 육월"

Prosody 제어 (SSML)

자세한 SSML 은 [[tts-streaming-ssml]].

# 모델에 직접 prosody 전달
audio = tts.synthesize(
    text="안녕하세요",
    speaker_id="female-1",
    speed=1.2,        # 20% 빠르게
    pitch=+2,         # 반음 2 up
    energy=1.1,       # 10% 큰 소리
)

Voice Cloning (few-shot)

# XTTS-v2 (6초 sample 로 cloning)
tts.tts_to_file(
    text="한 번도 만난 적 없는 사람의 목소리를 합성합니다.",
    speaker_wav="unknown_person_6sec.wav",   # ← 그 사람 음성 sample
    language="ko",
    file_path="cloned.wav",
)

내부:

Speaker encoder → 256-dim embedding.
TTS generator 가 embedding 조건 삽입.
새 텍스트 + 그 embedding → 합성.

흔한 함정

[!WARNING]

normalization 없이 = “$100” → “달러 백” 같이 이상. Front-end 처리 필수.

G2P 무시 = 한자, 영어 발음 이상. g2pK 등.

VITS 학습 데이터 편향 = 특정 speaker 만 자연스러움. Multi-speaker 학습.

Vocoder 만 교체 = mismatch → 음질 나빠짐. 함께 학습 필요.

[Voice] Whisper 내부: encoder-decoder, log-mel, tokenizer

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Whisper = OpenAI 의 encoder-decoder Transformer STT. 680K 시간 다국어 supervised training. 2022 공개, 2023 v2, 2023 v3.

개요는 [[stt-models-overview]] 참고. 본 페이지는 내부 아키텍처 + 코드.

아키텍처

flowchart TB
    Audio["30s audio (16kHz mono)"] --> LMS["Log-Mel Spectrogram<br/>(80 channels × 3000 frames)"]
    LMS --> Enc["Transformer Encoder<br/>(N layers, self-attention)"]
    Enc --> KV["Encoder hidden states"]
    KV --> Dec["Transformer Decoder<br/>(cross-attention to encoder)"]
    Tokens["Special + text tokens"] --> Dec
    Dec --> Out["다음 token 예측"]

모델 사이즈

모델	Layers	Width	Heads	Params
tiny	4	384	6	39M
base	6	512	8	74M
small	12	768	12	244M
medium	24	1024	16	769M
large-v3	32	1280	20	1550M

Log-Mel Spectrogram

import numpy as np
import librosa

# 16kHz, 30초 = 480000 samples
audio, sr = librosa.load('sample.wav', sr=16000)
audio = audio[:16000 * 30]   # 30초 padding/trim

# Log-mel spectrogram
mel = librosa.feature.melspectrogram(
    y=audio,
    sr=16000,
    n_fft=400,       # window 25ms
    hop_length=160,  # stride 10ms
    n_mels=80,       # 80 mel channels
)
log_mel = np.log10(np.clip(mel, 1e-10, None))
# shape: (80, 3000)

파라미터	값
Window	25ms (400 samples at 16kHz)
Hop	10ms (160 samples)
Mel channels	80
Input size	80 × 3000

Encoder (self-attention)

mel (80, 3000) → conv1d → conv1d → transformer layers

양방향 self-attention (모든 시간대 봄).
Output: (1500, d_model) (2x downsample).

Decoder (autoregressive)

<|startoftranscript|> <|ko|> <|transcribe|> <|notimestamps|> "안" "녕" "하세요" <|endoftext|>

각 토큰 예측:

cross-attention: encoder hidden states 참조.
causal self-attention: 옛 토큰만 봄.

Special Tokens

Token	의미
`<	startoftranscript
`<	en
`<	transcribe
`<	translate
`<	notimestamps
`<	0.00
`<	endoftext

Timestamp 생성

# 예 (with timestamps):
<|startoftranscript|> <|ko|> <|transcribe|>
<|0.00|> 안녕하세요 <|1.50|>
<|1.50|> 오늘 <|2.00|>
<|2.00|> 날씨가 좋네요 <|3.50|>
<|endoftext|>

모델이 timestamp token 을 다른 vocab 처럼 예측. 정확도는 word-level ~200ms 오차.

30초 chunking

def transcribe_long_audio(audio, model):
    chunk_size = 30 * 16000   # 30초
    stride = 25 * 16000        # 25초 (5초 overlap)

    results = []
    for start in range(0, len(audio), stride):
        chunk = audio[start:start + chunk_size]
        chunk = pad_or_trim(chunk, chunk_size)

        mel = log_mel_spectrogram(chunk)
        result = model.decode(mel, options)
        results.append(result)

    return merge_with_overlap(results)

Whisper 는 30초 단위 만 처리. 긴 오디오는 chunking + overlap.

Hallucination 문제

무음 구간 → 모델이 *없는 문장 생성*

해결:

VAD 전처리 (Silero) - 무음 제거
Temperature 0 - 결정론적
compression_ratio_threshold - 반복 감지
logprob_threshold - 확신 낮으면 skip

result = model.transcribe(
    audio,
    language='ko',
    temperature=0,
    compression_ratio_threshold=2.4,
    logprob_threshold=-1.0,
    no_speech_threshold=0.6,   # VAD 임계
    condition_on_previous_text=False,   # hallucination 방지
)

Faster-Whisper (CTranslate2)

from faster_whisper import WhisperModel

model = WhisperModel(
    "large-v3",
    device="cuda",
    compute_type="float16",   # 또는 int8_float16
)

segments, info = model.transcribe(
    "audio.wav",
    language="ko",
    beam_size=5,
    vad_filter=True,   # 내장 Silero VAD!
    vad_parameters={"min_silence_duration_ms": 500},
)

for seg in segments:
    print(f"[{seg.start:.2f} → {seg.end:.2f}] {seg.text}")

최적화	배속
CTranslate2	~4x
INT8 quantization	+2x
Beam search skip (greedy)	+1.5x
VAD filter	노이즈 절감

Distil-Whisper

Teacher (large-v3) → Distillation → Student
- Decoder layers 축소 (32 → 2)
- ~6x 빠름, 49% 작음
- 영어 정확도 유지, 다국어 약함

Streaming (WhisperLive, WhisperLink)

Whisper 는 batch 모델 → streaming 은 별도 wrapper:

flowchart LR
    Mic --> Buffer["Buffer (수 초)"]
    Buffer --> VAD
    VAD -->|"음성 감지"| Chunk["30초 chunk"]
    Chunk --> Whisper
    Whisper --> Merge["overlap merge"]
    Merge --> Text

partial transcript 를 30초 chunk 마다 갱신.
Overlap 으로 문장 경계 매끄럽게.
완전 real-time 은 아님 (500ms-1.5s 지연).

Vocab (Multilingual Tokenizer)

# GPT-2 style BPE (Byte-Pair Encoding)
tokenizer.encode("안녕하세요")
# → [23283, 9573, 7539, ...] (subword tokens)

len(tokenizer.vocab)   # 51864 tokens

Multilingual model = 다국어 subword 학습. 한국어도 자연스러운 tokenization.

흔한 함정

[!WARNING]

긴 오디오 그대로 넣음 = 30초 이상 무시. Chunking 필수.

VAD 없이 = 무음 구간 hallucination.

condition_on_previous_text=True (기본) = 옛 오류가 다음 chunk 로 전파.

CTranslate2 없이 batch = 4배 느림. Faster-whisper 권장.

김신건의 로그 - 위키 / voice

[Voice AI] Speech-to-Speech: OpenAI Realtime, Gemini Live, Moshi

정의

주요 모델

OpenAI Realtime API

Session 이벤트

Gemini Live

Moshi (OSS, self-host)

S2S vs Streaming Cascading 비교

적합 시나리오

Function Calling 제약

비용 비교

흔한 함정

관련 위키

[Voice AI] STT 모델: Whisper, Deepgram, AssemblyAI, CLOVA

정의

주요 모델 매트릭스 (2026)

Whisper 의 위치

모델 사이즈 vs 정확도 vs 속도 (Whisper)

한국어 STT 선택 가이드

Diarization (화자 분리)

API vs Self-host

평가 지표

흔한 함정

관련 위키

[Voice AI] STT 스트리밍: partial vs final, endpointing, gRPC/WS

정의

partial vs final

Endpointing (발화 종료 감지)

시맨틱 endpointing 의 가치

프로토콜: WebSocket vs gRPC

WebSocket 예시 (Deepgram)

gRPC 예시 (CLOVA, Python)

지표

흔한 함정

관련 위키

[Voice AI] TTS 모델: ElevenLabs, Cartesia, Edge TTS, 한국어

정의

뉴럴 TTS 구조

주요 모델 매트릭스 (2026)

TTFB (Time-to-First-Byte) 비교

Edge TTS (Microsoft 비공식 API)

한국어 TTS 선택

Voice Cloning

발음 교정 사전 (lexicon)

평가 지표

흔한 함정

관련 위키

[Voice AI] TTS 스트리밍 + SSML: TTFB, sentence aggregation, 청킹

정의

TTFB 의 중요성

Sentence Aggregation

SSML (Speech Synthesis Markup Language)

주요 SSML 태그

스트리밍 프로토콜

오디오 청크 형식

ElevenLabs 스트리밍 예시

Cartesia 스트리밍 (WebSocket)

발음 제어 패턴

흔한 함정

관련 위키

[Voice AI] Turn Detection + Barge-in + AEC: 자연스러운 대화

정의

1. Turn Detection (시맨틱)

순수 VAD endpointing 의 한계

시맨틱 Turn Detection

2. Barge-in (끼어들기)

Barge-in 흐름

Disallow Interruptions (보호)

3. Echo Cancellation (AEC)

문제: 자기 목소리가 다시 마이크로

해결 3계층

서버측 Echo Gate

4. Sentence Aggregation (LLM 토큰 → TTS 문장)

통합 흐름

흔한 함정

관련 위키

[Voice AI] VAD: Silero, 에너지 기반, endpointing 임계값

정의

종류