Perbandingan Loop dan Vectorization

Pendahuluan
Pengulangan datang secara alami kepada kita, kita belajar tentang pengulangan di hampir semua bahasa pemrograman. Jadi, secara default, kita mulai menerapkan pengulangan setiap kali ada operasi yang repetitif. Tetapi ketika kita bekerja dengan jumlah iterasi yang besar (jutaan/miliaran baris), menggunakan pengulangan bisa dianggap sebagai tindakan yang kurang efisien. Mungkin Anda akan terjebak untuk beberapa jam, baru kemudian menyadari bahwa itu tidak akan berhasil. Inilah saatnya menerapkan Vectorization dalam Python menjadi sangat penting.

Apa itu Vectorization?

Vectorization adalah teknik menerapkan operasi array (NumPy) pada sebuah dataset. Secara latar belakang, ia menerapkan operasi pada semua elemen array atau rangkaian sekaligus (berbeda dengan pengulangan ‘for’ yang memanipulasi satu baris pada satu waktu).

Dalam artikel ini, kita akan melihat beberapa kasus penggunaan di mana kita dapat dengan mudah menggantikan pengulangan Python dengan Vectorization. Hal ini akan membantu Anda menghemat waktu dan menjadi lebih terampil dalam pemrograman.

Case 1: Menemukan Jumlah Bilangan
Pertama, kita akan melihat contoh dasar dalam menemukan jumlah bilangan menggunakan pengulangan dan Vectorization dalam Python.

Menggunakan Pengulangan

import time
start = time.time()
# jumlah secara iteratif
total = 0
# mengulang sebanyak 1,5 Juta angka
for item in range(0, 1500000):
  total = total + item
print('Jumlahnya adalah:' + str(total))
end = time.time()
print(end - start)
# 1124999250000
# 0,14 Detikp

Menggunakan Vectorization

import numpy as np
start = time.time()
# jumlah vektor - menggunakan numpy untuk vectorization
# np.arange membuat urutan angka dari 0 hingga 1499999
print(np.sum(np.arange(1500000)))
end = time.time()
print(end - start)
# 1124999250000
# 0,008 Detik

Vectorization membutuhkan waktu ~18x lebih singkat untuk dieksekusi dibandingkan dengan iterasi menggunakan fungsi range. Perbedaan ini akan menjadi lebih signifikan saat bekerja dengan DataFrame Pandas.

Case 2: Operasi Matematika (pada DataFrame)

Dalam Ilmu Data, saat bekerja dengan Pandas DataFrame, para pengembang menggunakan pengulangan untuk membuat kolom turunan baru menggunakan operasi matematika.

Pada contoh berikut, kita dapat melihat seberapa mudahnya pengulangan dapat digantikan dengan Vectorization untuk kasus penggunaan seperti ini.

Membuat DataFrame

DataFrame adalah data tabular dalam bentuk baris dan kolom.

Kami membuat DataFrame Pandas dengan 5 Juta baris dan 4 kolom yang diisi dengan nilai acak antara 0 dan 50.

import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randint(0, 50, size=(5000000, 4)), columns=('a', 'b', 'c', 'd'))
df.shape
# (5000000, 5)
df.head()

Kami akan membuat kolom baru ‘ratio’ untuk menemukan rasio dari kolom ‘d’ dan ‘c’.

Menggunakan Pengulangan

import time 
start = time.time()
# Mengulang melalui DataFrame menggunakan iterrows
for idx, row in df.iterrows():
 # membuat kolom baru 
 df.at[idx, 'ratio'] = 100 * (row["d"] / row["c"]) 
end = time.time()
print(end - start)
### 109 Detik

Menggunakan Vectorization

start = time.time()
df["ratio"] = 100 * (df["d"] / df["c"])
end = time.time()
print(end - start)
### 0,12 detik

Kita dapat melihat peningkatan yang signifikan dengan DataFrame, waktu yang dibutuhkan oleh operasi Vectorization hampir 1000x lebih cepat dibandingkan dengan pengulangan di Python.

Case 3: Pernyataan If-else (pada DataFrame)

Kita mengimplementasikan banyak operasi yang memerlukan kita untuk menggunakan logika ‘If-else’. Kita dapat dengan mudah menggantikan logika ini dengan operasi Vectorization dalam Python.

Mari lihat contoh berikut untuk memahaminya lebih baik (kita akan menggunakan DataFrame yang telah kita buat pada kasus penggunaan 2):

Bayangkan kita ingin membuat kolom baru ‘e’ berdasarkan beberapa kondisi pada kolom yang ada ‘a’.

Menggunakan Pengulangan

import time 
start = time.time()
# Mengulang melalui DataFrame menggunakan iterrows
for idx, row in df.iterrows():
 if row.a == 0:
 df.at[idx, 'e'] = row.d 
 elif (row.a <= 25) & (row.a > 0):
 df.at[idx, 'e'] = (row.b) - (row.c) 
 else:
 df.at[idx, 'e'] = row.b + row.c
end = time.time()
print(end - start)
### Waktu yang dibutuhkan: 177 detik

Menggunakan Vectorization

# menggunakan vectorization 
start = time.time()
df['e'] = df['b'] + df['c']
df.loc[df['a'] <= 25, 'e'] = df['b'] - df['c']
df.loc[df['a'] == 0, 'e'] = df['d']
end = time.time()
print(end - start)
## 0,28007707595825195 detik

Waktu yang dibutuhkan oleh operasi Vectorization 600x lebih cepat dibandingkan dengan pengulangan Python dengan pernyataan if-else.

Case 4: Menyelesaikan Jaringan Pembelajaran Mesin/Deep Learning

Pembelajaran Mendalam memerlukan kita untuk menyelesaikan beberapa persamaan kompleks dan itu pun untuk jutaan dan miliaran baris. Menjalankan pengulangan di Python untuk menyelesaikan persamaan-persamaan ini sangat lambat dan Vectorization adalah solusi optimal.

Sebagai contoh, untuk menghitung nilai y untuk jutaan baris dalam persamaan regresi multi-linier:

Persamaan Regresi Linier (Gambar oleh Penulis)

Kita dapat menggantikan pengulangan dengan Vectorization.

Nilai-nilai m1, m2, m3,… ditentukan dengan menyelesaikan persamaan di atas menggunakan jutaan nilai yang sesuai dengan x1, x2, x3,… (untuk kesederhanaan, kita hanya akan melihat langkah perkalian sederhana)

Membuat Data

import numpy as np
# menetapkan nilai awal m 
m = np.random.rand(1,5)
# nilai input untuk 5 juta baris
x = np.random.rand(5000000,5)

Menggunakan Pengulangan

import numpy as np
m = np.random.rand(1, 5)
x = np.random.rand(5000000, 5)
total = 0
tic = time.process_time()
for i in range(0, 5000000):
 total = 0
 for j in range(0, 5):
 total = total + x[i][j] * m[0][j] 
 
 zer[i] = total 
toc = time.process_time()
print("Waktu komputasi = " + str((toc - tic)) + "detik")
####Waktu komputasi = 28,228 detik

Menggunakan Vectorization

tic = time.process_time()
# perkalian dot
np.dot(x, m.T) 
toc = time.process_time()
print("Waktu komputasi = " + str((toc - tic)) + "detik")
####Waktu komputasi = 0,107 detik

`np.dot` mengimplementasikan perkalian matriks Vectorized di belakang layar. Ini 165x lebih cepat dibandingkan dengan pengulangan di Python.

Ringkasan:

Dalam tiga kasus penggunaan yang dibahas, kita melihat betapa efisiennya Vectorization dibandingkan dengan pengulangan dalam Python, terutama saat bekerja dengan DataFrame Pandas dan operasi matematika kompleks.

1. Penggunaan 1: Menemukan Jumlah Bilangan

• Dengan menggunakan pengulangan, waktu eksekusi adalah 0,14 detik.
• Dengan menggunakan Vectorization (NumPy), waktu eksekusi hanya 0,008 detik.
• Vectorization membutuhkan waktu ~18x lebih sedikit dibandingkan dengan pengulangan.

2. Penggunaan 2: Operasi Matematika (pada DataFrame)

• Pengulangan memakan waktu 177 detik untuk membuat kolom ‘ratio’ pada DataFrame.
• Vectorization hanya memerlukan waktu 0,28007707595825195 detik.
• Vectorization mempercepat operasi sekitar 600x dibandingkan dengan pengulangan.

3. Penggunaan 3: Pernyataan If-else (pada DataFrame)

• Pengulangan membutuhkan waktu 177 detik untuk menentukan nilai kolom ‘e’ berdasarkan kondisi pada kolom ‘a’.
• Vectorization hanya memerlukan waktu 0,28007707595825195 detik.
• Waktu eksekusi Vectorization sekitar 600x lebih cepat dibandingkan dengan pengulangan.

4. Penggunaan 4 (Lanjutan): Menyelesaikan Jaringan Pembelajaran Mesin/Deep Learning.

• Dalam kasus ini, Vectorization sangat optimal untuk menyelesaikan persamaan kompleks dalam jutaan dan miliaran baris.
• Memanfaatkan NumPy dan operasi vektorisasi dapat memberikan peningkatan performa yang signifikan.

5. Penggunaan Tambahan: Matriks Dot Product

• Pengulangan memakan waktu 28,228 detik untuk melakukan perkalian dot pada dua matriks.
• Vectorization menggunakan `np.dot` hanya memerlukan waktu 0,107 detik.
• Vectorization mengungguli pengulangan sekitar 165x dalam hal kecepatan eksekusi.

Dalam semua kasus, penggunaan Vectorization, terutama dengan NumPy, dapat memberikan peningkatan kinerja yang luar biasa, terutama ketika bekerja dengan dataset yang besar.

reference : https://medium.com/codex/say-goodbye-to-loops-in-python-and-welcome-vectorization-e8b0172b9581