Perkalian matriks adalah operasi fundamental dalam aljabar linier.
Kami biasanya menggunakannya dalam berbagai aplikasi seperti pemrosesan gambar, pembelajaran mesin, dan banyak lagi. NumPy adalah paket Python terkenal untuk komputasi ilmiah.
Namun, dalam postingan ini, kita akan melihat berbagai metode untuk melakukan perkalian matriks dengan Python tanpa menggunakan NumPy.
Kami akan memanfaatkan loop bersarang, fungsi map() bawaan, dan pemahaman daftar.
Selain itu, kita akan melihat keuntungan dan kerugian dari masing-masing strategi, serta kapan menerapkannya. Jika Anda baru mengenal aljabar linier dan ingin mempelajari lebih lanjut tentang perkalian matriks; teruslah membaca.
Di Mana Kita Menggunakan Perkalian Matriks?
Perkalian matriks digunakan dalam grafik komputer untuk mengubah visual 2D dan 3D. Misalnya, Anda dapat memutar, menskalakan, dan menerjemahkan objek di layar. Matriks digunakan dalam pemrosesan gambar untuk merepresentasikan gambar sebagai susunan piksel. Selain itu, matriks dapat digunakan untuk melakukan operasi seperti pemfilteran gambar.
Kami juga menggunakan matriks di Mesin belajar. Mereka dapat membantu kita merepresentasikan data dan parameter model. Kita dapat melakukan banyak operasi, seperti menghitung produk titik dan produk matriks-vektor.
Tentunya, operasi ini juga sangat menguntungkan dalam operasi ilmiah. Kita dapat menggunakannya dalam fisika dan teknik untuk menjelaskan kuantitas fisik. Karenanya, kita dapat beroperasi dengan vektor dan tensor.
Mengapa Kami Tidak Memilih untuk Menggunakan NumPy?
Sementara NumPy adalah Pustaka Python, ini tidak selalu merupakan opsi ideal untuk perkalian matriks. Kami mungkin tidak memilih untuk menggunakan NumPy karena alasan seperti ukuran dan ketergantungan, pembelajaran, dan sistem warisan.
Menggunakan fungsi bawaan Python atau mengembangkan kode khusus mungkin lebih efisien dalam beberapa kasus. Namun, penting untuk dicatat bahwa NumPy adalah perpustakaan yang kuat. Selain itu, Anda juga dapat menggunakannya untuk perkalian matriks.
Sekarang, mari kita lihat bagaimana kita bisa mencapai perkalian matriks tanpa NumPy.
Metode loop bersarang
Teknik loop bersarang menggunakan loop bersarang untuk mengeksekusi perkalian matriks dengan Python. Fungsi ini berulang pada setiap elemen matriks. Dan, itu mengalikannya menggunakan serangkaian loop bersarang. Fungsi mengembalikan hasilnya, yang disimpan dalam matriks baru.
Pendekatan ini mudah dipahami. Namun, ini mungkin tidak seefisien cara lain, terutama untuk matriks yang lebih besar. Namun, ini adalah pilihan yang bagus untuk Anda jika Anda baru mengenal aljabar linier.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Setel matriks hasil ke nol.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
Mari kita lihat contoh bagaimana melakukan ini. Anda bisa menambahkan baris kode di bawah ini untuk menguji contoh ini.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
Manfaat:
- Mudah dipahami.
- Bagus untuk pemula atau mereka yang mencari pemahaman yang lebih dalam tentang perkalian matriks.
kekurangan:
- Tidak seefektif teknik alternatif, terutama untuk matriks yang lebih besar.
- Ini tidak mudah dibaca sebagai pendekatan alternatif.
peta() metode fungsi
Metode fungsi map() menyediakan pendekatan alternatif untuk melakukan perkalian matriks dengan Python. Dalam pendekatan ini, kami menggunakan fungsi map() bawaan. Karenanya, kami menggunakan alat pemrograman fungsional yang menerapkan fungsi yang disediakan untuk setiap elemen yang dapat diubah (daftar, tupel, dll.). Juga, fungsi map() menerima dua parameter, sebuah fungsi dan sebuah iterable. Dan, mengembalikan sebuah iterator yang menerapkan fungsi ke setiap elemen iterable.
Dalam pendekatan ini, kita menelusuri setiap anggota matriks dan melakukan perkalian menggunakan fungsi nested map() .
Fungsi zip() digunakan untuk melakukan iterasi melalui setiap elemen matriks secara paralel.
Terakhir, fungsi sum() digunakan untuk menjumlahkan hasilnya.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
Sekarang, sekali lagi, kita dapat menguji kode kita dengan sebuah contoh.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
Kelebihan
- Lebih efektif daripada pendekatan loop bertumpuk
- Ini menggunakan pemrograman fungsional untuk membuat kode lebih sederhana.
Kekurangan
- Beberapa orang yang tidak terbiasa dengan pemrograman fungsional mungkin menganggapnya kurang mudah dibaca.
- Ini kurang bisa dimengerti daripada teknik loop bersarang.
Metode pemahaman daftar
Pemahaman daftar memungkinkan Anda membuat daftar baru dalam satu baris kode. Oleh karena itu, ini dilakukan dengan menerapkan ekspresi ke setiap anggota daftar yang ada.
Dalam pendekatan ini, perkalian dilakukan dengan iterasi berulang kali melalui setiap anggota matriks. Kami menggunakan pemahaman daftar berlapis.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
manfaat
- Dibandingkan dengan metode fungsi map(), lebih pendek dan lebih mudah dibaca.
Kekurangan
- Ini mungkin kurang efektif daripada menggunakan fungsi map(), khususnya untuk matriks besar.
- Ini lebih sulit daripada pendekatan loop bersarang.
Kesimpulan
Dalam posting ini, kami melihat alternatif untuk menggunakan NumPy saat mengalikan matriks dengan Python. Kami melakukan perkalian matriks dalam loop bersarang, fungsi map() bawaan, dan pemahaman daftar.
Strategi terbaik akan bergantung pada kebutuhan khusus proyek Anda.
Masing-masing strategi memiliki pro dan kontra sendiri. Untuk memastikan fungsi beroperasi dengan baik, ada baiknya menambahkan beberapa test case dengan berbagai dimensi dan nilai matriks.
Anda juga harus menyertakan beberapa tes kinerja untuk membandingkan seberapa baik metode ini dijalankan.
Tinggalkan Balasan