Numpy Tingkat Lanjut

Ada beberapa perintah untuk menaikkan skill pemrograman Python Numpy (dan Scipy) ke level lanjut. Jika Anda (termasuk saya) paham dan bisa menginterpretasikan output perintah tersebut, maka kita sudah siap naik ke level Numpy selanjutnya.

1. Blok Memory (np.nbytes)

Sering kali kita hanya fokus pada bentuk (shape) array, namun melupakan "berat"nya. Perintah `np.nbytes` menginformasikan berapa banyak memori RAM yang sebenarnya kita pakai. Seseorang yang paham bahwa mengubah tipe data (dtype) dari float64 ke float32 bisa memangkas konsumsi memori hingga 50%, yang berarti mempercepat proses komputasi secara drastis. Di sini, kita belajar bahwa array bukan sekadar wadah angka, tetapi blok memori yang harus dikelola secara efisien. Contoh:

import numpy as np

a = np.zeros((1000, 1000), dtype=np.float64)
print(a.nbytes)
# Karena float64 = 8 byte, maka total memori:
# 1000 x 1000 x 8 byte = 8.000.000 byte (~8 MB)

Konsep penting:

• Ukuran memori = jumlah elemen × ukuran tipe data.
• Mengganti float64 ke float32 langsung mengurangi memori setengahnya.
• Pada skala besar (misalnya deep learning atau audio processing), ini sangat krusial.

Jika kita tidak sadar ukuran memori, kita akan mudah "membunuh" RAM sendiri.

2. Stride

Jika nbytes adalah beratnya, maka stride adalah cara kita melangkah di atas memori tersebut. Stride menentukan berapa byte yang harus "diloncati" komputer untuk menuju ke elemen berikutnya di setiap dimensi. Stride adalah jarak (dalam byte) yang harus dilompati untuk berpindah ke elemen berikutnya pada setiap dimensi. Konsep inilah yang menjawab misteri mengapa operasi transpose pada array besar bisa sangat cepat. Karena Numpy tidak benar-benar memindahkan data di memori; ia hanya mengubah pola langkah (stride) tersebut. Memahami stride berarti memahami bagaimana komputer "melihat" data array secara linear di dalam RAM. Contoh:

a = np.arange(12).reshape(3, 4)
print(a.strides)
# Jika dtype=int64 (8 byte), kemungkinan output:
# (32, 8)

Artinya:

• Untuk pindah ke baris berikutnya → lompat 32 byte (4 kolom × 8 byte).
• Untuk pindah ke kolom berikutnya → lompat 8 byte.

Ini penting karena:

• Operasi transpose (a.T) sering tidak membuat copy data, hanya mengubah stride.
• Pemahaman stride membantu kita tahu kapan NumPy membuat copy atau hanya view.
• Dalam optimasi performa, akses memori yang kontigu jauh lebih cepat.

Stride adalah jembatan antara konsep matematis array dan realitas fisik memori.

3. Broadcasting

Broadcasting adalah seni "mengada-ada" secara efisien. Broadcasting memungkinkan operasi antara array dengan ukuran yang berbeda tanpa perlu menyalin data secara fisik untuk menyamakan ukurannya. Misalnya, menjumlahkan array (3,3) dengan vektor (3,) secara otomatis. Seorang programmer biasa mungkin akan melakukan looping atau padding manual, tetapi level "Dewa" membiarkan Numpy melakukan broadcasting internal yang jauh lebih cepat karena terjadi di level C. Kita hemat memori, kita hemat waktu. Contoh:

a = np.array([[1], [2], [3]])
b = np.array([10, 20, 30])

c = a + b

Secara mental:

• `a` bentuk (3,1)
• `b` bentuk (3,)
• NumPy "membentangkan" dimensi agar cocok → hasil (3,3)

Tanpa broadcasting, kita harus membuat array besar secara manual. Dengan broadcasting:

• Kode lebih ringkas
• Lebih hemat memori
• Lebih cepat

Kunci memahami broadcasting:

• Dimensi dibandingkan dari kanan ke kiri
• Ukuran cocok jika sama atau salah satunya 1

Kalau ini sudah bisa kita prediksi tanpa menjalankan kode, berarti otak kita sudah mulai "NumPy-native".

4. Fancy Indexing

Fancy indexing adalah indexing menggunakan array atau list indeks. Berbeda dengan slicing biasa yang menghasilkan view (tampilan tanpa menyalin data), Fancy Indexing selalu menghasilkan copy (data baru). Memahami perbedaan ini krusial agar kita tidak membludakkan memori secara tidak sengaja saat memproses data besar. Contoh:

a = np.array([10, 20, 30, 40])
idx = [0, 2]
print(a[idx])
# Output: [10 30]

Perbedaan penting:

• Slice (a[1:3]) → biasanya view (tidak copy)
• Fancy indexing → selalu membuat copy

Ini sangat penting untuk:

• Mengontrol penggunaan memori
• Menghindari bug akibat modifikasi data yang tidak disengaja

Misalnya:

b = a[idx]
b[0] = 999

Di sini, a tidak akan berubah karena b adalah copy. Kalau kita tidak memahami ini, kita bisa salah kaprah saat debugging.

5. Vectorization

Vectorization adalah teknik menghilangkan loop eksplisit (perulangan for di Python) dan menggantinya dengan operasi array tunggal. Loop Python lambat karena interpretasi per-baris, namun operasi vektor Numpy terjadi di level kompilasi C/Fortran yang sangat cepat. Ketika kita memahami Broadcasting, Stride, dan Memory, Vectorization menjadi senjata utama untuk membuat kode berjalan 10x hingga 100x lebih kencang. Perulangan for (lambat):

result = []
for x in a:
    result.append(x * 2)

Vektorisasi (cepat):

result = a * 2

Kenapa jauh lebih cepat?

• Loop Python berjalan di level interpreter (lambat)
• Operasi NumPy berjalan di C (cepat)
• Akses memori lebih efisien

Vectorization bukan sekadar "gaya", tapi filosofi berpikir: Berpikir dalam bentuk operasi matriks, bukan iterasi elemen.

Pesan Penting

Perlu diingat, bagian terpenting adalah memahami konsep array dengan perintah di atas pada tataran level otak kita, bukan simulasi komputer. Artinya, kita bisa menebak output dari komputer (simulasi/Python Numpy) dengan otak kita dan memahaminya. Bukan asal mensimulasikan array, meskipun bisa menebak hasilnya. Inilah yang terpenting: ilmu sebelum beramal.

Referensi

1. https://shihchinw.github.io/2019/03/performance-tips-of-numpy-ndarray.html
2. https://pythonspeed.com/articles/numpy-memory-footprint/

Numpy: Broadcasting

Konsep python yang agak susah dipahami adalah operasi broadcasting. Operasi broadcasting merupakan "menyebar" pesan ke seluruh elemen matrik. Contoh sederhana, matrik c saya tambahkan dengan '5', maka semua elemen dalam matrik c akan ditambah dengan nilai 5. Operasi ini, sesuai konsep vektorisasi Numpy, akan jauh lebih cepat dari loop `for'. Syarat operasi broadcasting ini adalah setidaknya harus ada kompatibilitas antar aksisnya, bisa kolomnya, bisa barisnya, atau skalar. Misalnya matrik c  dengan ukuran (3, 3) bisa kita tambah dengan [1, 2, 3] tapi tidak dengan [1, 2, 3, 4].

>>> c = np.array([[ 5,  8, 11],
      [ 6,  9, 12],
      [ 7, 10, 13]])
>>> c +  [1, 2, 3]  # bisa juga dengan list langsung
array([[1,  5,  9],
      [ 2,  6, 10],
      [ 3,  7, 11]])
>>> c + np.array([1, 2, 3, 4])                
------------------------------------------
ValueError   Traceback (most recent call last)
< ipython-input-42-d334d3cf449e> in < module >
----> 1 c + np.array([1, 2, 3, 4])

ValueError: operands could not be broadcast together
with shapes (3,3) (4,)

Contoh lain adalah penjumlahan vektor kolom [1, 2, 3] dengan vektor baris [1, 2, 3]. Contoh ini menunjukkan betapa menariknya operasi broadcasting, kolom dijumlah dengan baris. Pada kolom pertama hasilnya menjadi [2, 3, 4], tiap elemen vektor kolom ditambah 1. Pada kolom 2 tiap elemen vektor kolom ditambah 2, dan pada elemen 3 tiap elemen vektor kolom ditambah dengan 3.

>>> np.array([1, 2, 3])[:, np.newaxis]+np.array([1, 2, 3])                                                                            
array([[2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])

Tulisan ini melengkapi tulisan ini.

Python: List Comprehension

Salah satu fitur di pemrograman Python yang saya suka dan sering pakai adalah list comprehension. Fitur ini menyederhanakan "for" loop dalam satu baris. Berikut contohnya.

Saya punya dua vektor A dan B. Saya ingin mencari dimana kemunculan vektor B dalam vektor A. 

a = np.array([1, 2, 3, 4, 5, 6])
b = np.array([2, 3, 4])

Dengan contoh di atas, jawaban atas pertanyaan saya adalah [1, 2, 3]; posisi/indeks dimana vektor B muncul di vektor A. Solusi pertama dengan "for" loop sebagai berikut:

import numpy as np
for i in b: 
    print(np.where(a == i)) 

Solusi kedua dengan List comprehension seperti berikut (baris kedua merupakan output).

In [26]: [np.where(a==x) for x in b]                                            
Out[26]: [(array([1]),), (array([2]),), (array([3]),)]

Cukup simpel dan intuitif.

Menghapus dan mengganti data NaN pada Numpy

Data NaN (Not a Number) sangat menjengkelkan; bisa dibilang sampah. Data ini, bisa dari pengukuran atau simulasi, tidak dipakai dalam pengolahan data dan perlu dihilangkan atau diganti. Ya, dua cara tersebut (menghapus atau mengganti data NaN) merupakan dua cara agar data yang terkontaminasi NaN bisa diproses. Oya, data NaN ini juga bisa merupakan data outlier, misal ketika mengukur suhu rentang 23-27 derajat celcius kita mendapatkan data pengukuran 127 celcius yang tentu saja tidak masuk akal. Bisa juga data NaN ini berupa nilai "0" karena kegagalan sensor pengukuran.

Menghapus Data NaN di Numpy

Misalkan kita memiliki 10 data pengukuran dari tiga sensor.  Pertama, kita mencari elemen NaN sebagai berikut.

In [1]: import numpy as np 
In [2]: a = np.array([[1, 2, 4], [1, 2, 1], [np.nan, 1, 2], [1, 2, np.nan], [2, 1, 1]])
In [3]: np.isnan(a).any()
Out[3]: True
In [4]: np.where(np.isnan(a))                                                                           
Out[4]: (array([2, 3]), array([0, 2]))

Dari output ipython tersebut kita mengetahui bahwa data NaN berada pada (2, 0) dan (3, 2). Ingat Python mengindeks dari 0. Untuk menghapus baris (row) yang berisi NaN, gunakan perintah berikut:

In [3]: b = a[~np.isnan(a).any(axis=1)] 

Algoritma menghapus NaN pada satu baris di atas dapat dijelaskan sbb:
1. Mencari indeks data NaN dengan np.isnan.
2. Mencari data jika ada NaN dengan np.any.
3. Mencari data jika ada NaN pada kolom (axis=1, karena yang kita hapus barisnya).
4. Membalik hasil pencarian pada (1-3) dengan ~, dengan kata lain, cari data yang bukan NaN.

Untuk lebih jelasnya, perhatikan setiap output perintah berikut:

In [57]: np.isnan(a)                                                                                     
Out[57]: 
array([[False, False, False],
       [False, False, False],
       [ True, False, False],
       [False, False,  True],
       [False, False, False]])
In [58]: np.isnan(a).any()                                                                               
Out[58]: True
In [59]: np.isnan(a).any(axis=1)                                                                         
Out[59]: array([False, False,  True,  True, False])
In [60]: ~np.isnan(a).any(axis=1)                                                                        
Out[60]: array([ True,  True, False, False,  True])

In [61]: a[~np.isnan(a).any(axis=1)]                                                                     
Out[61]: 
array([[1., 2., 4.],
       [1., 2., 1.],
       [2., 1., 1.]])

Baris untuk memfilter data NaN disebut fancy indexing. Inilah salah satu hal yang paling membedakan Numpy dengan List python. Dengan teknik ini kita bisa memfilter suatu array dengan array lainnya. Contohnya data dengan index NaN ini. Permasalahan menghapus data yang berisi NaN selesai.

Mengganti Data Nan di Numpy

Bagaimana jika kita tidak ingin menghapus dana NaN, tapi mengubahnya..? Misal, dalam pengukuran suhu, suhu yang tidak terbaca sensor kita anggap sebagai suhu 25 derajat celcius.
Berikut data dummy pengukuran tiga sensor suhu.

In [52]: a = np.random.uniform(23, 28, [10, 3])                                 

In [53]: a                                                                      
Out[53]: 
array([[27.78837233, 23.24395001, 23.57374599],
       [24.19978931, 23.25094801, 24.49294423],
       [26.73693715, 23.16475293, 25.96576384],
       [26.70315233, 24.85865614, 25.3510446 ],
       [25.31885087, 27.42903322, 25.26193883],
       [25.68032566, 27.06242615, 27.0408585 ],
       [26.64473586, 27.56036335, 24.49159284],
       [24.90196938, 26.00082306, 25.70781393],
       [26.58828295, 25.36263426, 27.6251521 ],
       [24.63801191, 24.23193679, 26.99034562]])

Kita tambahkan 5 data NaN secara acak.

In [54]: a.ravel()[np.random.choice(a.size, 5, replace=False)] = np.nan         

In [55]: a                                                                      
Out[55]: 
array([[27.78837233,         nan,         nan],
       [24.19978931, 23.25094801, 24.49294423],
       [26.73693715, 23.16475293, 25.96576384],
       [26.70315233, 24.85865614, 25.3510446 ],
       [        nan, 27.42903322, 25.26193883],
       [25.68032566, 27.06242615, 27.0408585 ],
       [26.64473586, 27.56036335,         nan],
       [24.90196938, 26.00082306, 25.70781393],
       [26.58828295,         nan, 27.6251521 ],
       [24.63801191, 24.23193679, 26.99034562]])

Terlihat 5 data NaN pada baris 0, 4, 6, dan 8 (indeks mulai dari 0). Kita ganti data NaN tersebut dengan 25.0 derajat celcius. Perintah yang digunakan adalan np.nan_to_num(a, nan=25.0).

In [56]: np.nan_to_num(a, nan=25.0)                                             
Out[56]: 
array([[27.78837233, 25.        , 25.        ],
       [24.19978931, 23.25094801, 24.49294423],
       [26.73693715, 23.16475293, 25.96576384],
       [26.70315233, 24.85865614, 25.3510446 ],
       [25.        , 27.42903322, 25.26193883],
       [25.68032566, 27.06242615, 27.0408585 ],
       [26.64473586, 27.56036335, 25.        ],
       [24.90196938, 26.00082306, 25.70781393],
       [26.58828295, 25.        , 27.6251521 ],
       [24.63801191, 24.23193679, 26.99034562]])

Cukup sederhana, jika argumen nan=25.0 tidak ditambahkan, maka data NaN akan diganti dengan angka "0" (default). Jika ingin mengganti dengan angka lain, misal 25.5, tinggal mengganti nan=25.5. Selesai permasalahan mengganti data NaN pada Numpy array.

 

Untuk Pandas (dataframe) silahkan baca di sini.

Menghitung rataan dengan mengabaikan nilai nol di Python Numpy

Ada kalanya kita ingin menghitung nilai rata-rata dari suatu data, namun kita ingin mengabaikan (skip) jika
ada nilai 0 (atau kosong, atau NaN, Not a Number) dalam data tersebut. Screencast di bawah ini menjelaskan tentang hal tersebut.

Numpy Array: merubah nilai tertentu (NaN) menjadi nilai lain

Keterangan ada pada komen (#) di dalam screencast.
TL;DR (too long; didn't read):

 a_without_nan = np.nan(a_with_nan, nan=0) # change NaN to 0

Lebih lengkapnya: 

https://bagustris.blogspot.com/2020/06/menghapus-dan-mengganti-data-nan-pada.html

Memahami size dan shape NumPy array

NumPy mirip dengan Matlab, jika kita menguasai bentuk matrik yang kita proses, maka akan mudah memahami proses komputasinya.

Langsung saja, perhatikan gambar berikut.

Sehingga, bentuk-bentuk matriks dapat dibagi sebagai berikut:

1. 1D array, contohnya matrik berbentuk (2, ), (3, ), (4, ).
2. 2D array, contohnya matrik berbentuk (3, 1), (2,3), (3,3).
3. 3D array, contohnya matrik berbentuk (3, 1, 1), (3, 2, 3), (4,3,2).
4. ND array, contohnya matrik berukuran (n, 4, 3, 2), (n, n, 4, 3, 2).

Jika a adalah sebuah NumPy array (disingkat: np array), maka beberapa atribut (perintah) penting dari a adalah:

• a.ndim: untuk mengetahui banyaknya dimensi dari variabel np array (1D, 2D, dll).
• a.shape: untuk mengetahui bentuk/shape dari variabel np array (misal (2,3)).
• a.size : untuk mengetahui total elemen matriks.
• len(a): untuk mengetahui panjang (baris/axis 0) dari np array, sama dengan a.shape[0].

Perhatikan screen cast berikut untuk implementasinya dengan Python.

Sesuai dengan judul artikel ini, size dan shape merujuk pada ukuran dan bentuk. Ukuran bernilai skalar, yakni banyaknya elemen, sedangkan bentuk bernilai matriks (baris, kolom). Namun kedua istilah tersebut kadang disamakan. Contohnya berikut.

In [1]: a = np.random.randint(0,10, size=(4, 3))                                

In [2]: a.shape                                                                 
Out[2]: (4, 3)

In [3]: a.size                                                                  
Out[3]: 12

In [4]: b = np.zeros(shape=(3, 2))                                              

In [5]: b.shape                                                                 
Out[5]: (3, 2)

In [6]: b.size                                                                  
Out[6]: 6

Jadi sebagai attribut kelas, shape dan size berbeda, sedangkan sebagai argumen keduanya sampai saat ini masih disamakan. Mungkin karena pengaruh bahasa C seperti yang didiskusikan pada forum ini. 

Untuk memahami pengubahan bentuk matriks pada NumPy array, silahkan baca artikel saya di SainsHack berikut: pengubahan bentuk matriks pada NumPy arrah.

Ekstraksi fitur MFCC dan zero paddingnya dengan library LIBROSA

Mel frequency cepstral coefficient, disingkat MFCC, masih merupakan fitur yang paling banyak digunakan pada pemrosesan sinyal wicara, khususnya pengenalan sinyal wicara. Untuk mengekstrak fitur MFCC, salah satu tool yang paling banyak digunakan adalah librosa. Tulisan berikut merupakan paparan singkat untuk mengekstrak fitur MFCC dari set sinyal wicara dalam sebuah direktori.

Instalasi

pip3 install --user librosa

Workflow
Misalkan dalam direktory saat ini (`./`), kita memiliki 30 file wav sinyal wicara. Dari 30 file tersebut, tiap file akan kita ekstrak 20 MFCC per frame/window (dari default librosa). Karena panjang tiap file berbeda, maka bentuk/ukuran variabel MFCC untuk tiap file tersebut berbeda, misalnya: (20, 44), (20, 193) dan (20, 102).  Karena default window size atau hopsize (n_fft) dari librosa adalah 2048 (25ms) dengan 512 hop length /stride (10 ms overlap), maka untuk file suara dengan durasi 2 detik banyaknya frame mffc yang didapat adalah,

output _length = (seconds) * (sample rate) / (hop_length)
output_length = 2 * 22050/512 = 87 --> (20, 87)

Jika panjang file 3 detik maka panjang output_length adalah,

output_length = 3 * 22050/512 = 130 --> (20, 130)

Variabel lebar window and stride untuk memproses MFCC pada librosa bisa dikontrol dengan argumen n_fft dan hop_length. Misal n_fft = int(sr/40), hop_lenghth=int(sr/100) untuk lebar window 25 ms dan hop length (geser ke kanan) sebesar 10 ms. Perhatikan gambar berikut untuk lebih jelasnya, K adalah lebar window (n_fft) dan Q adalah stride atau hop length (disebut juga hop size). Pada beberapa literatur sinyal sistem, variabel pergeseran antar window memakai nilai % overlap yang pada gambar dibawah disimbolkan dengan 0. Jika default hop_length=512 dan n_fft = 2048, maka overlap defaultnya adalah 75%.

Windowing: window length, hop size, and its overlap.

Jadi, by default MFCC yang dihasilkan oleh librosa berbeda ukurannya bergantung pada ukuran file input. Padahal, agar bisa diproses oleh deep learning, kita inginkan panjang semua variabel MFCC tersebut sama, misal (20, 100). Jika kurang kita zero-paddingkan, jika lebih kita potong sampai 100 sample sehingga menjadi (20, 100). Karena input deeplearning berupa (sample, fitur), bentuk (20, 100) kita transpose menjadi (100, 20). Tujuan akhir kita adalah memperoleh bentuk dari variabel fitur berupa (30, 100, 20) yang siap dimasukkan pada arsitektur deep learning.

Berikut caranya:

import os
import librosa

lenmin = 100

mfcc =[]
for i in os.listdir('.'):
    x_i, sr = librosa.load(i, sr=None)
    mfcc_i = librosa.feature.mfcc(x_i, sr)
    if mfcc_i.shape[1] < lenmin:
        mfcc_i = np.hstack((mfcc_i, np.zeros((mfcc_i.shape[0], lenmin-mfcc_i.shape[1]))))
    mfcc_i = mfcc_i[:,:lenmin]
    mfcc.append(mfcc_i.T)

mfcc = np.array(mfcc)

Cek ukuran variable mfcc dengan:

In [1]: np_mfcc.shape
Out[1]: (30, 100, 20)

Mengekstrak Delta dan Delta-delta MFCC
Pada banyak aplikasi pemrosesan sinyal wicara, tidak hanya MFCC yang dipakai sebagai fitur, namun juga perbedaan antar koefisien MFCC (delta) dan perbedaan antar delta MFCC (delta-delta). Librosa menyediakan fungsi untuk mengekstrak kedua fitur tersebut.

Untuk mengekstrak delta MFCC dari MFCC:

delta = librosa.feature.delta(mfcc)

Untuk mengekstrak delta-delta dari MFCC:

deltad = librosa.feature.delta(MFCC, order=2)

Zero padding dengan Tensorflow 

Ada cara yang lebih singkat untuk zero padding, yakni dengan tensorflow. Dengan tensorflow, kita hanya butuh satu perintah (dan satu baris jika memungkinkan). Contoh jika kita mempunyai list MFCC dengan ukuran seperti [(100, 20), (28, 20), (53,20), ...]. Semua MFCC tersebut kita rubah menjadi ukuran (100, 200) dengan cara berikut.

import tensorflow as tf
mfcc_padded = tf.keras.preprocessing.sequence.pad_sequence(mfcc, maxlen=100, dtype=float)

Dimana mfcc_list merupakan list MFCC yang berbeda-beda ukuran dan hasilnya, mfcc_padded, merupakan list MFCC yang kesemuanya berukuran (100, 20) melalui teknik zero padding.

Python: konversi array ND ke 1D

Misal kita memiliki matriks sebagai berikut:

In [4]: x = np.arange(9.).reshape(3, 3)
In [5]: x
Out[5]: array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])

Apabila kita cari tahu panjang dan bentuk vektor x

In [6]: x.shape                                                                 
Out[6]: (3, 3)
In [179]: len(x)
Out[179]: 3

In [180]: x.size
Out[180]: 9

Artinya, kita memiliki array 3D (N-dimensional atau ND) dengan panjang 3 baris dan total berisi 9 elemen. Kita ingin merubah matrix 3x3 tersebut menjadi matrikx 1x9 (atau 9x1). Berikut caranya:

x.flatten()

Cek panjang vektor x.flatten sebagai berikut:

len(x.flatten())

Update:
2019-04-22: Selain dengan `flatten`, konversi ke 1D dilakukan dengan ravel dan ini cara lebih cepat.

Numpy: Menggabungkan dua list menjadi N x 2 vektor

Misalkan kita memiliki dua list sebagai berikut:

kata = ["Bagus!", "Ampuh!", "cantik!", "Mantap!", "Cakep!", 
        "Jelek", "Rusak", "Nol", "Omong kosong", "Busuk", "Tidak"]
label = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]

Kita ingin menggabungkan dua list tersebut sehingga menjadi seperti ini:

array([['Bagus!', '1'],
       ['Ampuh!', '1'],
       ['cantik!', '1'],
       ['Mantap!', '1'],
       ['Cakep!', '1'],
       ['Jelek', '0'],
       ['Rusak', '0'],
       ['Nol', '0'],
       ['Omong kosong', '0'],
       ['Busuk', '0'],
       ['Tidak', '0']])

Maka, kita dapat menggunakan skrip berikut:

kata_label = hstack([np.array(kata, ndmin=2).T, np.array(label, ndmin=2).T])

Zero Padding dan efeknya pada FFT

Zero padding berarti menambahkan nol diakhir sinyal. Misal kita memiliki vektor x sebagai berikut,

$$ x = [0 ~1~ 2 ~3 ~1~ 2~ 3~ 2~ 4~ 3] $$

Vektor tersebut memiliki ukuran 10 data. Zero padding adalah menambahkan nol di belakang vektor tersebut, misalnya kita tambahkan lima nol di belakang data terakhir sehingga menjadi,

$$x = [0 ~1~ 2~ 3~ 1~ 2~ 3~ 2~ 4~ 3~ 0~ 0~ 0~ 0~ 0]$$

Zero padding banyak dipakai untuk menyamakan ukuran vektor/matriks. Pada machine learning/deep learning, ukuran input harus sama, dan zero padding dilakukan untuk tujuan tersebut (menyamakan ukuran input). Pada analisa sinyal di domain frekuensi, zero padding ini biasanya digunakan agar spektrum yang kita plot menjadi lebih halus.

Implementasi dengan Python

Implementasi zero padding dengan python bisa bermacam-macam, salah satunya dengan np.pad (salah lainnya dengan menggunakan np.zeros).

Contohnya adalah sebagai berikut:

>>> x = np.array([1, 2, 3, 4, 5])
>>> xpad = np.pad(x, (0, 5), 'constant')  # menambahkan lima nol di belakang vektor a
>>> x
    [1, 2, 3, 4 , 5, 0, 0, 0, 0, 0]