VERIFIKASI SUARA MENGGUNAKAN METODE MFCC DAN DTW MENGGUNAKAN METODE MFCC DAN DTW (BAB III METODE DAN PERANCANGAN SISTEM)


BAB III
METODE DAN PERANCANGAN SISTEM

Dalam bab Metode dan Perancangan Sistem ini dipaparkan mengenai perancangan dan pembuatan perangkat lunak verifikasi suara menggunakan metode mfcc dan dtw. Bab ini meliputi tempat dan waktu penelitian, cara penelitian dan gambaran umum mengenai proses pembuatan program.
3.1 Tempat dan Waktu Penelitian
Penelitian dilakukan di Jurusan Teknik Elektro Fakultas Teknik Universitas Udayana dari bulan Oktober 2009 hingga Januari 2009.
3.2  Data
3.2.1 Sumber Data
Data diperoleh dari jurnal dan artikel-artikel dari internet yang berhubungan dengan pembuatan sistem verifikasi suara menggunakan metode mfcc dan dtw serta data suara yang diperoleh langsung dari pengguna sistem. Data kemudian disusun dan diolah agar dapat dipakai sebagai acuan di dalam menyusun tugas akhir ini.
3.2.2 Metode Pengumpulan Data
Metode pengumpulan data menggunakan metode studi literatur, yaitu mengumpulkan data dari buku-buku referensi, modul-modul yang relevan dengan objek permasalahan, serta menggunakan metode studi observasi, yaitu dengan mengumpulkan data suara dari pengguna sistem secara langsung dengan cara mencoba sistem secara langsung.
3.3 Alur Analisis
Alur analisis dari penelitian yang dilakukan adalah sebagai berikut :
1.      Pendefinisian permasalahan dari aplikasi yang ingin dibuat untuk menambah pemahaman mengenai hal tersebut.
2.      Pengumpulan data yang berhubungan dengan perancangan dan pembuatan sistem, melalui studi literatur.
3.      Pemahaman terhadap proses-proses yang terjadi, sehingga dapat dilakukan suatu pemodelan data.
4.      Pembuatan perangkat lunak.
5.      Pengujian terhadap perangkat lunak yang telah dibuat, dengan cara memasukkan beberapa contoh data.
6.      Melakukan analisa terhadap hasil pengujian. Jika aplikasi sudah benar lakukan langkah 7, jika belum benar kembali ke langkah 2.
7.       Pengambilan kesimpulan.
Gambar 3.1 Alur analisis perancangan sistem.
3.4  Cara Penelitian
Penelitian ini dilakukan dengan menggunakan file suara dalam bentuk *.wav. File suara diperoleh dengan melakukan perekaman suara melalui aplikasi verifikasi suara yang dibangun.
File suara (*.wav) yang diperoleh akan dicari cirri-cirinya dengan menggunakan metode feature extraction MFCC (Mel Frequency Cepstrum Coefficient). Pengujian sistem akan dilakukan dengan mencocokkan ciri-ciri suara yang telah didaftarkan pada sistem dengan suara yang ingin diuji. Proses pencocokan menggunakan metode DTW (Dynamic Time Warping)
            Keberhasilan dari sistem verifikasi suara ini dapat diukur berdasarkan tingkat keberhasilan (hit rate) atau tingkat kesalahan yaitu FAR (False Acceptance Rate) dan FRR (False Rejection Rate). Keputusan sistem diambil dengan menggabungkan skor dari masing-masing klasifikasi berdasarkan biometrik suara.
3.4.1        Materi Penelitian
Materi penelitian yang dilakukan pada sistem verifikasi suara menggunakan metode mfcc dan dtw ini adalah :
-                      Langkah - langkah proses feature extraction dengan metode MFCC (Mel Frequency Cepstrum Coefficient).
-                      Langkah – langkah pencocokan suara dengan metode DTW (Dynamic Time Warping)
3.4.2    Alat Penelitian

Alat penelitian yang digunakan dalam perancangan sistem verifikasi suara menggunakan metode mfcc dan dtw, yaitu :
1.    Perangkat Lunak :
Perangkat lunak yang digunakan dalam perancangan sistem ini terdiri dari :
·      Sistem Operasi Microsoft Windows XP SP3.
·      .Net Framework 2.0.
·      Editor bahasa pemrograman Microsoft Visual C# Express Editon 2008.
2.        Perangkat Keras :
Perangkat keras yang digunakan dalam penelitian ini meliputi :
·         Komputer dengan spesifikasi :
·         Prosesor Intel Core 2 Duo 1.8 GHz
·         RAM 3 GB DDR2
·         Hard Disk 120 GB
·         VGA internal 384 MB
3.5 Gambaran Umum Sistem
Gambaran umum sistem merupakan gambaran proses yang dilakukan sistem secara keseluruhan serta modul-modul apa saja yang nantinya akan digunakan dalam pembuatan program. Secara umum proses dari sistem verifikasi suara menggunakan metode mfcc dan dtw adalah proses perekaman suara (voice recorder), proses training (training mode) dan proses testing atau testing mode.
Voice Recorder merupakan bagian yang bertugas merekam suara pembicara. Suara direkam dengan menggunakan format PCM (pulse code modulation). Alat yang dibutuhkan untuk proses ini adalah microphone dan audio speaker.
Training Mode adalah bagian yang bertugas mempelajari dan memodelkan suara pembicara. Pembelajaran terhadap suara pembicara dilakukan dengan membuat model dari suara pembicara kemudian menyimpannya ke dalam database.
Testing Mode merupakan bagian yang bertugas mengenali suara pembicara. Pengenalan suara dilakukan dengan melakukan pattern matching input suara terhadap model yang ada dalam database. Pada pattern matching perbandingan yang dilakukan adalah perbandingan 1:1 dimana model suara dari A langsung dibandingkan dengan model suara A yang ada dalam database.
Gambaran umum sistem verifikasi suara menggunakan metode mfcc dan dtw dapat dilihat pada gambar dibawah ini.

Gambar 3.2 Gambaran umum sistem.
3.6 Algoritma Program
Sistem pengenalan suara yang dikembangan terdiri dari beberapa algoritma diantaranya adalah algoritma MFCC (mel frequency cepstrum coefficient) dan algoritma DTW (dynamic time warping). Algoritma MFCC terdiri dari beberapa algoritma lagi yaitu algoritma dc removal, pre-emphasize, frame blocking, windowing, fft, filterbank, dct dan cepstral liftering. Berikut ini adalah perjelasan dari masing-masing algoritma yang digunakan.
3.6.1 Algoritma MFCC
Algoritma yang digunakan dalam proses feature extraction adalah MFCC. Langkah – langkah dari algoritma MFCC adalah :
1.    Melakukan proses Dc Removal untuk mendapatkan nilai normal dari sampel signal.
2.    Melakukan proses Pre-emphasize untuk memperbaiki signal dari gangguan noise.
3.    Melakukan proses Frame Blocking bertujuan untuk membagi sampel signal menjadi beberapa frame.
4.    Melakukan proses Windowing untuk mengurangi efek diskontinuitas pada ujung-ujung frame yang dihasilkan oleh proses frame blocking.
5.    Melakukan proses FFT sehingga diperoleh sampel signal dalam frequensi domain.
6.    Melakukan proses Fileterbank untuk mengetahui ukuran energi dari setiap frequensi band.
7.    Melakukan proses DCT untuk mendapatkan mel cepstrums
8.    Melakukan proses Cepstral Liftering, bertujuan menhaluskan spectrum signal.
9.    Melakukan proses Remove Silence untuk menghilakan signal-signal silence.
flowchart di bawah ini menggambarkan proses MFCC ;

Gambar 3.3 Flowchart MFCC



3.6.2 Algoritma Remove DC Components
Remove DC Components bertujuan untuk menghitung rata-rata dari data sampel suara, dan mengurangkan nilai setiap sampel suara dengan nilai rata-rata tersebut. Tujuannya adalah mendapat normalisasi dari data suara input. Input dari proses ini adalah sample suara dalam bentuk array dan outputnya adalah array sample suara yang sudah dinormalisasi. Langkah-langkah dari algoritma ini adalah :
1.    Tentukan variabel i dengan tipe data integer, dan variabel sum dengan tipe data double.
2.    Isi variabel i dan sum dengan nilai nol
3.    Cek apakah i lebih kecil dari jumlah sampel signal? Jika ya, lakukan langkah 4. Jika tidak, lakukan langkah 6.
4.    Tambahkan nilai sampel signal ke- i dengan variabel sum lalu simpan ke dalam variabel sum.
5.    Lakukan langkah 3 sampai 4 hingga i sama atau lebih besar dari jumlah sampel signal.
6.    Isi variabel sum dengan hasil dari sum dibagi jumlah sampel signal. Proses ini akan menghasilkan nilai rata-rata dari seluruh sampel signal.
7.    Set nilai i = 0.
8.    Cek apakah nilai i lebih kecil dari jumlah sampel signal. Jika ya, lakukan langkah 9. Jika tidak, lakukan langkah 11.
9.    Isi nilai sampel signal ke- i dengan hasil dari nilai sampel signal ke i dikurangi sum.
10.              Lakukan langkah 8 sampai 9 hingga i sama atau lebih besar dari jumlah sampel signal.
11.              Output dari algoritma ini adalah sampel signal yang sudah dinormalisasi.
 

Berikut merupakan flowchart dari proses Remove Dc.
Gambar 3.4 Flowchart remove DC components

3.6.3 Algoritma Pre emphasize
Pre-emphasize dilakukan untuk memperbaiki signal dari gangguan noise, sehingga dapat meningkatkan tingkat akurasi dari proses feature extraction. Default nilai alpha yang digunakan dalam proses ini adalah 0.97 . langkah-langkah dari algoritma ini adalah :
1.    Tentukan variabel i dengan tipe data integer, dan alpha dengan tipe data double.
2.    Isi variabel i dengan nilai panjang signal dikurangi satu, dan alpha dengan nilai 0.97.
3.    Cek apakah i lebih besar dari 0. Jika ya lakukan langkah 4, jika tidak, lakukan langkah 6.
4.    Isi nilai sampel signal ke-i dengan hasil dari nilai sampel signal ke-i dikurangi nilai sampel signal ke-(i-1) dikalikan dengan alpha.
5.    Lakukan langkah 3 sampai 4 hingga nilai i sama atau lebih kecil dari nol. 
6.    Isi nilai sampel signal ke-i dengan hasil dari signal ke-i dikurangi signal ke-i  dikali nilai alpha.
7.    Sampel signal yang merupakan output dari algoritma preemphasize.
Berikut merupakan flowchart dari proses pre-emphasize filtering.
Gambar 3.5 Flowchart pre emphasize
3.6.4 Algoritma Frame Blocking
Hasil perekaman suara merupakan sinyal analog yang masih bergantung terhadap waktu atau sering disebut variant time. Oleh karena itu sinyal tersebut harus dipotong - potong dalam slot - slot waktu tertentu agar bisa dianggap invariant.
Frame blocking adalah suatu proses yang bertujuan untuk membagi sampel suara menjadi beberapa frame atau slot dengan panjang tertentu. Pada penelitian yang dilakukan sinyal suara akan dipotong sepanjang 20 ms disetiap pergeseran sepanjang 10 ms. Dibawah ini merupakan langkah-langkah dari algoritma frame blocking :
1.    Tentukan variabel M, N, i, j, nFrame dengan tipe data integer.
2.    Tentukan variabel arrFrame dengan tipe data double. Variabel ini digunakan sebagai tempat penyimpanan sampel signal hasil dari proses frame blocking.
3.    Set nilai M = 128
4.    Set nilai N =  256
5.    Set nilai nFrame = panjang sampel signal / M-1
6.    Set i dan j = 0
7.    Cek apakah i lebih kecil dari nFrame. Jika ya, lakukan langkah 8, jika tidak, lakukan langkah 12.
8.    Cek apakah j lebih kecil dari N. jika ya, lakukan langkah 9 dan 10, jika tidak, lakukan langkah 11.
9.    Isi variabel arrFrame[i,j] dengan sampel signal ke - [M*i+j].
10.              Ulangi langkah 8 dan 9 hingga j sama atau lebih besar dari N
11.              Ulangi langkah 7 sampai 10 hingga I sama atau lebih besar dari nFrame.
12.              Hasil dari algoritma frame blocking disimpan dalam variabel arrFrame.



Berikut merupakan flowchart dari proses frame blocking.
 Gambar 3.6 flowchart frame blocking

3.6.5 Algoritma Windowing
            Ada banyak fungsi window namun yang digunakan dalam penelitian ini adalah hamming window karena mempunyai hasil yang lebih baik dalam pembatasan sinyal yang akan dianalisa. Proses windowing berfungsi untuk mengurangi efek diskontinuitas pada ujung-ujung frame yang dihasilkan oleh proses frame blocking. Berikut adalah langkah-langkah dari alogoritma ini :
1.        Tentukan variabel M, N, i, j, nFrame dengan tipe data integer.
2.        Tentukan variabel arrWindow dengan tipe data double. Variabel ini digunakan sebagai tempat penyimpanan sampel signal hasil dari proses Windowing.
3.        Set nilai M = 128
4.        Set nilai N =  256
5.        Set nilai nFrame = panjang sampel signal / M-1
6.        Set i dan j = 0
7.        Cek apakah i lebih kecil dari nFrame. Jika ya, lakukan langkah 8, jika tidak, lakukan langkah 12.
8.        Cek apakah j lebih kecil dari N. jika ya, lakukan langkah 9 dan 10, jika tidak, lakukan langkah 11.
9.        Isi variabel arrWindow[i,j] dengan hasil dari arrFrame[i,j]*(0.54 - 0.46 * cos(2*pi*j/(N-1))) 
10.    Ulangi langkah 8 dan 9 hingga j sama atau lebih besar dari N
11.    Ulangi langkah 7 sampai 10 hingga I sama atau lebih besar dari nFrame.
12.    Hasil dari algoritma windowing disimpan dalam variabel arrWindow.



 Flowchart berikut ini menggambarkan proses windowing.

Gambar 3.7 flowchart Windowing
Analisa berdasarkan fourier transform sama artinya dengan analisa spektrum, karena fourier transform merubah signal digital dari time domain ke frequency domain. Langkah – langkah yang dilakukan dalam proses ini adalah :
1.        Mulai
2.        Tentukan n,nu dengan tipe data integer
3.        Tentukan variabel x, xre, xim, magnitude, tr, ti, p, arg, c, s, r dengan tipe data double.
4.        Tentukan nilai x
5.        Isi variabel n dengan panjang x
6.        Isi variabel nu dengan hasil log(n) dibagi log(2)
7.        Isi variabel n2 dengan hasil n dibagi 2
8.        Isi variabel nu1 dengan hasil nu dikurangi 1
9.        Set i sama dengan 1
10.    Cek apakah i kurang dari n?
11.    Jika ya,
11.a Isi variabel xre[i] dengan nilai x[i]
11.b Isi variabel xim[i] dengan nilai 0.0f
11.c Lakukan langkah 11.a dan 11.b sampai I sama dengan atau lebih dari n
12. Set l sama dengan 1
13. Apakah l kurang atau sama dengan nu?
14. Jika ya,
14.a  Apakah k kurang dari n?
14.b  Jika ya,
(1) Set m sama dengan 1
(2) Apakah m kurang atau sama dengan n2
(3) Jika ya,
            (a) Isi variabel p dengan nilai dari prosedure bitreverse(k>>nu1)
            (b) Isi nilai arg dengan hasil dari 2+(pi * p/n)
            (c) Isi variabel c dengan nilai cos(arg)
            (d) Isi variabel s dengan nilai sin(arg)
                                    (e) Isi nilai tr dengan hasil xre[k+n2]* c + xim[k+n2]*s
                                    (f) Isi ti dengan hasil xim[k+n2] * c – xre[k+n2] *s
                                    (g) Isi variabel xre[k+n2] dengan hasil xre[k] – tr
                                    (h) Isi variabel xim[k+n2] dengan hasil xim[k] – ti
                                    (i) Isi variabel xre[k] dengan hasil xre[k] + tr
                        (j) Isi variabel xim[k] dengan hasil xre[k] +ti
                        (k) Lakukan langkah a sampai j hingga m lebih besar dari n2
            (4) Jika tidak,
            (5) Isi variabel k denga hasil k di tambah n2
(6) Lakukan langkah 2 sampai 5 hingga k lebih besar atau sama dengan n
14.c Jika tidak,
14.d Set k sama dengan  nol
14.e Isi variabel nu1 dengan hasil nu1 dikurangi 1
14.f Isi n2 dengan hasil n2 dibagi 2
14.g Lakukan langkah 14.a sampai 14.f hingga l lebih dari nu
15. Set k sama dengan nol
16. apakah k kurang dari n?
17. jika ya,
            (1) isi variabel r dengan hasil dari prosedure bitreverse(k)
            (2) apakah r lebih besar dari k
            (3) jika ya,
                        (a) isi variabel tr dengan nilai xre[k]
                        (b) isi variabel ti dengan nilai xim[k]
                        (c) isi variabel xre[k] dengan xre[r]
                        (d) isi variabel xim[k] dengan xim[r]
                        (e) isi variabel xer[r] dengan nilai tr
                        (f) isi variabel xim[r] dengan nilai ti
(g) lakukan proses a sampai f hingga r kurang atau sama            
      dengan k
            (4) set I sama dengan nol
            (5) apakah I kurang dari n dibagi dua
            (6) jika ya,
(1) isi variabel magnitude[i] dengan hasil akar dari (xre[i])2  + (xim[i]) 2
(2) lakukan langkah 1 hingga I lebih atau sama dengan n dibagi 2
18. hasil dari fft adalah magnitude
(19) selesai.    
Berikut ini adalah flowchart fast fourier transform.


Gambar 3.8 Flowchart Fast Fourier Transform
Magnitude hasil dari proses FFT selanjutnya akan melalui tahap filterbank. Untuk dapat melakukan tahap filterbank ini, maka terlebih dahulu harus dicari nilai-nilai koefisien dari filterbank. Berikut ini adalah langkah-langkahnya :
1.        Mulai
2.        Siapkan variabel numChannels, fftlength,  samplingrate, m_melWeight, freq, bin, mel, start, center, end, sumWeight, dan melWeight.
3.        Set numChannels = banyaknya channel.
4.        Set samplingrate = frekuensi sampling.
5.        Set fftlength = panjang FFT
6.        Set freq[0] = 0
7.        Set bin[0] = 0
8.        Isi variabel freq[numChannels + 1] dengan hasil dari samplingrate dibagi 2
9.        Isi varibael mel dengan hasil dari (2595 * log10(1 + (samplingrate / 2) / 700))
10.    Isi variabel bin[numChannels+1] dengan hasil dari (round(fftlength * freq[numChannels+1] / samplingrate))
11.    Set variabel k = 0
12.    Cek apakah k lebih kecil atau sama dengan numChannels ? jika ya lakukan langkah 13 sampai 16, jika tidak, lanjutkan dengan langkah 17
13.    Isi variabel freq[k] dengan hasil dari (700 * pow(10, (k / (numChannesl + 1) *  mel / 2595)) - 1)
14.    Isi variabel bin[k] dengan hasil dari (round(fftlength * freq[k] / samplingrate))
15.    Isi variabel k dengan k +1
16.    Lakukan langkah 12
17.    Set variabel start[0] = 0
18.    Set variabel central[0] = bin[0]
19.    Set variabel end[0] = bin[1] – 1
20.    Set variabel k = 0
21.    Cek apakah k lebih kecil atau sama dengan numChannels ? jika ya, lakukan langkah 22 sampai 26. Jika tidak, lanjutkan ke langkah 27.
22.    Isi variabel start[k] dengan nilai dari bin[k-1] +1
23.    Isi variabel center[k] dengan nilai dari bin[k]
24.    Isi variabel end[k] dengan nilai dari bin[k + 1] -1
25.    Isi variabel k dengan k ditambah 1
26.    Lakukan langkah 21
27.    Isi variabel start[numChannels + 1] dengan nilai dari bin[numChannels] +1
28.    Isi variabel center[numChannels + 1] dengan nilai dari bin[numChannels + 1]
29.    Isi variabel end[numChannels + 1] dengan nilai dari bin[numChannels + 1]
30.    Set k = 1
31.    Apakah k lebih kecil atau sama dengan numChannels ditambah 1 ? jika ya, lakukan langkah 32 sampai 38. Jika tidak, lanjutkan ke langkah 39
32.    Set i = bin[k-1]
33.    Cek apakah i lebik kecil dari k ? jika ya, lakukan langkah 34 sampai 36. Jika tidak, lakukan langkah
34.    Isi variabel melWeight[i] dengan hasil dari ((i - bin[k - 1]) / (bin[k] - bin[k - 1]))
35.    Isi variabel i dengan I di tambah 1
36.    Lakukan langkah 33
37.    Tambahkan variabel i dengan 1
38.    Lakukan langkah 31
39.    Isi variabel melWeight[bin[numChanel + 1]] dingan 0
40.    Isi variabel sumWeight[0] dengan hasil dari (bin[1] - bin[0] + 1) / 2
41.    Set k = 1
42.    Cek apakah k lebih kecil atau sama dengan numChannels ? jika ya, lakukan langkah 43 sampai 45. Jika tidak, lakukan langkah 46
43.    Isi variabel sumWeight[k] dengan hasil dari (bin[k + 1] - bin[k - 1]) / 2
44.    Tambahkan variabel k dengan 1
45.    Lakukan kembali langkah 42
46.    Isi variabel sumWeight[numChannels + 1] dengan hasil dari (bin[numChannels + 1] - bin[numChannels] + 1) / 2
47.    Hasil dari proses ini adalah nilai-nilai awal dari filterbank yang disimpan dalam variabel sumWeight, start, center, end, dan melWeight.
48.    Selesai.
Berikut ini adalah flowchart yang menunjukkan proses generate filterbank coefficients.

Gambar 3.9 Flowchart Generate Filterbank Coefficients

            Setelah berhasil memperoleh koefisien filterbank, maka proses konvolusi filterbank dapat dilaksanakan. Langkah-langkah dari proses ini adalah :
1.        Mulai
2.        Tentukan variabel fftlength,  sigFFT, nFrame, sum, start, end, melWeight, numChannels dan sigFB.
3.        Isi variabel fftlength dengan panjang FFT
4.        Isi variabel koef dengan panjang filterbank yang diinginkan
5.        Isi variabel sigFFT dengan spektrum hasil dari proses fft
6.        Isi variabel nFrame dengan jumlah frame
7.        Isi variabel start, center, end dan melWeight dengan start, center, end dan melWeight hasil dari proses generate filterbank coefficients yang telah dilakukan sebelumnya.
8.        Set I = 0
9.        Cek apakah I lebih kecil dari nFrame ? jika ya, lakukan langkah 10 sampai 27. Jika tidak, lakukan langkah 28
10.    Set k = 0
11.    Cek apakah k lebih kecil atau sama dengan numChannels + 1 ? jika ya, lakukan langkah 12 sampai 25. Jika tidak, lanjutkan dengan langkah 26
12.    Isi variabel sum dengan nilai dari sigFFT[i, center[k]]
13.    Set varibel j sama dengan nilai dari start[k]
14.    Cek apakah j lebih kecil dari nilai center[k] ? jika ya, lakukan langkah 15 sampai 17. Jika tidak, lakukan langkah 18
15.    Isi variabel sum dengan sum + melWeight[j] * sigFFT[i, j]
16.    Tambahkan variabel j dengan 1
17.    Lakukan langkah 14
18.    Set j sama dengan nilai dari center[k] + 1
19.    Cek apakah j lebih kecil atau sama dengan end[k] ? jika ya, lakukan langkah 20 sampai 22. Jika tidak, lakukan langkah 23
20.    Isi variabel sum dengan (sum + (1 - melWeight[j]) * sigFFT[i, j])
21.    Tambahkan variabel j dengan 1
22.    Lakukan langkah 19
23.    Isi variabel sigFB[i, k] dengan hasil dari (sum / sumWeight[k])
24.    Tambahkan variabel k dengan 1
25.    Lakukan kembali langkah 11
26.    Tambahkan variabel I dengan 1
27.    Lakukan kembali langkah 9
28.    Hasil dari proses ini adalah mel spectrums yang disimpan dalam variabel sigFB.
29.    Selesai.





Berikut ini adalah flowchart yang menunjukkan proses konvolusi filterbank.
Gambar 3.10 Flowchart Konvolusi Filterbank
Proses DCT adalah langkah terakhir dari proses feature extraction. Melalui proses ini akan diperoleh beberapa nilai yang merupakan dimensi dari vector yang bersangkutan. Langkah-langkah dari algoritma ini adalah :
1.    Tentukan nFrame, koef, i, j dengan tipe data integer, sigFb dan sigDCT dengan tipe data double.
2.    Isi variabel nFrame dengan jumlah frame. Isi variabel koef dengan 10
3.    Isi variabel i dan j dengan nol.
4.    Isi variabel sigFb dengan sampel signal hasil dari proses filterbank
5.    Cek apakah i lebih kecil dari nFrame ?
6.    Jika ya,
6.a Cek apakah j lebih kecil dari koef?
6.b Jika ya,
a. Cek apakah k lebih kecil dari koef ?
b. Jika ya,
b.1 Isi variabel sigDCT[i, j] dengan hasil dari sigDCT[i, j] + 
      log(sigFb[i,   k]) * cos(j * (k - 0.5) * (pi / koef)).
b.2 Isi variabel k dengan hasil dari k ditambah 1
b.3 Lakukan langkah a sampai b.2 hingga nilai k sama atau lebih besar  
      dari nilai koef
     c. Jika tidak,          
            c.1 Tambahkan variabel j dengan satu.
c.2 Lakukan langkah 6.a sampai 6.b(a, b, c) hingga j sama atau lebih besar dari koef.
6.c Jika tidak,
     a. Tambahkan nilai i dengan satu
     b. Lakukan langkah 5 sampai 6.c hingga i sama atau lebih besar dari nFrame.
7.  Jika tidak,
8. Hasil dari algorithma ini adalah mel frequency cepstrum coefficients

Berikut ini adalah flowchart dari proses DCT.

Gambar 3.11 Flowchart DCT

3.6.9 Algoritma Cepstral Liftering
Hasil dari proses DCT adalah cepstrums yang sebenarnya sudah merupakan hasil akhir dari proses feature extraction. Tetapi seperti yang telah dijelaskan pada bab sebelumnya, bahwa untuk dapat meningkatkan kualitas pengenalan, maka cepstrums hasil dari proses DCT harus melewati proses cepstral liftering. Langkah-langkah dari algoritma ini adalah :
1.        Mulai
2.        Tentukan variabel nFrame, koef, i dan j dengan tipe data integer, variabel sigLif dan sigDCT dengan tipe data double.
3.        Set nilai variabel nFrame sama dengan jumlah frame
4.        Set nilai variabel koef sama dengan 10.
5.        Set nilai variabel i sama dengan nol
6.        Set nilai variabel j sama dengan nol
7.        Cek apakah i lebih kecil dari nFrame ?
8.        Jika ya,
9.        Cek apakah j lebih kecil dari koef dikurangi 1
10.    Jika ya,
11.    Isi variabel sigLif[i, j] dengan hasil dari sigDCT[i, j+1] * (1+(koef-1) / 2 * sin((j+1) * pi / (koef-1) ).
12.    Tambahkan variabel j dengan satu.
13.    Lakukan langkah 9 sampai 12 hingga j sama atau lebih besar dari koef dikurangi 1.
14.    Jika tidak,
15.    Tambahkan variabel i dengan satu.
16.    Lakukan langkah 7 sampai 15 hingga i sama atau lebih besar dari nFrame
17.    Jika tidak,
18.    Hasil dari algoritma ini adalah mel cepstrum.
19.    Selesai.
 
Berikut adalah flowchart yang menunjukkan proses cepstral liftering.

Gambar 3.12 Flowchart Cepstral Liftering.
cepstral liftering mengakhiri proses feature extraction, namum hasilnya masih mengandung frame-frame silence. Frame semacam ini tentunya sangat mengganggu proses pengenalan pembicara. Oleh karena itu frame-frame seperti ini harus dihilangkan. Langkah-langkah dari algoritma ini adalah :
1.        Mulai
2.        Tentukan variabel rasio,threshold dengan tipe data double
3.        Set nilai rasio sama dengan 1.0
4.        Tentukan nilai rata-rata (mean) dari setiap frame
5.        Tentukan nilai rata-rata (mean) dari seluruh frame
6.        Isi variabel threshold dengan hasil dari nilai rata-rata seluruh frame dikali dengan rasio.
7.        Hapus frame dengan mean lebih kecil dari threshold karena itu merupakan frame silence.
8.        Hasilnya adalah frame-frame yang sudah tidak mengandung silence.
9.        Selesai.
Berikut adalah flowchart dari proses remove silence.

Gambar 3.13 Flowchart Remove Silence.

Implementasi dari pengenalan suara ini menggunakan .Net Framework 2.0 dengan Microsoft Visual Studio 2008 untuk pembuatan aplikasi dengan bahasa pemrograman C#. Bahasa Pemrograman ini menggunakan konsep pemrograman berbasis objek. Berikut ini adalah beberapa kelas utama yang digunakan dalam sistem pengenalan suara :
Kelas MFCC (mel frequency cepstrum coefficients) berfungsi untuk mencari feature ciri dari suara yang diinputkan. Kelas ini terdiri dari beberapa langkah yang berurutan. Langkah-langkah tersebut terdiri dari Remove DC, Preemphasize, Frame blocking, Windowing, Fast Fourier Transform, Filterbank, Discrete Cosine Transform, Cepstral Liftering, dan Remove Silence. Berikut adalah kode program dari masing-masing langkah.
Remove DC merupakan proses yang bertujuan untuk melakukan normalisasi terhadap data sampel suara yang diinputkan. Berikut adalah kode program dari proses ini.

Fungsi      : Normalisasi data sampel suara
Input  : Data sampel suara
Output      : Data sampel suara yang sudah normal
static private double[] RemoveDC()
        {
            try
            {
                double sum = 0.0;
                for (int i = 0; i < length; i++)
                    sum += sample[i];
                sum = sum / length;
                for (int i = 0; i < length; i++)
                    sample[i] = sample[i] - sum;

                return sample;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
Kode Program 3.1 Proses Remove DC
Fungsi ini berguna untuk mengurangi noise pada signal dan menyeimbangkan spektrum pada voiced sound. Berikut adalah kode program dari fungsi pre-emphasize filtering :

Fungsi      : Mengurangin noise dan menyeimbangkan spektrum
Input  : Data sampel suara
Output    : Data sampel suara dengan spektrum yang lebih seimbang dan    
         mengandung sedikit noise
static private double[] Preemphasize()
        {
            try
            {
                double[] sigDataTemp = new double[length];

                for (int i = (int)length - 1; i > 0; i--)
                    sigDataTemp[i] = sample[i] - 0.97 * sample[i –
                    1];
                sigDataTemp[0] = sample[0] - 0.97 * sample[0];

                return sigDataTemp;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
Kode Program 3.2 Proses fre-emphasize filtering
Frame blocking berfungsi untuk mebagi sampel suara menjadi beberapa frame. Windowing berfungsi untuk mengurangi efek discontinuitas pada ujung-ujung data sampel hasil dari proses frame blocking. Berikut adalah kode program dari proses ini :
Fungsi      : frame blocking : membagi signal menjadi beberapa frame. 
         Windowing : mengurangi efek discontinuitas akibat proses
         frame blocking.
Input  : Data sampel suara
Output    : Data sampel suara yang sudah tersimpan dalam beberapa
         frame
                //frame blocking dan windowing           
                int N = samplingrate * panjangFrame / 1000;//  
                =>banyaknya sample dalam 1 frame kuranglebih 20- 
                30ms dan merupakan kelipatan 2
                int M = samplingrate * pergeseranFrame / 1000;//
                int nFrame = 0;
                nFrame = (int)length / M - 1;
                double[,] arrFrame = new double[nFrame, N];
                double[,] arrWindow = new double[nFrame, N];
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < N; j++)
                    {
                        arrFrame[i, j] = sample[M * i + j];   
                        //frame blocking
                        arrWindow[i, j] = arrFrame[i, j] * (0.54 –
                        0.46 * Math.Cos(2 * Math.PI * j / (N -  
                        1))); //windowing                   
                    }
Kode Program 3.3 Proses frame blocking dan windowing
Kelas fast fourier transform berfungsi untuk mengubah data sampel suara dari time domain ke frequency domain. Berikut adalah kode program dari kelas FFT :
Kelas  : FourierTransform.cs
Fungsi      : Mengubah signal suara dari time domain ke frequency
         domain.
Input  : Data sampel suara dengan panjang data merupakan kelipatan  
         2
Output    : Signal suara dalam domain frekuensi.
public class FourierTransform
    {
        static private int n, nu;

        static private int BitReverse(int j)
        {
            int j2;
            int j1 = j;
            int k = 0;
            for (int i = 1; i <= nu; i++)
            {
                j2 = j1 / 2;
                k = 2 * k + j1 - 2 * j2;
                j1 = j2;
            }
            return k;
        }

        static public double[] FFT(ref double[] x)
        {
            // Assume n is a power of 2
            n = x.Length;
            nu = (int)(Math.Log(n) / Math.Log(2));
            int n2 = n / 2;
            int nu1 = nu - 1;
            double[] xre = new double[n];
            double[] xim = new double[n];
            double[] magnitude = new double[n2];
            double[] decibel = new double[n2];
            double tr, ti, p, arg, c, s;
            for (int i = 0; i < n; i++)
            {
                xre[i] = x[i];
                xim[i] = 0.0f;
            }
            int k = 0;
            for (int l = 1; l <= nu; l++)
            {
                while (k < n)
                {
                    for (int i = 1; i <= n2; i++)
                    {
                        p = BitReverse(k >> nu1);
                        arg = 2 * (double)Math.PI * p / n;
                        c = (double)Math.Cos(arg);
                        s = (double)Math.Sin(arg);
                        tr = xre[k + n2] * c + xim[k + n2] * s;
                        ti = xim[k + n2] * c - xre[k + n2] * s;
                        xre[k + n2] = xre[k] - tr;
                        xim[k + n2] = xim[k] - ti;
                        xre[k] += tr;
                        xim[k] += ti;
                        k++;
                    }
                    k += n2;
                }
                k = 0;
                nu1--;
                n2 = n2 / 2;
            }
            k = 0;
            int r;
            while (k < n)
            {
                r = BitReverse(k);
                if (r > k)
                {
                    tr = xre[k];
                    ti = xim[k];
                    xre[k] = xre[r];
                    xim[k] = xim[r];
                    xre[r] = tr;
                    xim[r] = ti;
                }
                k++;
            }
            for (int i = 0; i < n / 2; i++)
                magnitude[i] = (float)(Math.Sqrt((xre[i] * xre[i])
                + (xim[i] * xim[i])));
                //decibel[i] = 10.0 *
                Math.Log10((float)(Math.Sqrt((xre[i] * xre[i]) +
                (xim[i] * xim[i]))));
            return magnitude;
            //return decibel;
        }
    }
Kode Program 3.4 Proses fast fourier transform

Filterbank bertujuan untuk mengetahui ukuran energi pada frequency band tertentu dalam signal suara. Berikut adalah kode program dari proses inisialisasi koefisien-koefisien filterbank :
Fungsi      : Mencari koefisien-koefisien filterbank.
Input  : Data sampel suara dalam domain frequency
Output    : koefisien-koefisien filterbank.
static private melFB[] initFB(int fftLength)
        {
            try
            {
                //-- constant for calculations --//
                m_melWeight = new double[fftLength + 1];//fft/2+1
                double[] freq = new double[numChanel + 2];
                int[] bin = new int[numChanel + 2];
                double mel;
                m_MelFb = new melFB[numChanel + 2];
                //            m_MelFB1 = new double[numChanel +
                2];
                freq[0] = 0;
                bin[0] = (int)(Math.Round(fftLength * freq[0] /
                samplingrate));
                freq[numChanel + 1] = (double)(samplingrate /
                2.0);
                mel = (double)(2595.0 * Math.Log10(1 +
                (samplingrate / 2.0) / 700));
                bin[numChanel + 1] = (int)(Math.Round(fftLength *
                freq[numChanel + 1] / samplingrate));
               
                /* Calculating mel-scaled frequency and the
                corresponding FFT-bin */
                /* number for the lower edge of the band                         
                */
                for (int k = 1; k <= numChanel; k++)
                {
                    freq[k] = (double)(700.0 * (Math.Pow(10.0,
                    ((double)k / (numChanel + 1) * mel / 2595.0))
                    - 1.0));
                    bin[k] = (int)(Math.Round(fftLength * freq[k]
                    / samplingrate));
                }
               
                m_MelFb[0].m_lowX = 0;
                m_MelFb[0].m_centerX = bin[0];
                m_MelFb[0].m_highX = bin[1] - 1;
                for (int k = 1; k <= numChanel; k++)
                {                   
                    m_MelFb[k].m_lowX = bin[k - 1] + 1;
                    m_MelFb[k].m_centerX = bin[k];
                    m_MelFb[k].m_highX = bin[k + 1] - 1;
                }               
                m_MelFb[numChanel + 1].m_lowX = bin[numChanel] +
                1;
                m_MelFb[numChanel + 1].m_centerX = bin[numChanel +
                1];
                m_MelFb[numChanel + 1].m_highX = bin[numChanel +
                1];
                for (int k = 1; k <= numChanel + 1; k++)
                {
                    for (int i = bin[k - 1]; i < bin[k]; i++)
                    {
                        m_melWeight[i] = (i - bin[k - 1]) /
                        (double)(bin[k] - bin[k - 1]);
                    }
                }
                m_melWeight[bin[numChanel + 1]] = 0;
                               
                m_MelFb[0].m_sumWeight = (bin[1] - bin[0] + 1) /
                (double)2; //m_sumWeight
                for (int k = 1; k <= numChanel; k++)
                {
                    m_MelFb[k].m_sumWeight = (bin[k + 1] - bin[k –
                    1]) / (double)2;
                }
                m_MelFb[numChanel + 1].m_sumWeight =
                (bin[numChanel + 1] - bin[numChanel] + 1) /
                (double)2;
                return m_MelFb;
            }
            catch (Exception err)  
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
Kode Program 3.5 Proses initialize filterbank

Kode program berikut adalah proses konvolusi filterbank yaitu dengan melakukan multiplikasi antara spektrum signal hasil FFT dengan koefisien filterbank.
Fungsi      : Mengetahui ukuran energi pada frequency band tertentu.
Input  : Data sampel suara dalam domain frequency dan koefisien 
         filterbank
Output    : Ukuran energi signal suara.
                //filter bank
                int fftLength = outFFT;
                int koef = 10;
                double[,] H2mel = new double[nFrame, numChanel +
                2];
                melFB[] m_MelFB3 = new melFB[numChanel + 2];
                m_MelFB3 = initFB(fftLength);
                for (int i = 0; i < nFrame; i++)
                {
                    for (int k = 0; k <= numChanel + 1; k++)
                    {
                        double sum = arrFFT[i,
                        (int)m_MelFB3[k].m_centerX]; /* The center
                        weight is always 1 */
                        for (int j = (int)m_MelFB3[k].m_lowX; j <
                        m_MelFB3[k].m_centerX; j++)
                        {
                            sum += m_melWeight[j] * arrFFT[i, j];
                        }
                        for (int j = (int)m_MelFB3[k].m_centerX +
                        1; j <= m_MelFB3[k].m_highX; j++)
                        {
                            sum += (1 - m_melWeight[j]) *
                            arrFFT[i, j];
                        }
                        H2mel[i, k] = sum /
                        m_MelFB3[k].m_sumWeight;
                    }
                }
Kode Program 3.6 Proses konvolusi filterbank
Discrete cosine transform berfungsi untuk mendekorelasi mel spectrum sehingga didapatkan representasi yang baik dari spektral lokal. DCT merupakan langkah terakhir dari proses utama MFCC. Berikut ini adalah kode program dari proses DCT :
Fungsi      : Mencari mel cepstrum.
Input  : mel spectrum
Output    : mel cepstrum.
               //DCT            
                double[,] arrDCT = new double[nFrame, koef];
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < koef; j++)
                    {
                        for (int k = 0; k < koef; k++)
                        {
                            arrDCT[i, j] += Math.Log10(H2mel[i,
                            k]) * Math.Cos(j * (k - 0.5) *
                            (Math.PI / koef));
                        }
                    }
Kode Program 3.7 Proses DCT
Cepstral liftering berfungsi untuk menghaluskan spektrum hasil dari proses utama MFCC. Berikut adalah kode program dari proses ini :


Fungsi      : menghaluskan spektrum.
Input  : mel cepstrum
Output    : mel cepstrum yang lebih halus.

               //cepstral liftering
                double[,] arrLif = new double[nFrame, koef - 1];
                //double[] hasil = new double[nFrame * (koef –
                1)];
                //int counter=0;
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < koef - 1; j++)
                    {
                        arrLif[i, j] = arrDCT[i, j + 1] * (1 +
                        (koef - 1) / 2 * Math.Sin((j + 1) *
                        Math.PI / (koef - 1)));         
                    }
Kode Program 3.8 Proses cepstral liftering
3.7.1.8 Remove Silence
Remove silence berfungsi untuk menghilangkan frame-frame yang mengandung silence sehingga diharapkan dapat meningkatkan akurasi dari aplikasi pengenalan suara yang dibuat. Berikut adalah kode program dari proses remove silence :
Fungsi      : Menghilangkan frame yang mengandung silence.
Input  : mel frequency cepstral coefficents
Output    : mel cepstrum tanpa frame silence.

              
 //silence removal           
                double[] mean = new double[nFrame];
                double mAllFr = 0;
                double ratio = 1.0;
                double threshold;
                double[,] slnFrame = new double[nFrame, koef - 1];
                for (int i = 0; i < nFrame; i++)
                {
                    for (int j = 0; j < koef - 1; j++)
                    {
                        mean[i] += arrLif[i, j] / (koef - 1);
                    }
                    mAllFr += mean[i] / nFrame;
                }
                threshold = mAllFr * ratio;
                int m = 0;//banyak frame dikurangi frame silence
                for (int i = 0; i < nFrame; i++)
                {
                    if (mean[i] < threshold)
                    {
                        for (int j = 0; j < koef - 1; j++)
                        {
                            slnFrame[m, j] = arrLif[i, j];
                        }
                        m++;
                    }
                }
                double[,] newFrame = new double[m, koef - 1];
                double[] outMFCC = new double[m * (koef - 1)];
                int w = 0;
                for (int i = 0; i < m; i++)
                {
                    for (int j = 0; j < koef - 1; j++)
                    {
                        newFrame[i, j] = slnFrame[i, j];
                        outMFCC[w] = newFrame[i, j];
                        w++;
                    }
                }
Kode Program 3.9 Proses remove silence

Berikut ini adalah kode program dari kelas MFCC secara keseluruhan :

Kelas : MFCC.cs
Fungsi      : Mencari feature ciri dari suara.
Input  : Data sampel signal.
Output    : mel frequency cepstrum coefficients.
namespace VeriVoice
{
    public class MFCC
    {
        static public long length;
        static public double[] sample;
        static private int numChanel = 23;//panjang koefisien   
        hasil filterbank yang diinginkan
        static private int samplingrate =  
        Properties.Settings.Default.SettingSamplesPerSecond;
        static private melFB[] m_MelFb;
        static private double[] m_melWeight;
        static private int panjangFrame =  
        Properties.Settings.Default.SettingFrameLength;  
        //milimeter/second
        static private int pergeseranFrame =
        Properties.Settings.Default.SettingFrictionFrame;
        //milimeter/second
        static private int inFFT = 0;//panjang input FFT yang   
        diinginkan, harus merupakan kelipatan 2
       
        static public double[] mfcc(double[] data, long nData)
        {
            sample = data;
            length = nData;
            try
            {
                sample = RemoveDC();//remove DC
                sample = Preemphasize();//preemphasize
                //frame blocking dan windowing           
                int N = samplingrate * panjangFrame / 1000;//  
                =>banyaknya sample dalam 1 frame kuranglebih 20- 
                30ms dan merupakan kelipatan 2
                int M = samplingrate * pergeseranFrame / 1000;//
                int nFrame = 0;
                nFrame = (int)length / M - 1;
                double[,] arrFrame = new double[nFrame, N];
                double[,] arrWindow = new double[nFrame, N];
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < N; j++)
                    {
                        arrFrame[i, j] = sample[M * i + j];   
                        //frame blocking
                        arrWindow[i, j] = arrFrame[i, j] * (0.54 –
                        0.46 * Math.Cos(2 * Math.PI * j / (N -  
                        1))); //windowing                   
                    }

                //fft
                if (N <= 256) { inFFT = 256; } else { inFFT = 512;
                } //set input length for FFT

                int outFFT = inFFT / 2;
                double[,] arrFFT = new double[nFrame, outFFT];
                double[] arrTempFFT1 = new double[inFFT];
                double[] arrTempFFT2 = new double[outFFT];
                for (int i = 0; i < nFrame; i++)
                {
                    for (int j = 0; j < N; j++)
                        arrTempFFT1[j] = arrWindow[i, j];

                    arrTempFFT2 = FourierTransform.FFT(ref
                    arrTempFFT1);

                    for (int j = 0; j < outFFT; j++)
                    {
                        arrFFT[i, j] = arrTempFFT2[j];
                    }
                }

                //filter bank
                int fftLength = outFFT;
                int koef = 10;
                double[,] H2mel = new double[nFrame, numChanel +
                2];
                melFB[] m_MelFB3 = new melFB[numChanel + 2];
                m_MelFB3 = initFB(fftLength);
                for (int i = 0; i < nFrame; i++)
                {
                    for (int k = 0; k <= numChanel + 1; k++)
                    {
                        double sum = arrFFT[i,
                        (int)m_MelFB3[k].m_centerX]; /* The center
                        weight is always 1 */
                        for (int j = (int)m_MelFB3[k].m_lowX; j <
                        m_MelFB3[k].m_centerX; j++)
                        {
                            sum += m_melWeight[j] * arrFFT[i, j];
                        }
                        for (int j = (int)m_MelFB3[k].m_centerX +
                        1; j <= m_MelFB3[k].m_highX; j++)
                        {
                            sum += (1 - m_melWeight[j]) *
                            arrFFT[i, j];
                        }
                        H2mel[i, k] = sum /
                        m_MelFB3[k].m_sumWeight;
                    }
                }
                //DCT            
                double[,] arrDCT = new double[nFrame, koef];
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < koef; j++)
                    {
                        for (int k = 0; k < koef; k++)
                        {
                            arrDCT[i, j] += Math.Log10(H2mel[i,
                            k]) * Math.Cos(j * (k - 0.5) *
                            (Math.PI / koef));
                        }
                    }

                //cepstral liftering
                double[,] arrLif = new double[nFrame, koef - 1];
                //double[] hasil = new double[nFrame * (koef –
                1)];
                //int counter=0;
                for (int i = 0; i < nFrame; i++)
                    for (int j = 0; j < koef - 1; j++)
                    {
                        arrLif[i, j] = arrDCT[i, j + 1] * (1 +
                        (koef - 1) / 2 * Math.Sin((j + 1) *
                        Math.PI / (koef - 1)));         
                    }
                               
                //silence removal           
                double[] mean = new double[nFrame];
                double mAllFr = 0;
                double ratio = 1.0;
                double threshold;
                double[,] slnFrame = new double[nFrame, koef - 1];
                for (int i = 0; i < nFrame; i++)
                {
                    for (int j = 0; j < koef - 1; j++)
                    {
                        mean[i] += arrLif[i, j] / (koef - 1);
                    }
                    mAllFr += mean[i] / nFrame;
                }
                threshold = mAllFr * ratio;
                int m = 0;//banyak frame dikurangi frame silence
                for (int i = 0; i < nFrame; i++)
                {
                    if (mean[i] < threshold)
                    {
                        for (int j = 0; j < koef - 1; j++)
                        {
                            slnFrame[m, j] = arrLif[i, j];
                        }
                        m++;
                    }
                }
                double[,] newFrame = new double[m, koef - 1];
                double[] outMFCC = new double[m * (koef - 1)];
                int w = 0;
                for (int i = 0; i < m; i++)
                {
                    for (int j = 0; j < koef - 1; j++)
                    {
                        newFrame[i, j] = slnFrame[i, j];
                        outMFCC[w] = newFrame[i, j];
                        w++;
                    }
                }
                return outMFCC; // mel frequency cepstral
                coefficient               
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
        static private double[] RemoveDC()
        {
            try
            {
                double sum = 0.0;
                for (int i = 0; i < length; i++)
                    sum += sample[i];
                sum = sum / length;
                for (int i = 0; i < length; i++)
                    sample[i] = sample[i] - sum;

                return sample;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
        static private double[] Preemphasize()
        {
            try
            {
                double[] sigDataTemp = new double[length];

                for (int i = (int)length - 1; i > 0; i--)
                    sigDataTemp[i] = sample[i] - 0.97 * sample[i –
                    1];
                sigDataTemp[0] = sample[0] - 0.97 * sample[0];

                return sigDataTemp;
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }

        /*--------------------------------------------------------          
        Initialize data structure for FFT windows (mel filter     
        bank).
        Computes start (bin[k-1]), center (bin[k]) and end  
        (bin[k+1]) points
        of each mel filter to FFT index.
        Input:
           m_sampleRate     Sampling frequency
           fftLength    FFT length
           numChannel  Number of channels
        Output:
          Initialized weights and mel filters
        *---------------------------------------------------------
        ------------------*/
        static private melFB[] initFB(int fftLength)
        {
            try
            {
                //-- constant for calculations --//
                m_melWeight = new double[fftLength + 1];//fft/2+1
                double[] freq = new double[numChanel + 2];
                int[] bin = new int[numChanel + 2];
                double mel;
                m_MelFb = new melFB[numChanel + 2];
                //            m_MelFB1 = new double[numChanel +
                2];
                freq[0] = 0;
                bin[0] = (int)(Math.Round(fftLength * freq[0] /
                samplingrate));
                freq[numChanel + 1] = (double)(samplingrate /
                2.0);
                mel = (double)(2595.0 * Math.Log10(1 +
                (samplingrate / 2.0) / 700));
                bin[numChanel + 1] = (int)(Math.Round(fftLength *
                freq[numChanel + 1] / samplingrate));
               
                /* Calculating mel-scaled frequency and the
                corresponding FFT-bin */
                /* number for the lower edge of the band                         
                */
                for (int k = 1; k <= numChanel; k++)
                {
                    freq[k] = (double)(700.0 * (Math.Pow(10.0,
                    ((double)k / (numChanel + 1) * mel / 2595.0))
                    - 1.0));
                    bin[k] = (int)(Math.Round(fftLength * freq[k]
                    / samplingrate));
                }
               
                m_MelFb[0].m_lowX = 0;
                m_MelFb[0].m_centerX = bin[0];
                m_MelFb[0].m_highX = bin[1] - 1;
                for (int k = 1; k <= numChanel; k++)
                {                   
                    m_MelFb[k].m_lowX = bin[k - 1] + 1;
                    m_MelFb[k].m_centerX = bin[k];
                    m_MelFb[k].m_highX = bin[k + 1] - 1;
                }               
                m_MelFb[numChanel + 1].m_lowX = bin[numChanel] +
                1;
                m_MelFb[numChanel + 1].m_centerX = bin[numChanel +
                1];
                m_MelFb[numChanel + 1].m_highX = bin[numChanel +
                1];
                for (int k = 1; k <= numChanel + 1; k++)
                {
                    for (int i = bin[k - 1]; i < bin[k]; i++)
                    {
                        m_melWeight[i] = (i - bin[k - 1]) /
                        (double)(bin[k] - bin[k - 1]);
                    }
                }
                m_melWeight[bin[numChanel + 1]] = 0;
                                
                m_MelFb[0].m_sumWeight = (bin[1] - bin[0] + 1) /
                (double)2; //m_sumWeight
                for (int k = 1; k <= numChanel; k++)
                {
                    m_MelFb[k].m_sumWeight = (bin[k + 1] - bin[k –
                    1]) / (double)2;
                }
                m_MelFb[numChanel + 1].m_sumWeight =
                (bin[numChanel + 1] - bin[numChanel] + 1) /
                (double)2;
                return m_MelFb;
            }
            catch (Exception err)  
            {
                MessageBox.Show(err.Message);
                return null;
            }
        }
    }
 Kode Program 3.10 Proses MFCC
Kelas ini berfungsi untuk membandingkan antara feature sampel acuan dengan feature sampel uji. Berikut adalah kode program dari kelas DTW :
Kelas : DTW.cs
Fungsi      : Membandingkan feature acuan dengan feature uji.
Input  : Data feature sampel.
Output    : Skor hasil perbandingan.
class DynamicTimeWarping
    {
        static public double DTW(double[] acuan, double[] sample)
        {
            int i, j = 0;
            double[,] dtw = new double[acuan.Length,
            sample.Length];
            //string a = "";
            for (i = 0; i < acuan.Length; i++)
            {
                for (j = 0; j < sample.Length; j++)
                {
                    if (i + j == 0)
                    {
                        dtw[0, 0] = (double)Math.Pow((acuan[0] –
                        sample[0]), 2);
                    }
                    else if (i == 0)
                    {
                        dtw[i, j] = (double)Math.Pow((acuan[i] - 
                        sample[j]), 2) + dtw[i, j - 1];
                    }
                    else if (j == 0)
                    {
                        dtw[i, j] = (double)Math.Pow((acuan[i] –
                        sample[j]), 2) + dtw[i - 1, j];
                    }
                    else
                    {
                        dtw[i, j] = (double)(Math.Pow((acuan[i] –
                        sample[j]), 2) + (Math.Min(dtw[i - 1, j –
                        1], Math.Min(dtw[i - 1, j], dtw[i, j –
                        1]))));
                    }
                }
            }
           
            double resDtw = dtw[i-1,j-1];
            return resDtw;
        }
    }
Kode Program 3.11 Proses DTW

Antarmuka aplikasi dari sistem pengenalan suara ini terdiri dari beberapa form yang akan dijelaskan pada sub bab berikut ini.
Form utama merupakan tampilan awal yang terdiri dari menustrip pada bagian atas form, navBarControl terletak pada bagian sebelah kiri, serta statusStrip pada bagian bawah form. Menu yang terdapat pada bagian kiri dan atas berfungsi untuk memanggil form lain yang diperlukan dalam aplikasi pengenalan suara yang dirancang. Form yang akan dipanggil dari form utama antara lain : form Step by step Feature Extraction, form Enrollment from file, form Enrollment from mic,  form Matching from file, form Matching from mic, form Database Control, form Simulation, dan form Data User. Gambar dibawah ini merupakan rancangan dari form utama.   

Gambar 3.14 Form utama.
Form ini akan menampilkan tahapan-tahapan dari feature extraction menggunakan metode MFCC. Dimulai dari menekan tombol Browse untuk membuka file .wav yang ingin dicari featurenya. Kemudian dilanjutkan dengan memilih menu MFCC untuk melakukan ekstraksi feature secara bertahap. Gambar berikut ini adalah form Step by step feature extraction.

Gambar 3.15 Form Step by step feature extraction.
Form ini berfungsi untuk melakukan pendaftaran user baru secara offline. Tekan tombol Open File untuk membuka file .wav yang akan didaftarkan ke dalam sistem. Kemudian lanjutkan dengan menekan tombol Get Feature. Tekan tombol Cancel untuk keluar dari form ini. Berikut adalah gambar dari form Offline Enrollment.

Gambar 3.16 Form Offline Enrollment.
Form ini akan muncul ketika ditekan sub menu Add a sound from mic dari menu Feature Extraction pada form utama. Pada form ini user diminta untuk memasukkan username sebagai tanda pengenal dari suara yang diinputkan pada proses selanjutnya. Gambar dibawah ini merupakan form New Speaker.

Gambar 3.17 Form New Speaker.
Form Enrollment merupakan tampilan yang muncul setelah ditekan tombol Next pada form New SpeakerForm ini berfungsi untuk melakukan pendaftaran user baru dengan menginputkan suara langsung dari mic. Tekan tombol Start untuk mengaktifkan sistem perekaman otomatis dari aplikasi ini. Setelah sistem perekaman aktif maka aplikasi ini akan merekam suara yang diucapkan secara otomatis. Aplikasi ini juga sekaligus mengolah dan mencari fitur ciri dari suara tadi kemudian menyimpannya dalam database sebagai sampel acuan. Gambar berikut merupakan rancangan dari form Enrollment.  

Gambar 3.18 Form Enrollment
Ketika tombol start pada form Enrollment ditekan maka akan muncul kotak informasi seperti pada gambar di bawah. Pada kotak pesan tersebut user diminta agar dapat mengucapkan kata yang terdapat dalam textbox Word dengan baik dan benar.

Gambar 3.19 Form MessageBox Information
Kotak pesan dibawah ini akan muncul setelah fitur cirri dari user berhasil disimpan ke dalam database.

Gambar 3.20 Form MessageBox
Form Matching merpukan form yang bertugas untuk melakukan pencocokan secara offline. Pilih file yang ingin dicocokkan dengan menekan tombol Open File kemudian lanjutkan dengan menekan tombol Verify. Sistem akan mencocokkan fitur ciri dari file .wav yang diinputkan dengan fitur ciri yang tersimpan dalam database sesuai dengan username  dan kata yang diucapkan. Gambar dibawah ini merupakan rancangan dari form Offline Matching.

Gambar 3.21 Form Offline Matching
Form ini akan muncul saat user menekan sub menu Add a sound from mic pada menu Matching pada form utama. User  diminta untuk memasukkan usernamenya agar bisa melanjutkan ke proses selanjutnya.

Gambar 3.22 Form New User
Form Matching berfungsi sebagai tempat untuk melakukan proses pencocokan antara fitur ciri dari sampel suara yang telah didaftarkan sebelumnya dengan fitur suara yang diucapkan user setelah menekan tombol start pada form Matching di bawah ini.

Gambar 3.23 Form Matching
Form Database Control berfungsi mengatur database yang akan digunakan oleh sistem. Masukkan host address, username dan password sesuai dengan yang digunakan pada database. Disini user bisa membuat database baru sesuai kebutuhan dengan cara memberi centang pada checkbox New Database dilanjutkan dengan mengetik nama database pada textbox yang terletak di sebelah kanannya. Berikut merupakan rancangan gambar dari form Database Control. 

 
Gambar 3.24 Form Database Control
Form Simulation adalah form yang dirancang khusus untuk melakukan simulasi guna mengetahui unjuk kerja dari aplikasi yang dirancang. Pada form ini terdapat dua buah kurva,yaitu :
a.         Kurva karakteristik kinerja sistem
Sumbu x dari kurva ini menyatakan nilai ambang (t) dan sumbu y menyatakan FMR (false match rate) dan FNMR (false non match rate) sehingga dari kurva ini akan diketahui tingkat kesuksesan dari aplikasi yang dirancang.
b.        Kurva distribusi pengguna genuine dan impostor.
Sumbu x dari kurva ini merupakan skor hasil pencocokan sedangkan sumbu y adalah persentase(%) dari setiap skor. Berikut adalah rancangan gambar dari form Simulation.

Gambar 3.25 Form Simulation
Form Data User dirancang agar user dapat melihat data yang telah diinputkan seperti username, word atau kata yang diucapkan saat proses Enrollment, feature serta direktori tempat file .wav disimpan. Gambar dibawah ini merupakan rancangan form Data User.

Gambar 3.26 Form Data User
Pada form ini user dapat melakukan pengaturan terhadap panjang frame dan panjang pergeseran frame pada proses fitur ekstraksi dilakukan. Nilai default untuk panjang frame adalah 20 ms dan panjang pergeseran frame adalah 10 ms.

Gambar 3.27 Form Settings



*file lengkapnya dapat di dowload DISINI 


Comments

  1. This comment has been removed by the author.

    ReplyDelete
  2. Kak, boleh minta program nya buat belajar?
    mashuri.hasan@gmail.com

    ReplyDelete
  3. terima kasih bang file.nya ..
    TA sya juga berhubungan dengan ini ...
    boleh minta file programnya gak bang ..
    lagi stuck nih ..
    Syahembolantang@ymail.com

    ReplyDelete
  4. Siang kak,
    Penjelasannya sangat membantu,
    Apakah untuk gambar flowchartnya boleh minta diupload/diupdate juga?
    Karena beberapa bagian sudah tidak muncul..
    Terima kasih banyak :)

    ReplyDelete
  5. hallo kak
    saya junior di elektro
    kebetulan saya membuat skripsi yg mirip dengan kakak
    bisa minta refrensinya?
    thx
    email: budi_prabhawa@icloud.com

    ReplyDelete

Post a Comment

silahkan berkomentar, kritik dan saran yang membangun adalah harapkan kita semua !

Popular posts from this blog

Review Pemakaian Lenovo K900 Mati Total (Matot)

VERIFIKASI SUARA MENGGUNAKAN METODE MFCC DAN DTW MENGGUNAKAN METODE MFCC DAN DTW (BAB II TINJAUAN PUSTAKA)