Pendaraban matriks ialah operasi asas dalam algebra linear.
Kami biasanya menggunakannya dalam pelbagai aplikasi seperti pemprosesan imej, pembelajaran mesin dan banyak lagi. NumPy ialah pakej Python yang terkenal untuk pengkomputeran saintifik.
Walau bagaimanapun, dalam siaran ini, kita akan melihat pelbagai kaedah untuk melakukan pendaraban matriks dalam Python tanpa menggunakan NumPy.
Kami akan memanfaatkan gelung bersarang, fungsi map() terbina dalam, dan pemahaman senarai.
Di samping itu, kami akan melihat faedah dan kelemahan setiap strategi, serta masa untuk menggunakan setiap strategi. Jika anda baru dalam algebra linear dan ingin mengetahui lebih lanjut tentang pendaraban matriks; teruskan membaca.
Di Mana Kami Menggunakan Pendaraban Matriks?
Pendaraban matriks digunakan dalam grafik komputer untuk mengubah visual 2D dan 3D. Contohnya, anda boleh memutar, menskala dan menterjemah objek pada skrin. Matriks digunakan dalam pemprosesan imej untuk mewakili gambar sebagai tatasusunan piksel. Selain itu, matriks boleh digunakan untuk menjalankan operasi seperti penapisan imej.
Kami juga menggunakan matriks dalam pembelajaran mesin. Mereka boleh membantu kami untuk mewakili data dan parameter model. Kami boleh menjalankan banyak operasi, seperti pengkomputeran produk titik dan produk vektor matriks.
Sudah tentu, operasi ini juga sangat berfaedah dalam operasi saintifik. Kita boleh menggunakannya dalam fizik dan kejuruteraan untuk menerangkan kuantiti fizik. Oleh itu, kita boleh beroperasi dengan vektor dan tensor.
Mengapa Kami Tidak Memilih untuk Menggunakan NumPy?
Manakala NumPy ialah a Perpustakaan Python, ia bukan selalu pilihan yang ideal untuk pendaraban matriks. Kami mungkin tidak memilih untuk menggunakan NumPy atas sebab seperti saiz dan pergantungan, pembelajaran dan sistem warisan.
Menggunakan fungsi terbina dalam Python atau membangunkan kod tersuai mungkin lebih cekap dalam beberapa keadaan. Walau bagaimanapun, adalah penting untuk diperhatikan bahawa NumPy ialah perpustakaan yang kukuh. Selain itu, anda juga boleh menggunakannya untuk pendaraban matriks.
Sekarang, mari kita lihat bagaimana kita boleh mencapai pendaraban matriks tanpa NumPy.
Kaedah gelung bersarang
Teknik gelung bersarang menggunakan gelung bersarang untuk melaksanakan pendaraban matriks dalam Python. Fungsi ini berulang pada setiap elemen matriks. Dan, ia mendarabkannya menggunakan satu siri gelung bersarang. Fungsi ini mengembalikan hasil, yang disimpan dalam matriks baharu.
Pendekatan ini mudah difahami. Walau bagaimanapun, ia mungkin tidak secekap cara lain, terutamanya untuk matriks yang lebih besar. Namun, ini adalah pilihan yang bagus untuk anda jika anda baru dalam algebra linear.
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])
# Tetapkan matriks hasil kepada sifar.
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 berikan contoh bagaimana untuk melakukan ini. Anda hanya boleh menambah baris kod ini di bawah 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]]
Kebaikan:
- Mudah difahami.
- Bagus untuk pemula atau mereka yang mencari pemahaman yang lebih mendalam tentang pendaraban matriks.
Kelemahan:
- Tidak berkesan seperti teknik alternatif, terutamanya untuk matriks yang lebih besar.
- Ia tidak boleh dibaca sebagai pendekatan alternatif.
kaedah fungsi map().
Kaedah fungsi map() menyediakan pendekatan alternatif untuk melakukan pendaraban matriks dalam Python. Dalam pendekatan ini, kami menggunakan fungsi map() terbina dalam. Oleh itu, kami menggunakan alat pengaturcaraan berfungsi yang menggunakan fungsi yang disediakan untuk setiap elemen lelaran (senarai, tuple, dll.). Juga, fungsi map() menerima dua parameter, fungsi dan boleh lelar. Dan, ia mengembalikan iterator yang menggunakan fungsi untuk setiap elemen boleh lelaran.
Dalam pendekatan ini, kami melalui setiap ahli matriks dan melakukan pendaraban menggunakan fungsi map() bersarang.
Fungsi zip() digunakan untuk melelaran melalui setiap elemen matriks secara selari.
Akhirnya, fungsi sum() digunakan untuk menambah hasil.
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 boleh menguji kod kita dengan 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 berkesan daripada pendekatan gelung bertindan
- Ia menggunakan pengaturcaraan berfungsi untuk menjadikan kod lebih mudah.
Kekurangan
- Sesetengah orang yang tidak biasa dengan pengaturcaraan berfungsi mungkin mendapati ia kurang boleh dibaca.
- Ia kurang difahami daripada teknik gelung bersarang.
Senaraikan kaedah pemahaman
Pemahaman senarai membolehkan anda menjana senarai baharu dalam satu baris kod. Oleh itu, ini adalah dengan menggunakan ungkapan kepada setiap ahli senarai sedia ada.
Dalam pendekatan ini, pendaraban dijalankan dengan berulang kali berulang melalui setiap ahli matriks. Kami menggunakan pemahaman senarai 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]]
Faedah-faedah
- Berbanding dengan kaedah fungsi map(), lebih pendek dan lebih mudah dibaca.
Kekurangan
- Ia mungkin kurang berkesan daripada menggunakan fungsi map(), terutamanya untuk matriks besar.
- Ia lebih sukar daripada pendekatan gelung bersarang.
Kesimpulan
Dalam siaran ini, kami melihat alternatif untuk menggunakan NumPy apabila mendarab matriks dalam Python. Kami melakukan pendaraban matriks dalam gelung bersarang, fungsi map() terbina dalam dan pemahaman senarai.
Strategi terbaik akan bergantung pada keperluan tertentu projek anda.
Setiap strategi mempunyai kebaikan dan keburukan tersendiri. Untuk memastikan fungsi berfungsi dengan betul, adalah idea yang baik untuk menambah beberapa kes ujian dengan pelbagai dimensi dan nilai matriks.
Anda juga harus memasukkan beberapa ujian prestasi untuk membandingkan sejauh mana kaedah ini dilaksanakan.
Sila tinggalkan balasan anda