๋์กธ์ค ํ ์ธ์ด์ฅ์ ์ง๋จ์ ์ํ ๋ฅ๋ฌ๋ ๊ธฐ๋ฐ ์ธ์ด ๊ธฐ๋ฅ ํ๊ฐ ์๋น์ค โ ๋๋ฐ๋๋ฐ ๋งํ๊ธฐ ํญ๋ชฉ ๋ด๋น
์ค์ด์ฆ(Aphasia)ยท๋ง๋น๋ง์ฅ์ (Dysarthria)๋ ๋์กธ์ค, ์ธ์์ฑ ๋์์, ์ ๊ฒฝํดํ์ฑ ์งํ์ผ๋ก ์ธํด ํ์์ ์์ฌ์ํต ๋ฅ๋ ฅ๊ณผ ์ถ์ ์ง์ ์ค๋ํ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
ํ์ฌ ์์ ํ๊ฐ๋ ์ธ์ด์น๋ฃ์ฌยท์ ๊ฒฝ๊ณผ ์ ๋ฌธ์์ ์ฒญ์ง๊ฐ์ ํ๋จ์ ์์กดํ๋ฉฐ, ์ฃผ๊ด์ฑ ๊ฐ์
, ์๊ฐ/์ธ๋ ฅ ์๋ชจ, ์ ๋์ ์ถ์ ๋ถ๊ฐ ๋ฑ์ ํ๊ณ๊ฐ ์์ต๋๋ค.
๋ณธ ํ๋ก์ ํธ๋ ์์ฑ ๋ฐ์ดํฐ ๊ธฐ๋ฐ์ ๋ฅ๋ฌ๋ ๋ชจ๋ธ๋ก ์ด ํ๊ณ๋ฅผ ๋ณด์ํ๋ ์๋ ํ๊ฐ ์์คํ ์ ๊ตฌ์ถํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค.
CLAP-D ๊ฒ์ฌ๋ ๋ง๋น๋ง์ฅ์ ๋ฅผ ์ํ 5๊ฐ์ง ํญ๋ชฉ์ผ๋ก ๊ตฌ์ฑ๋๋ฉฐ, ๊ทธ ์ค ๋๋ฐ๋๋ฐ ๋งํ๊ธฐ ํญ๋ชฉ์ ๋ด๋นํ์์ต๋๋ค.
| ํญ๋ชฉ | ๋ด์ฉ |
|---|---|
| ๋๋ฐ๋๋ฐ ๋งํ๊ธฐ | ํ๊ฐ์๊ฐ ์ ์ํ ๋จ์ดยท๋ฌธ์ฅ์ ๋๋ฐ๋๋ฐ ๋งํ๋ ๊ฒ์ฌ, 25๋ฌธํญ |
- ๊ฒ์ฌ์(ํ์)์ ๋ฐํ ์์ฑ + ํ๊ฐ์์ ์ ์ ํ ์คํธ, ๋ ์ ๋ ฅ์ ๋์์ ์ฒ๋ฆฌ
- ๊ฐ ๋ฌธํญ์ ์ ์๋ฅผ ์์ธกํ์ฌ ์ต์ข ์ฑ์ ์ ์(์ ์)๋ฅผ ์ฐ์ถ
- ์ต์ข ํ๊ฐ ์งํ: Accuracy ๋ฐ Pearson ์๊ด๊ณ์(r)
CLAP_D/
โโโ scr/
โ โโโ data/
โ โ โโโ preprocess.py # ์์ฑโ๋ฉ์คํ, ํ
์คํธโ์๋ชจ ์ธ๋ฑ์ค ์ ์ฒ๋ฆฌ
โ โ โโโ split.py # ์ ์๋ณ ๊ณ์ธต ๋ถ๋ฆฌ ํ train/valid/test ๋ถํ
โ โโโ models/
โ โ โโโ # Cross-Attention ๋ชจ๋ธ
โ โโโ utils/
โ โ โโโ augment_utils.py # ํผ์น ์ด๋ + ์๋ ๋ณํ ์ฆ๊ฐ
โ โ โโโ data_utils_class.py # ๋ฐ์ดํฐ ๋ก๋, ์ฆ๊ฐ ํตํฉ, reliable ์ ํ
โ โ โโโ train_utils.py # ํ์ต ๋ฃจํ, ์์ค ๊ฐ์ค์น ์ ์ฉ
โ โ โโโ wav_utils.py # WAV โ ๋ฉ์คํํธ๋ก๊ทธ๋จ ๋ณํ
โ โ โโโ jamo_utils.py # ํ๊ตญ์ด ์๋ชจ ๋ถ๋ฆฌ ๋ฐ ์ ์ ์ธ์ฝ๋ฉ
โ โโโ train/
โ โ โโโ train.py # ์ ์ฒด ์คํ ์กฐํฉ ๊ทธ๋ฆฌ๋ ์์น ์คํ
โ โโโ evaluate/
โ โโโ test.py # ๋ชจ๋ธ ๋ก๋ โ ์์ธก โ accuracy/corr ์ฐ์ถ โ CSV ์ ์ฅ
โโโ data/
โ โโโ csv/ # ๋ชจ๋ธ๋ณ score_df, compare_df ๊ฒฐ๊ณผ
โ โโโ npy/ # ์ ์ฒ๋ฆฌ๋ ์
๋ ฅ ๋ฐ์ดํฐ (โป ๋ฏธํฌํจ)
โ โโโ wav_flie/ # ์๋ณธ ์์ฑ ๋ฐ์ดํฐ (โป ๋ฏธํฌํจ)
โโโ checkpoints/ # ํ์ต๋ ๋ชจ๋ธ ๊ฐ์ค์น (โป ๋ฏธํฌํจ)
โป data/npy, data/wav_flie: ์ ์๊ถ์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ณต๋ฐ์ ์ฌ์ฉํ์์ผ๋ฏ๋ก ์ ์ฅ์์ ํฌํจํ์ง ์์ต๋๋ค.
โป checkpoints: ๋ชจ๋ธ ํ์ผ(.keras)์ ์ฉ๋์ด ์ปค ์ ์ฅ์์ ํฌํจํ์ง ์์ต๋๋ค.
| ๋จ๊ณ | ํ์ผ | ํจ์ / ํด๋์ค | ์ค๋ช | ์ ํ์ง |
|---|---|---|---|---|
| 1. ์ ์ฒ๋ฆฌ | wav_utils.py |
x_data_preprocess() |
wav ํ์ผ โ ๋ฉ ์คํํธ๋ก๊ทธ๋จ โ x1_data.npy | - |
jamo_utils.py |
text_to_ctc_indices() |
์ ์ ํ ์คํธ โ ์๋ชจ ์ธ์ฝ๋ฉ โ x2_data.npy | - | |
| 2. ๋ฐ์ดํฐ ๋ก๋ | data_utils.py |
data_load() |
npy ํ์ผ ๋ก๋ ๋ฐ ๋ฐ์ดํฐ ๊ตฌ์ฑ | - |
| 3. ๋ฐ์ดํฐ ๊ตฌ์ฑ | data_utils.py |
make_list() |
๋ฌธํญ๋ณ ๋ ๋ฆฝ ํ์ต ๋ฐ์ดํฐ ๊ตฌ์ฑ | no1 ~ no25 |
total_concat() |
์ ์ฒด 25๋ฌธํญ ๋ณํฉ | total | ||
select_reliable_data() |
Target ๋ถ์ฐ ์์ 3๋ฌธํญ ์ ํ | reliable | ||
| 4. ๋ฐ์ดํฐ ์ฆ๊ฐ | data_utils.py |
augment() |
Targetโ 1 ์์ ์ํ๋ง ์ ํํ์ฌ ์ฆ๊ฐ | aug / no aug |
augment_utils.py |
speed_aug() |
๋ฉ ์คํํธ๋ก๊ทธ๋จ ์๊ฐ์ถ ์ ํ ๋ณด๊ฐ (์๋ ๋ณํ) | ||
pitch_aug() |
๋ฉ ๋น(bin) ๋จ์ ์ฃผํ์ ์ถ ์ด๋ (ํผ์น ๋ณํ) | |||
| 5. ๋ชจ๋ธ ์์ฑ | model_1D.py |
make_talk_clean_model() |
CNN โ GRU โ Attention ร 6 โ Dense(1) | 1D / 2D, linear / relu |
| 6. ๋ชจ๋ธ ํ์ต | train_utils.py |
model_train() |
Adam ยท MSE ยท EarlyStopping์ผ๋ก ํ์ต | lossO / lossX |
weight_return() |
์ ์๋ณ ์ญ์ ๊ฐ์ค์น ๊ณ์ฐ (lossO ์ ์ฉ ์) | |||
| 7. ํ๊ฐ | test.py |
model.predict() |
์์ธก๊ฐ(0~1) ร Score(Alloc) โ round โ Accuracy / Pearson r โ CSV | - |
Python TensorFlow/Keras NumPy Pandas Mel-Spectrogram Multi-Head Attention CNN Bidirectional GRU
| ํญ๋ชฉ | ๋ด์ฉ |
|---|---|
| ์ ์ฒด ์ํ ์ | 1,500๊ฐ (25๋ฌธํญ ร 60๊ฐ) |
| ์์ฑ ์ ๋ ฅ (x1) | ๋ฉ ์คํํธ๋ก๊ทธ๋จ, shape (128, 312), ํจ๋ฉ๊ฐ -80.0 |
| ํ ์คํธ ์ ๋ ฅ (x2) | ์ ์ ๋จ์ด ์๋ชจ ๋ถ๋ฆฌ ํ ์ ์ ์ธ์ฝ๋ฉ, shape (12,) |
| ์ ๋ต ๋ ์ด๋ธ | Score(Refer) โ ํ๊ฐ์๊ฐ ๋ถ์ฌํ ์ค์ ์ฑ์ ์ ์ (์ ์) |
| ํ์ต ํ๊ฒ | Target = ๋์ / ๋ง์ โ 0~1 ์ฌ์ด์ ์ฐ์ ๋น์จ๊ฐ |
๋ชจ๋ธ์ ๋์ ๋น์จ(0~1)์ ์์ธกํ๊ณ , ์์ธก๊ฐ์ ํด๋น ๋ฌธํญ์ ๋ง์ (Score(Alloc))์ ๊ณฑํ ๋ค ๋ฐ์ฌ๋ฆผํ์ฌ ์ต์ข
์ ์ ์ ์๋ก ๋ณํํฉ๋๋ค.
์์ธก ํ๋ฆ: ๋ชจ๋ธ ์ถ๋ ฅ(0~1) ร Score(Alloc) โ ๋ฐ์ฌ๋ฆผ โ ์ต์ข
์ ์
Target = 1 (๋ง์ ) : ~74.46% (๋๋ค์)
Target โ 1 (๊ฐ์ /0์ ) : ~25.54% (์์)
์ ์ฒด 25๋ฌธํญ ๋ชจ๋ ๋ง์ (Target=1) ๋น์จ์ด ์๋์ ์ผ๋ก ๋๊ณ ์ ์ ๋ถ์ฐ์ด ๋ฎ์ต๋๋ค.
์ด๋ ๋จ์ํ ๋ชจ๋ ์ํ์ ๋ง์ ์ผ๋ก ์์ธกํด๋ 74.46%์ accuracy๊ฐ ๋์ค๋ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค์ด,
๋ชจ๋ธ์ด ์ ์ ๋ถํฌ ํธํฅ์ ์ํด ํญ์ ๋ง์ ์ ์ถ๋ ฅํ๋ ๋ฐฉํฅ์ผ๋ก ์๋ ดํ ์ํ์ด ์์ต๋๋ค.
๋ฐํ ์์ฑ(Query)๊ณผ ์ ์ ํ
์คํธ(Key) ๊ฐ์ ์ ์ฌ์ฑ์ ์ธก์ ํ๊ธฐ ์ํด
Cross Multi-Head Attention ๊ตฌ์กฐ๋ฅผ ์ค์ฌ์ผ๋ก ์ค๊ณํ์์ต๋๋ค.
[์์ฑ ์
๋ ฅ (128ร312)]
โ
SequenceMask
โ
Conv1D ร 2 + BatchNorm + HardTanh
โ
LayerNormalization
โ
Bidirectional GRU (64ร2) [ํ
์คํธ ์
๋ ฅ (12,)]
โ โ
Sinusoidal Positional Encoding Embedding (55โ16)
โ โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Multi-Head Attention ร 6 (Q=์์ฑ, K/V=ํ
์คํธ) โ
โ + Add & Norm + FFN (Dense 512โ128) + Add & Norm โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ
GlobalAveragePooling1D + GlobalMaxPooling1D (concat)
โ
Dense (512, relu) โ Dense (1, linear)
โ
์์ธก๊ฐ ร Score(Alloc) โ round โ ์ต์ข
์ ์
| ๊ตฌ์ฑ ์์ | ์ธ๋ถ ๋ด์ฉ |
|---|---|
| ํจ๋ฉ ๋ง์คํฌ | ์ ํจ ์์ฑ ๊ธธ์ด ์ถ์ถ, ํจ๋ฉ ์ ์ธ |
| CNN | Conv1D(512, kernel=11, stride=2) or Conv1D(512, kernel=11, stride=1) |
| ํ์ฑํ | HardTanh (clip [-20, 20]) |
| RNN | Bidirectional GRU(64), dropout=0.1 |
| ์์น ์ธ์ฝ๋ฉ | Sinusoidal Positional Encoding |
| Attention | MultiHeadAttention(heads=16, key_dim=32, dropout=0.1) ร 6 |
| ์ถ๋ ฅ์ธต | Dense(1, activation=out) โ relu ๋๋ linear |
| ํ์ต | Adam(lr=0.001), loss=MSE, EarlyStopping(patience=10) |
| ๋ฐฐ์น ํฌ๊ธฐ | 64, ์ต๋ 100 epoch |
์ด 8๊ฐ์ง ๋ชจ๋ธ ร 25๋ฌธํญ + total + reliable + aug ๋ฒ์ = ๋๊ท๋ชจ ๊ทธ๋ฆฌ๋ ์์น
(itertools.product๋ก ๋ชจ๋ ์กฐํฉ ์๋ ์์ฑ)
| ๋ณ์ | ์ ํ์ง | ๋น๊ณ |
|---|---|---|
| ํ์ต ๋ฐ์ดํฐ ๊ตฌ์ฑ | no1~no25, total, reliable | ๋จ์ผ ํญ๋ชฉ์ ๋ฐ์ดํฐ๋ก ํ์ต๋ ๋ชจ๋ธ์ด ์ ์ฒด ํญ๋ชฉ์ ์์ธกํ ์ ์์์ง ํ์ธํ๊ธฐ ์ํด ๊ฐ ํญ๋ชฉ๋ณ๋ก๋ ํ์ต์ ์งํ |
| CNN ์ฐจ์ | 1D / 2D | 312์ ์๊ฐ์ถ์ 128์ ํน์ฑ์ ์ง๋ 1D, ๊ฐ๋ก ์ธ๋ก ํ๋ฐฑ์ ์ด๋ฏธ์ง๋ฅผ ๊ฐ์ง 2D ๋ ๊ฐ์ง ๊ด์ ์ ์ฐจ์ด๊ฐ ์๋์ง ํ์ธํ๊ธฐ ์ํด ์งํ |
| ์ถ๋ ฅ ํ์ฑํ | relu / linear | ํ์ต ํ๊ฒ(๋์ ๋น์จ)์ ๋ฒ์๊ฐ 0~1 ์์ ๊ณ ๋ ค ์์ธก๊ฐ์ด ์์๊ฐ ๋์ง ์๋๋ก ReLU๋ฅผ ์๋ |
| ์์ค ๊ฐ์ค์น | lossO (์์) / lossX (์์) | ๋ฐ์ดํฐ ๋ถ๊ท ํ์ผ๋ก ์ธํด ์๊ธฐ๋ ์์ธกํธํฅ์ด ์์ค ๊ฐ์ค์น๋ก ํด๊ฒฐ๋๋์ง ํ์ธํ๊ธฐ ์ํด ์งํ |
| ๋ฐ์ดํฐ ์ฆ๊ฐ | aug ์ ์ฉ / ๋ฏธ์ ์ฉ | ๋ฏธ๋ง์ ํญ๋ชฉ์ ๋ฐ์ดํฐ๋ฅผ ์ฆ๊ฐ์ ํตํด ๋ชจ๋ธ์ ์ ํ๋๋ฅผ ๋์ผ ์ ์์์ง ํ์ธ์ ์ํด ์งํ |
์ ์ ๋ถํฌ ํธํฅยท์ผ๋ฐํ ์ฑ๋ฅ ๋ถ์กฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์๋ 5๊ฐ์ง ์ถ์ผ๋ก ์คํ์ ์งํํ์์ต๋๋ค.
25๊ฐ ๋ฌธํญ์ ์ด๋ป๊ฒ ์กฐํฉํด ํ์ตํ ์ง๋ ๋ณ์๋ก ์คํํ์์ต๋๋ค.
| ๊ตฌ์ฑ | ๋ด์ฉ |
|---|---|
no1 ~ no25 |
๊ฐ ๋ฌธํญ๋ณ ๋ ๋ฆฝ ๋ชจ๋ธ ํ์ต |
total |
25๋ฌธํญ ์ ์ฒด๋ฅผ ํ๋๋ก ํฉ์ณ ํ์ต |
reliable |
์ ์ ๋ถ์ฐ์ด ๊ฐ์ฅ ๋์ ์์ 3๊ฐ ๋ฌธํญ๋ง ์ ํํ์ฌ ํ์ต |
# reliable: Target ํ์คํธ์ฐจ ๊ธฐ์ค ์์ 3๋ฌธํญ ์ ํ
temp_list = d_2_csv.groupby('QUESTION_NO')['Target'].describe()[['std']] \
.sort_values('std', ascending=False).index[:3]
์๋: ๋ถ์ฐ์ด ๋ฎ์ ๋ฌธํญ(๋๋ถ๋ถ ๋ง์ )์ ๋ชจ๋ธ์ด "ํญ์ ๋ง์ ์ถ๋ ฅ"์ ํ์ตํ๋๋ก ์ ๋ํ๋ฏ๋ก ์ ์ธํ๊ณ ,
์๋์ ์ผ๋ก ์ ์ ๋ค์์ฑ์ด ๋์ ๋ฌธํญ๋ง ์ ๋ณํ์ฌ ํ์ต์ ์ง์ ๋์ด๊ณ ์ ํจ
๊ฒฐ๊ณผ: reliable๋ total๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ธฐ์ค์ ์์ค์ ๋ฒ์ด๋์ง ๋ชปํจ. ๋ฌธํญ ์ ์์ฒด๊ฐ ์ค์ด ๋ฐ์ดํฐ ๋ถ์กฑ ์ฌํ.
| ๊ตฌ๋ถ | ๋ฐฉ์ |
|---|---|
| 1D (baseline) | ๋ฉ ์คํํธ๋ก๊ทธ๋จ์ (์๊ฐ, ์ฃผํ์) ํํ๋ก ๋ณํ ํ Conv1D ์ฒ๋ฆฌ |
| 2D | (128, 312, 1) ์๋ณธ ํํ ๊ทธ๋๋ก Conv2D ์ฒ๋ฆฌ ํ Reshape |
# 1D: (B, 128, 312, 1) โ Permute โ (B, 312, 128) โ Conv1D
# 2D: (B, 128, 312, 1) โ Conv2D(32, (41,11), stride=(2,2)) โ Conv2D(32, (21,11), stride=(2,1))์๋: 2D CNN์ด ์ฃผํ์-์๊ฐ ์ถ์ 2์ฐจ์ ํจํด(ํฌ๋งํธ ๊ตฌ์กฐ ๋ฑ)์ ๋ ์ ํฌ์ฐฉํ ๊ฒ์ด๋ผ ๊ธฐ๋
๊ฒฐ๊ณผ: ๋์ผ ์กฐ๊ฑด(linear, lossX)์์ total accuracy ๋๋ฑ(0.5793), aug ๋ฐ์ดํฐ corr์์ 2D๊ฐ ์ํญ ์ฐ์ธ(0.5160 vs 0.4646)
ํ์ต ํ๊ฒ(๋์ ๋น์จ)์ 0~1 ๋ฒ์์ด๋ฏ๋ก, ์์ธก๊ฐ์ด ์์๊ฐ ๋์ง ์๋๋ก ReLU๋ฅผ ์๋ํ์์ต๋๋ค.
| ๊ตฌ๋ถ | ์ถ๋ ฅ์ธต ํ์ฑํ | ์๋ |
|---|---|---|
| relu | Dense(1, activation='relu') |
์์ธก๊ฐ โฅ 0 ๋ณด์ฅ |
| linear (baseline) | Dense(1, activation='linear') |
์ ์ฝ ์์ด ํ์ต |
๊ฒฐ๊ณผ: ReLU ๋ชจ๋ธ์ ํ์ต ์ค ์ถ๋ ฅ์ด 0์ผ๋ก ์์ ํ ์๋ ดํ๋ ํ์์ด ๋ฐ์ํ์์ต๋๋ค.
์ถ๋ ฅ์ธต์ ReLU๋ฅผ ์ ์ฉํ๋ฉด, ๋ด๋ฐ์ ์ ๋ ฅ๊ฐ์ด ์์๊ฐ ๋ ๊ฒฝ์ฐ ์ถ๋ ฅ์ด 0์ผ๋ก ๊ณ ์ ๋๊ณ ์ญ์ ํ ๊ธฐ์ธ๊ธฐ๋ 0์ด ๋ฉ๋๋ค (Dying ReLU ํ์). MSE ์์ค ํ๊ฒฝ์์ ์ด ์ํ๊ฐ ๋๋ฉด ๊ฐ์ค์น๊ฐ ๋ ์ด์ ์ ๋ฐ์ดํธ๋์ง ์์ ๋ชจ๋ธ์ด ๋ชจ๋ ์ํ์ ๋ํด 0์ (์์ธก๊ฐ=0)์ ์ถ๋ ฅํ๋ ์ํ๋ก ๊ณ ์ฐฉ๋ฉ๋๋ค. ๊ทธ ๊ฒฐ๊ณผ ์ค์ ์ ๋ต์ด 0์ ์ธ ์ํ๋ง ๋งํ๊ฒ ๋์ด accuracy โ 14.13%์ ๋จธ๋ฌผ๊ฒ ๋ฉ๋๋ค.
๋ฐ๋ฉด linear ํ์ฑํ๋ ์ด๋ฐ ์๋ ด ๋ฌธ์ ์์ด ์ ์์ ์ผ๋ก ํ์ต์ด ์ด๋ฃจ์ด์ก์ต๋๋ค.
weight_return ํจ์์์ ์ํ ๊ฐ์ค์น๋ฅผ ๊ณ์ฐํ์ฌ ํ์ต์ ์ ์ฉํฉ๋๋ค.
# lossO: ์ ์๋ณ ์ํ ๋น๋์ ์ญ์(์ ๊ณฑ๊ทผ)๋ฅผ ๊ฐ์ค์น๋ก ๋ถ์ฌ
weight[score] = sqrt(total / (num_unique_scores ร count[score]))
# lossX: ๋ชจ๋ ์ํ ๊ฐ์ค์น = 1 (๊ฐ์ค์น ์์)| ๊ตฌ๋ถ | ๋ด์ฉ |
|---|---|
| lossO (baseline) | ๋ง์ (Target=1) ์ธ ์์ ์ํ์ ๋ ๋์ ์์ค ๊ฐ์ค์น ๋ถ์ฌ |
| lossX | ๊ฐ์ค์น ์์ด ๊ท ๋ฑ ํ์ต |
์๋: ๋ง์ (Target=1) ์ธ ์์ ์ํ์ ๋์ ๊ฐ์ค์น๋ฅผ ์ค ๋ชจ๋ธ์ด ๋ง์ ๋ง ์์ธกํ์ง ์๋๋ก ์ ๋
๊ฒฐ๊ณผ: ์ญ์ค์ ์ผ๋ก lossX(๊ฐ์ค์น ์์)์ total accuracy๊ฐ ๋ ๋์(0.5793 vs 0.2593).
lossO๋ ์์ ์ํ์ ๊ณผํ ๊ฐ์ค์น๊ฐ ๋ถ์ฌ๋์ด ์คํ๋ ค ์ ์ฒด ์์ธก์ด ๋ถ์์ ํด์ง. ์ผ๋ถ ๋ฌธํญ(no14)์์๋ corr์ด ์ํญ ๋์์ง(r=0.6398).
๋ง์ (Target=1) ์ธ ์์ ์ํ์ ์ ๋๋์ด ๋ถ์กฑํ์ฌ ์์ฑ ์ฆ๊ฐ์ ์ ์ฉํ์์ต๋๋ค.
# ์๋ ๋ณํ: ์๋ณธ ๋ฐํ์ ์ฌ์ ์๋๋ฅผ ๋ฌด์์ ๋ณ๊ฒฝ (๊ฐ์/๊ฐ์)
speed = random(slow_range) or random(fast_range)
# โ ๋ฉ ์คํํธ๋ก๊ทธ๋จ์ ์๊ฐ์ถ์ ์ ํ ๋ณด๊ฐ์ผ๋ก ๋ฆฌ์ํ๋ง
# ํผ์น ์ด๋: ๋ฉ ๋น(bin)์ ์์๋๋ก ๋ฌด์์ ์ด๋
shift_bins = random(-max_pitch_bins, +max_pitch_bins)
# min_pitch_bins=5, max_pitch_bins=10 (5~10 bin ๋ฒ์ ๊ฐ์ )| ์ฆ๊ฐ ๊ธฐ๋ฒ | ๊ตฌํ |
|---|---|
| ์๋ ๋ณํ | augment_utils.py / speed_aug() โ ๋ฉ ์คํํธ๋ก๊ทธ๋จ ์๊ฐ์ถ ์ ํ ๋ณด๊ฐ ๋ฆฌ์ํ๋ง |
| ํผ์น ์ด๋ | augment_utils.py / pitch_aug() โ ๋ฉ ๋น(bin) ๋จ์ ์ฃผํ์ ์ถ ์ด๋ |
| ๋ฐ์ดํฐ ๋ณํฉ | augment_utils.py / make_aug_dataset_pitch_speed() โ ์๋/ํผ์น ํจ์๋ฅผ ์ฌ์ฉํด ๋ฐ์ดํฐ ์ฆ๊ฐ |
| ์์ ์ํ ์ ํ | data_utils.py / augment() โ idx_0/idx_1 ๋ถ๋ฆฌ โ Targetโ 1 ์ํ๋ง ์ ํํ์ฌ ์ฆ๊ฐ |
์๋: ์์ ์ํ์ ๋๋ ค ์ ์ ๋ถํฌ ํธํฅ ์ํ
๊ฒฐ๊ณผ: aug ์ ์ฉ ์ ์ผ๋ถ ๋ฌธํญ์์ ๊ฐ์ . ํนํ 1D_relu_lossX์ no4_aug๊ฐ corr=0.7001๋ก ์ ์ฒด ์ต๊ณ ์๊ด๊ณ์ ๋ฌ์ฑ. ๋จ, ์ด๋ ํน์ ๋ฌธํญ + aug ์กฐํฉ์์์ ์ด๋ก์ ํ์์ผ๋ก, total/reliable ์์ธก์์๋ ๊ฐ์ ๋์ง ์์ ์ ๋ขฐํ๊ธฐ ์ด๋ ค์.
| ๋ชจ๋ธ | total acc | total corr | ์ ํจ ๋ฌธํญ ์ (acc>0.30 / ๊ฐ๋ณ 25๋ฌธํญ+๋ณํฉ๋ฌธํญ+๋ถ์ฐ๋ฌธํญ) |
|---|---|---|---|
| 1D_linear_lossX | 0.5793 | 0.4748 | 16 / 27 |
| 2D_linear_lossX | 0.5793 | 0.4748 | 17 / 27 |
| 1D_linear_lossO | 0.2593 | 0.5129 | 4 / 27 |
| 2D_linear_lossO | 0.2593 | 0.5129 | 2 / 27 |
| 1D_relu_lossO | 0.1413 | N/A | 4 / 27 |
| 2D_relu_lossO | 0.1413 | N/A | 1 / 27 |
| 1D_relu_lossX | 0.1413 | N/A | 0 / 27 |
| 2D_relu_lossX | 0.1413 | N/A | 0 / 27 |
---
๊ฐ์ฅ ์ข์ ๋ณด์ด๋ ๋ฌธํญ(no1)์ accuracy 0.7447์ ์ค์ ํ์ต์ ๊ฒฐ๊ณผ๊ฐ ์๋์์ต๋๋ค.
์ค์ =0 ์ค์ =1 ์ค์ =2 ์ค์ =3
์์ธก=1 (300) 65 235 0 0
์์ธก=2 (780) 102 99 579 0
์์ธก=3 (420) 45 17 55 303
์ ์ 0 ์ ๋ต๋ฅ : 0 / 212 = 0.0% โ ํ ๋ฒ๋ ๋งํ์ง ๋ชปํจ
์ ์ 1 ์ ๋ต๋ฅ : 235 / 351 = 66.9%
์ ์ 2 ์ ๋ต๋ฅ : 579 / 634 = 91.3%
์ ์ 3 ์ ๋ต๋ฅ : 303 / 303 = 100%
์ ์ฒด accuracy: 1117 / 1500 = 74.47%
๋ฌธ์ ์ : 0์ ์์ธก์ ์ ํ ํ์ง ๋ชปํ๊ณ , ํน์ ์ ์๊ฐ์ผ๋ก ํธํฅ๋ ์์ธก์ ํจ. ์ด๋ ์ค์ ๋ชจ๋ธ์ด ์์ธกํ ๊ฐ์ด Target์ 1๊ฐ์ธ ๋ง์ ์ ์์ธกํ๊ณ , 74.46%๊ฐ ๋ฐ์ดํฐ์ ์ง๋ฐฐ์ ์ ์(๋ง์ =Target=1)์ ๋น์จ ๊ทธ ์์ฒด์ด๊ธฐ ๋๋ฌธ์ ๋๋ค.
๋ชจ๋ ์คํ์์ ๋์ accuracy๋ฅผ ๋ณด์ธ ๋ชจ๋ธ๋ค์ ๊ณตํต์ ์ผ๋ก
์ง๋ฐฐ์ ์ธ ์ ์๊ฐ(๋ง์ =Target=1)๋ง ์์ธกํ๊ฑฐ๋ ํน์ ์ ์ ์กฐํฉ์์ ์ฐ์ฐํ ๋์ ์ ํ๋๋ฅผ ๊ธฐ๋กํ๋
์ ์ ๋ถํฌ ํธํฅ๋ ํ์ต์ ๊ฒฐ๊ณผ์์ผ๋ฉฐ, ์ค์ ๋ก ์ธ์ด์ฅ์ ์ง๋จ์ ํ์ฉํ ์ ์๋ ์์ค์ ์ผ๋ฐํ ์ฑ๋ฅ์ ๋ฌ์ฑํ์ง ๋ชปํ์์ต๋๋ค.

| ์งํ | ์๋ฏธ | ๊ตฌํ | ํ๊ณ |
|---|---|---|---|
| Accuracy | ์์ธก๊ฐ == ์ ๋ต์ธ ๋น์จ | np.mean(process_score == correct_y) |
์ ์ ๋ถํฌ ํธํฅ ์ ์ง๋ฐฐ์ ์ ์ ์์ธก๋ง์ผ๋ก๋ ๋๊ฒ ๋์ด |
| Pearson r | ์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ ํ ์๊ด | np.corrcoef(...) |
์ค์ ์์์ ์ ์ฉ์ฑ์ ๋ ์ ๋ฐ์ |
์์ ์ ์ธ ์กฐ๊ฑด(linear + lossX)์์์ corr์ ์ฝ 0.47~0.51 ์์ค์ ๋จธ๋ฌผ๋ ์ต๋๋ค.
| ๋ฌธ์ | ๋ด์ฉ |
|---|---|
| ์ ์ ๋ถํฌ ํธํฅ | ์ ์ฒด 25๋ฌธํญ ๋ชจ๋ ๋ง์ ๋น์จ ~74%. ์์ค ๊ฐ์ค์นยท์ฆ๊ฐ์ ์๋ํ์ผ๋ ๊ทผ๋ณธ์ ํด๊ฒฐ ๋ถ๊ฐ |
| ๋ฐ์ดํฐ ๋ถ์กฑ | ๋ฌธํญ๋น ์ฝ 60๊ฐ ์ํ์ผ๋ก ๋ฅ๋ฌ๋ ๋ชจ๋ธ์ ์ผ๋ฐํ์ ์ถฉ๋ถํ์ง ์์ |
| ํ๊ฐ ์งํ ์ค๋ฅ | Accuracy๊ฐ ์ ์ ๋ถํฌ ํธํฅ ์ํฉ์ ๋ฐ์ํ์ง ๋ชปํด, ํ์ต ์คํจ๋ฅผ ์ฑ๊ณต์ผ๋ก ์ค์ธํ ๋ปํจ |
| ReLU ์๋ ด ๋ฌธ์ | MSE ์์ค + ReLU ์ถ๋ ฅ์ธต ์กฐํฉ์์ Dying ReLU ํ์์ผ๋ก ์์ธก๊ฐ์ด 0์ผ๋ก ๊ณ ์ฐฉ |
| ์ง๊ณ(total) ์ญํจ๊ณผ | ๊ฐ๋ณ ๋ฌธํญ๋ณด๋ค ์ ์ฒด ์์๋ธ(total)์ด ์คํ๋ ค ์ฝํจ โ ํน์ ์ ์ ์์ธก ๋ฅ๋ ฅ์ด ํ๊ท ํ ๊ณผ์ ์์ ์์ค |
์ฒ์๋ถํฐ ํ์ตํ ๋ชจ๋ธ(Zerobase)๋ง์ผ๋ก๋ ํ๋ก์ ํธ ๋ชฉํ ๋ฌ์ฑ์ ํ๊ณ๊ฐ ์์ด, ์ถํ ์คํ์์ค STT ๋ชจ๋ธ์ ํ์ฉํ์ฌ ์๋ชจ ๋จ์ ์์ฑ ์ธ์ ๋ชจ๋ธ์ ๊ตฌ์ถํ๊ณ ์ด๋ฅผ ์ ์ฉํ ๊ณํ์ ๋๋ค.