Multiplikasi Matriks.

Multiplikasi Matriks.

Jadi, dalam pelajaran sebelumnya, kami membongkar aturan untuk penambahan dan pengurangan matriks. Ini adalah operasi yang begitu sederhana sehingga sebagian besar siswa memahaminya secara harfiah dengan pergi.

Namun, Anda bersukacita lebih awal. Freebie sudah berakhir - pergi ke perkalian. Segera saya memperingatkan Anda: kalikan dua matriks sama sekali tidak mengalikan angka dalam sel dengan koordinat yang sama, seolah-olah Anda mungkin berpikir. Semuanya jauh lebih menyenangkan di sini. Dan untuk memulai dengan definisi awal.

Matriks yang konsisten

Salah satu karakteristik paling penting dari matriks adalah ukurannya. Kami telah membicarakannya seratus kali: rekor $ A = \ kiri [m \ kali n \ kanan] $ berarti bahwa dalam matriks persis $ m $ baris dan $ n $ kolom. Bagaimana tidak membingungkan baris dengan kolom, kita sudah membahas juga. Sekarang ini penting.

Definisi. Matriks dari $ A = \ kiri] $ dan $ b = \ kiri] $ dan $ b = \ kiri] $, di mana jumlah kolom dalam matriks pertama bertepatan dengan jumlah baris di yang kedua, adalah dipanggil Konsisten .

Sekali lagi: jumlah kolom di matriks pertama sama dengan jumlah baris di kedua! Dari sini kita mendapatkan dua output sekaligus:

  1. Kami penting untuk urutan matriks. Misalnya, matriks $ A = \ kiri [3 \ kali 2 \ kanan] $ dan $ b = \ kiri [2 \ kali 5 \ kanan] $ disetujui (2 kolom dalam matriks pertama dan 2 baris di kedua) , tetapi sebaliknya - matriks $ b = \ kiri [2 \ kali 5 \ kanan] $ dan $ A = \ kiri [3 kali 2 \ kanan] $ - tidak lagi setuju (5 kolom dalam matriks pertama - tidak 3 baris di kedua).
  2. Konsistensi mudah untuk memeriksa apakah Anda menuliskan semua ukuran satu sama lain. Pada contoh paragraf sebelumnya: "3 2 2 5" - di tengah angka yang sama, sehingga matriks disepakati. Tapi "2 5 3 2" - tidak setuju, karena di tengah ada angka yang berbeda.

Selain itu, kapten jelas karena ia memiliki matriks persegi dengan jumlah $ \ kiri [n \ kali n \ kanan] $ selalu konsisten.

Dalam matematika, ketika prosedur untuk mentransfer objek penting (misalnya, dalam definisi di atas, prosedur untuk matriks penting), sering berbicara tentang pasangan yang dipesan. Kami bertemu dengan mereka di sekolah: Saya pikir juga jelas bahwa koordinat $ \ kiri (1; 0 \ kanan) $ dan $ \ kiri (0; 1 \ kanan) $ set poin yang berbeda pada pesawat.

Jadi: koordinat juga dipesan pasangan yang disusun dari angka. Tapi tidak ada yang mencegah pasangan matriks seperti itu. Kemudian dapat dikatakan: "Pasangan yang dipesan $ \ matriks kiri (a; b \ kanan) $ konsisten jika jumlah kolom dalam matriks pertama bertepatan dengan jumlah baris pada detik."

Nah, jadi apa?

Definisi multiplikasi.

Pertimbangkan dua matriks yang konsisten: $ A = \ kiri [m \ kali n \ kanan] $ dan $ b = \ kiri [n \ time k \ kanan] $. Dan kami mendefinisikan operasi multiplikasi untuk mereka.

Definisi. Pekerjaan dua matriks yang disepakati $ A = \ kiri] $ dan $ b = \ kiri] $ dan $ b = \ kiri] $ adalah matriks baru $ C = \ kiri [m \ kali k \ kanan] $ elemen yang dipertimbangkan oleh rumus:

\ [\ begin {align} {{{i; j}} = {{i; 1}} \ cdot {{1; j}} + {{a}} + {{a}} + {{a} {i; 2}} \ cdot {{b} _} +} + \ ldots + {{i; n}} \ cdot {n;}} = \ \ & = \ Sum \ limits_ {t = 1} ^ {{{a}} {i; t}} \ cdot {{t; j}}} \ \ end {}}

Standar standar: $ C = A \ CDOT B $.

Menurut saya, semuanya sudah jelas. Selanjutnya Anda tidak bisa membaca. [tidak juga]

Bagi mereka yang pertama kali melihat definisi ini, dua pertanyaan segera muncul:

  1. Apa ini hanya untuk game?
  2. Mengapa begitu sulit?

Nah, tentang segala sesuatu secara berurutan. Mari kita mulai dengan pertanyaan pertama. Apa artinya semua indeks ini? Dan bagaimana tidak membuat kesalahan saat bekerja dengan matriks nyata?

Pertama-tama, kami perhatikan bahwa garis panjang untuk menghitung $ {{c} _ {i; j}} $ (khususnya menempatkan titik dengan titik koma di antara indeks agar tidak bingung, tetapi tidak perlu untuk menempatkan mereka secara umum - saya sendiri sakit mengetik formula dalam definisi) sebenarnya datang ke aturan sederhana:

  1. Kami mengambil $ I $ -un baris di matriks pertama;
  2. Kami mengambil kolom $ J-Sa di matriks kedua;
  3. Kami mendapatkan dua urutan angka. Alternatif item dari urutan ini dengan angka yang sama, dan kemudian lipat karya yang diperoleh.

Proses ini mudah dipahami gambar:

Diagram multiplikasi dari dua matriks

Sekali lagi: Saya memperbaiki garis $ i $ dalam matriks pertama, kolom $ J $ di matriks kedua, ubah elemen dengan angka yang sama, dan kemudian karya yang diperoleh dilipat - kami memperoleh $ {{c} _ { IJ}} $. Dan untuk semua $ 1 \ le i \ le m $ dan $ 1 \ le j \ le k $. Itu. Akan ada total $ m \ kali K $ dari "penyimpangan" seperti itu.

Bahkan, kita sudah bertemu dengan mengalikan matriks dalam program sekolah, hanya dalam bentuk yang sangat dipangkas. Biarkan biarkan vektor:

\ [\ Begin {a} = \ kiri ({} = \ kiri ({x}}}; {{a}}; {{a}} \ kanan); \\ \ overligharrow {B} = \ kiri ({{b} _ {b}}; {{y} _ {b}}; {z}} \ kanan). \\ \ end {align} \]

Kemudian karya skalar mereka akan menjadi jumlah karya berpasangan:

\ [\ overl diRaintarrow {a} \ time \ overligharrow {b} = {a}} \ cdot {{x} _ {b}} + {a} {{{a} \ \ } _ {B}} + {{z} _ {a}} \ cdot {{z} _ {b}} \ \]

Bahkan, pada tahun-tahun yang jauh itu, ketika pohon-pohon itu lebih hijau, dan langit lebih cerah, kami hanya mengalikan $ \ overtrowarrow {a} $ vector ke kolom vektor $ \ b} $ vector.

Hari ini tidak ada yang berubah. Baru saja baris dan kolom ini telah menjadi lebih.

Tapi teori yang cukup! Mari kita lihat contoh-contoh nyata. Dan mulai dari kasing sederhana - matriks persegi.

Mengalikan matriks persegi

Tugas 1. Lakukan perkalian:

\ [\ kiri [\ begin {array} {* {r} {r}} 1 & 2 \\ -3 & 4 \ end {array} \ kanan] \ cdot \ kiri {* {35} {r}} -2 & 4 \\ 3 & 1 \ \ end {array} \ kanan] \]

Larutan. Jadi, kami memiliki dua matriks: $ A = \ kiri [2 \ kali 2 \ kanan] $ dan $ b = \ kiri [2 \ kali 2 \ kanan] $. Jelas bahwa mereka disepakati (matriks persegi dengan ukuran yang sama selalu konsisten). Karena itu, kami melakukan perkalian:

\ [\ Begin {Align} \ \ Left [\ Begin {array} {* {} {r}} 1 & 2 \\ -3 & 4 \ end {array} \ kanan] \ CDot \ {Array} {* {R}} -2 & 4 \\ 3 & 1 \ end {array} \ kanan] = \ kiri [\ begin {array} {r}} 1 \ CDOT \ kiri (-2 \ kanan) +2 \ CDOT 3 & 1 \ CDOT 4 + 2 \ CDOT 1 \\ -3 \ CDOT \ kiri (-2 \ kanan) +4 \ CDOT 3 & -3 \ CDOT 4 + 4 \ CDOT 1 \ end {array} \ kanan] = \\ \ = \ kiri [\ begin {array} {* {r}} 4 & 6 \\ 18 & -8 \\ \ Array} \ kanan]. \ end {align} \]

Itu saja!

Jawaban: $ \ kiri [\ begin {array} {* {{r}} 4 & 6 \\ 18 & -8 \ end {array} \ kanan] $.

Tugas 2. Lakukan perkalian:

\ [\ Kiri [\ Mulai {Matrix} 1 & 3 \\ 2 & 6 \ end {matrix} \ kanan] \ CDOT \ kiri [\ begin {array} {*}} 9 & 6 \ \ -3 & -2 \ \ end {array} \ kanan] \]

Larutan. Lagi-lagi matriks yang disepakati, jadi lakukan tindakan: \ [\]

\ [\ Mulai {align} & \ kiri [\ Begin {Matrix} 1 & 3 \\ 2 & 6 \ end {Matrix} \ Kanan] \ CDot \ kiri [\ begin {array} {* {{{35} {R }} 9 & 6 \\ -3 & -2 \ \ ujung {array} \ kanan] = \ kiri [\ begin {array} {* {r} {r}} 1 \ cdot \ cdot ( -3 \ Kanan) & 1 \ CDOT 6 + 3 \ CDOT \ kiri (-2 \ kanan) \\ 2 \ CDOT 9 + 6 \ CDOT \ kiri (-3 \ kanan) & 2 \ cdot 6 + 6 \ CDot \ Kiri (-2 \ kanan) \ end {array} \ right] = \\ & = \ kiri [\ begin {matrix} 0 & 0 \\ 0 & 0 \ \ \ kanan]. \ end {align} \]

Seperti yang kita lihat, ternyata matriks yang diisi dengan nol

Jawaban: $ \ kiri [\ Begin {Matrix} 0 & 0 \\ 0 \ end {matrix} \ kanan] $.

Dari contoh di atas, jelas bahwa multiplikasi matriks bukanlah operasi yang sulit. Setidaknya untuk matriks persegi ukuran 2 dengan 2.

Dalam proses perhitungan, kami merupakan matriks perantara, di mana langsung dicat, angka apa yang termasuk dalam satu atau sel lain. Ini adalah bagaimana hal itu harus dilakukan ketika menyelesaikan tugas-tugas ini.

Sifat utama dari karya matriks

Pendeknya. Multiplikasi matriks:

  1. NonMutomMutative: $ A \ CDOT B \ NE B \ CDOT A $ Dalam kasus umum. Tentu saja ada matriks khusus yang kesetaraan adalah $ a \ cdot b = b \ cdot A $ = misalnya, jika $ b = E $ adalah matriks tunggal), tetapi dalam banyak kasus itu tidak berfungsi;
  2. Associative: $ \ kiri (A \ CDOT B \ KANAN) \ CDOT C = A \ CDOT \ LEFT (B \ CDOT C \ KANAN) $. Di sini tanpa opsi: berdiri di sebelah matriks dapat dikalikan, tidak bertahan untuk yang berikutnya dan kanan dari dua matriks ini.
  3. Distribusi: $ A \ CDOT \ Kiri (B + C \ Kanan) = A \ CDOT B + A \ CDOT C $ dan $ \ kiri (A + B \ Kanan) \ CDOT C = A \ CDOT C + B \ CDOT C $ (karena nonkommativitas, pekerjaan harus secara terpisah meresepkan distribusi ke kanan dan kiri.

Dan sekarang - semuanya sama, tetapi lebih detail.

Penggandaan matriks sebagian besar mengingatkan pada penggandaan angka klasik. Tetapi ada perbedaan, yang paling penting adalah itu Perkalian matriks, secara umum, tidak bersifat komunutatif .

Pertimbangkan sekali lagi matriks dari tugas 1. Kami sudah tahu pekerjaan langsung mereka:

\ [\ kiri [\ begin {array} {* {r} {r}} 1 & 2 \\ -3 & 4 \ end {array} \ kanan] \ cdot \ kiri {* {35} {r} -2 & 4 \\ 3 & 1 \ \ \ end {array} \ kanan] = \ kiri [\ begin {array} {* {r}} 4 & 6 \\ 18 & -8 \ \ end {array} \ kanan] \]

Tetapi jika Anda mengubah matriks di beberapa tempat, kami akan mendapatkan hasil yang sama sekali berbeda:

\ [\ kiri [\ begin {array} {* {r} {r}} -2 & 4 \\ 3 & 1 \ \ end {array} \ kanan] \ cdot \ kiri [\ \} {* {35} {r}} 1 & 2 \\ -3 & 4 \ Â \ end {array} \ kanan] = \ kiri [\ begin {matrix} -14 & 4 \ Â\ End {Matrix } \ BAIK] \]

Ternyata $ A \ CDOT B \ NE B \ CDOT A $. Selain itu, operasi multiplikasi didefinisikan hanya untuk matriks terkoordinasi $ A = \ kiri [m \ kali n \ kanan] $ dan $ b = \ kiri [n \ waktu k \ kanan] $, tetapi tidak ada yang dijamin akan tetap setuju, jika mereka mengubahnya di beberapa tempat. Misalnya, $ \ matriks kiri [2 kali 3 \ kanan] $ dan $ \ kiri [3 \ kali 5 \ kanan] $ cukup konsisten dalam urutan yang ditentukan, tetapi matriks yang sama $ \ kiri [3 kali 5 \ Kanan] $ dan $ \ kiri [2 \ Times 3 \ kanan] $ direkam dalam urutan terbalik tidak lagi disetujui. Kesedihan. :(

Di antara matriks kuadrat dari ukuran yang ditentukan $ N $ akan selalu menemukan sedemikian rupa sehingga memberikan hasil yang sama ketika mengalikan langsung dan dalam urutan terbalik. Cara menggambarkan semua matriks serupa (dan berapa banyak pada umumnya) adalah topik untuk pelajaran terpisah. Hari ini kita tidak akan membicarakannya. :)

Namun, multiplikasi matriks adalah asosiatif:

\ [\ kiri) \ cdot c = a \ cdot \ kiri (b \ cdot c \ kanan) \]

Oleh karena itu, ketika Anda perlu mengalikan beberapa matriks berturut-turut sekaligus, sangat diperlukan untuk melakukannya dengan air kotor: sangat mungkin bahwa beberapa matriks berdiri di dekatnya memberikan hasil yang menarik. Misalnya, matriks nol, seperti pada tugas 2, dibahas di atas.

Dalam tugas nyata, itu paling sering harus mengalikan matriks kuadrat dari ukuran $ \ kiri [n \ kali n \ kanan] $. Set semua matriks tersebut dilambangkan dengan $ {{m} ^ {n}} $ (yaitu, catatan $ A = \ kiri [n \ kali n \ kanan] $ dan \ [A \ in {{} ^ {n}} \] Berarti sama), dan itu tentu akan menemukan matriks $ E $, yang disebut satu tunggal.

Definisi. Matriks tunggal Jumlah $ N $ adalah matriks $ E $, yang untuk matriks persegi $ A = \ kiri [n \ kali n kanan] $ dilakukan dengan kesetaraan:

\ [A \ CDOT E = E \ CDOT A = A \]

Matriks seperti itu selalu terlihat sama: pada diagonal utama ada unit, dan di semua sel lain - nol.

Kami melangkah lebih jauh. Selain asosiatif, perkalian matriks juga distributif:

\ [\ Begin {Align} & A \ CDot \ Kiri (B + C \ Right) = A \ CDOT B + A \ CDOT C; \\ & \ kiri (A + b \ kanan) \ CDOT C = A \ CDOT C + B \ CDOT C. \ ¡{align} \]

Dengan kata lain, jika Anda perlu mengalikan satu matriks untuk jumlah dua lainnya, Anda dapat mengalikannya ke masing-masing "dua lainnya", dan kemudian lipat hasilnya. Dalam praktiknya, biasanya diperlukan untuk melakukan operasi terbalik: Kami melihat matriks yang sama, kami melaksanakannya untuk braket, kami melakukan penambahan dan dengan demikian menyederhanakan hidup Anda. :)

Catatan: Untuk menggambarkan distribusi, kami harus mendaftarkan dua formula: di mana jumlahnya dalam pengganda kedua dan di mana jumlahnya adalah yang pertama. Ini terjadi karena fakta bahwa perkalian matriks tidak bersifat komunutatif (dan secara umum, dalam aljabar non-komutatif banyak lelucon, yang, ketika bekerja dengan angka biasa, bahkan tidak terlintas dalam pikiran). Dan jika, katakanlah, Anda perlu menulis properti ini pada ujian, maka Anda pasti akan menulis kedua formula, jika tidak, guru bisa sedikit marah.

Oke, semua ini adalah dongeng tentang matriks persegi. Bagaimana dengan persegi panjang?

Kasus matriks persegi panjang

Dan tidak ada yang sama dengan persegi.

Tugas 3. Lakukan perkalian:

\ [\ Kiri [\ Mulai {Matrix} \ Begin {Matrix} 5 \\ 2 \\ 3 \ end {matrix} \ \ begin {matrix} 4 \\ 5 \\ 1 \ \ \ \ \ \ \ \ \ End {matrix} \ right] \ cdot \ kiri [\ begin {array} {* {} {r}} -2 & 5 \\ 3 & 4 \ \ \ kanan] \]

Larutan. Kami memiliki dua matriks: $ A = \ kiri [3 kali 2 \ kanan] $ dan $ b = \ kiri [2 kali 2 \ kanan] $. Kami minum nomor yang menunjukkan dimensi berturut-turut:

\ [3; \ 2; \ 2; \ 2 \]

Seperti yang Anda lihat, dua angka tengah bertepatan. Jadi, matriks disepakati, dan mereka dapat berkembang biak. Dan pada output, kita mendapatkan matriks $ c = \ kiri [3 \ kali 2 \ kanan] $:

\ [\ Mulai {align} & \ kiri [\ Begin {Matrix} \ Begin {Matrix} 5 \\ 2 \\ 3 \\ End {Matrix} \ begin {matrix} 4 \ \ \ \ {Matriks} \\ end {matrix} \ right] \ CDOT \ kiri [\ begin {array} {* {r} {r}}-\\ 3 & 4 \ kanan] = \ kiri [\ begin {array} {* {r} {r}} 5 \ cdot \ kiri (-2 \ kanan) +4 \ cdot 3 & 5 \ cdot 5 + 4 \ cdot 4 \\ 2 \ cdot Kiri (-2 \ kanan) +5 \ CDOT 3 & 2 \ CDOT 5 + 5 \ CDOT 4 \\ 3 \ CDOT \ kiri (-2 \ kanan) +1 \ CDOT 3 & 3 \ CDOT 5 + 1 \ CDOT 4 \ Â {array \ kanan] = \\ \ = \ kiri [\ begin {array} {* {35} {r}} 2 & 41 \\ -3 & 19 \ \ \ Array} \ kanan]. \ end {align} \]

Semuanya jelas: dalam matriks akhir 3 baris dan 2 kolom. Ini cukup $ = \ kiri [3 \ kali 2 \ kanan] $.

Jawaban: $ \ kiri [\ begin {array} {* {35} {r}} \ begin {array} {* {r} {r}} 2 \\ -3 {array} & \\ \ Mulai {matrix} 41 \\ 30 \\ 19 \ \ end {matrix} \\ end {array} \ kanan] $.

Sekarang pertimbangkan salah satu tugas pelatihan terbaik bagi mereka yang baru mulai bekerja dengan matriks. Di dalamnya, perlu untuk tidak mengembalikan beberapa dua tanda, tetapi pertama-tama menentukan apakah multiplikasi seperti itu diizinkan?

Saya sarankan setelah membaca tugas untuk tidak melihat solusinya, tetapi pertama-tama cobalah untuk menampilkannya sendiri. Dan kemudian bandingkan dengan jawabannya.

Tugas 4. Temukan semua pasangan matriks yang mungkin:

\ [A = \ kiri [\ begin {array} {* {r} {r}} \ begin {matrix} 1 \\ 1 \ end {matrix} \ begin {array} {* {35} {r} } -1 \\ 1 \ 'end {array} \ begin {matrix} 2 \\ 2 \ end {matrix} \ begin {array} {* {r}}} \ \} \\ {Array} \\ end {array} \ kanan] \]; $ B = \ kiri [\ Begin {Matrix} \ Begin {Matrix} 0 \\ 2 \\ 0 \\ 4 \ end {Matrix} \ Begin {Matrix} 1 \\ 0 \\ 0 \\ End {matrix} \ end {matrix} \ kanan] $; $ C = \ kiri [\ Begin {Matrix} 0 & 1 \\ 1 & 0 \\ end {matrix} \ kanan] $.

Larutan. Untuk mulai dengan, menulis dimensi dari matriks:

\ [A = \ meninggalkan]; \ b = \ meninggalkan [4 \ kali 2 \ Kanan]; \ C = \ meninggalkan [2 \ kali 2 \ Kanan] \]

Kita memperoleh bahwa $ a $ matriks dapat dikoordinasikan hanya dengan $ b $ matriks, karena jumlah kolom dalam $ $ adalah 4, dan seperti sejumlah baris hanya $ b $. Oleh karena itu, kita dapat menemukan pekerjaan:

\ [A \ cdot b = \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 & 1 & 2 & 2 \\ Akhir {Array} \ Kanan] \ cdot \ meninggalkan [\ begin {array yang} {* {35} {r}} 0 & 1 \\ 2 & 0 \\ 0 & 3 \\ 4 & 0 \\ END {Array} \ Kanan] = \ meninggalkan [\ begin {array yang} {* {35} {r}} - 10 & 7 \\ 10 & 7 \\ End {Array} \ Kanan] \]

Saya mengusulkan langkah-langkah perantara untuk mengeksekusi pembaca pada Anda sendiri. Saya perhatikan hanya itu ukuran matriks yang dihasilkan lebih baik untuk menentukan terlebih dahulu, bahkan sebelum perhitungan:

\ [A \ cdot B = \ Left [2 \ Times bintang 4 \ Kanan] \ cdot \ Left [4 \ kali 2 \ Kanan] = \ meninggalkan [2 \ kali 2 \ Kanan] \]

Dengan kata lain, kita cukup menghapus "transit" koefisien yang menjamin konsistensi matriks.

Apa pilihan lain yang mungkin? Tentu saja, Anda dapat menemukan $ B \ cdot sebuah $, karena $ b = \ meninggalkan [4 \ kali 2 \ Kanan] $, $ a = \ meninggalkan [2 \ Times bintang 4 \ Kanan] $, jadi memerintahkan uap $ \ kiri (b; A \ kanan) $ konsisten, dan dimensi pekerjaan akan:

\ [B \ cdot a = \ meninggalkan [4 \ kali 2 \ Kanan] \ cdot \ Left [2 \ Times bintang 4 \ Kanan] = \ meninggalkan [4 \ Times bintang 4 \ KANAN] \]

Singkatnya, pada output akan ada $ \ matriks kiri [4 \ Times bintang 4 \ Kanan] $, koefisien yang mudah dianggap:

\ [B \ cdot a = \ meninggalkan [\ begin {array yang} {* {35} {r}} 0 & 1 \\ 2 & 0 \\ 0 & 3 \\ 4 & 0 \\ End {Array} \ Kanan ] \ cdot \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 & 1 & 2 & 2 \\ END {Array \ Kanan] = \ meninggalkan [\ begin {array yang} {* {35} { R}} 1 & 1 & 2 & 2 \\ 2 & 3 & 4 & 6 \\ 3 & 3 & 6 & 6 \\ 4 & -4 & 8 & -8 \\\ End {Array} \ Kanan] \ ]

Jelas, Anda dapat menyetujui lain $ C \ cdot A $ dan $ B \ cdot C $ - dan hanya itu. Oleh karena itu, kami hanya menulis karya-karya yang diperoleh:

\ [C \ cdot a = \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 & 1 & 2 & 2 \\ 1 & -1 & 2 & -2 \\\ End {Array} \ BAIK] \]

\ [B \ cdot c = \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 & 0 \\ 0 & 2 \\ 3 & 0 \\ 0 & 4 \\ Akhir {Array} \ KANAN ] \]

Itu mudah.:)

Jawaban: $ AB = \ meninggalkan [\ begin {array yang} {* {35} {R}} --10 & 7 \\ 10 & 7 \\\ End {Array} \ Kanan] $; $ Ba = \ meninggalkan [\ begin {array yang} {* {35} {R}} 1 & 1 & 2 & 2 \\ 2 & 3 & 4 & 6 \\ 2 & 3 & 6 & 6 \\ 4 & - 4 & 8 & -8 \\\ End {Array} \ Kanan] $; $ Ca = \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 & 1 & 2 & 2 \\ 1 & -1 & 2 & -2 \\ END {Array} \ Kanan] $; $ Bc = \ meninggalkan [\ begin {array yang} {* {35} {R}} 1 & 0 \\ 0 & 2 \\ 3 & 0 \\ 0 & 4 \\\ Akhir {Array} \ Kanan] $.

Secara umum, saya sangat merekomendasikan melakukan tugas ini sendiri. Dan salah satu tugas yang lebih mirip yang ada di pekerjaan rumah Anda. Ini pemikiran sederhana akan membantu Anda bekerja keluar semua tahap kunci dari perkalian matriks.

Tapi cerita ini tidak berakhir. Pergi ke kasus khusus dari perkalian. :)

string vektor dan kolom vektor

Salah satu yang paling operasi matriks umum adalah perkalian pada matriks di mana satu baris atau satu kolom.

Definisi. Vektor-kolom - Ini adalah matriks $ \ left [M \ Times, 1 \ kanan] $, yaitu yang terdiri dari beberapa baris dan hanya satu kolom.

vektor string yang - Ini adalah matriks $ \ left [1 \ Kali N \ Kanan] $, yaitu terdiri dari satu baris dan beberapa kolom.

Bahkan, kami sudah bertemu dengan benda-benda ini. Sebagai contoh, biasa vektor tiga dimensi stereometry $ \ overrightarrow {a} = \ left (x; y; z \ right) $ hanyalah string vektor. Dari sudut pandang teori perbedaan antara baris dan kolom, hampir tidak ada. Hal ini diperlukan untuk menjadi perhatian berada di setuju dengan faktor matriks sekitarnya.

Tugas 5. Lakukan perkalian:

\ [\ Meninggalkan [\ begin {array yang} {* {35} {R}} 2 & -1 & 3 \\ 4 & 2 & 0 \\ -1 & 1 & 1 \\ END {Array} \ Kanan] \ cdot \ meninggalkan [\ begin {array yang} {* {35} {r}} 1 \\ 2 \\ -1 \\\ End {Array} \ Kanan] \]

Larutan. Sebelum kita, karya matriks setuju: $ \ meninggalkan [3 \ Kali 3 \ Kanan] \ cdot \ Left [3 \ Kali 1 \ Kanan] = \ meninggalkan [3 \ Kali 1 \ kanan] $. Cari pekerjaan ini:

\ [\ Meninggalkan [\ begin {array yang} {* {35} {R}} 2 & -1 & 3 \\ 4 & 2 & 0 \\ -1 & 1 & 1 \\ END {Array} \ Kanan] \ cdot \ kIRI [\ begin {array yang} {* {35} {R}} 1 \\ 2 \\ -1 \\\ End {Array} \ Kanan] = \ meninggalkan [\ begin {array yang} {* {35} {R}} 2 \ cdot 1+ \ Left (-1 \ kanan) \ cdot 2 + 3 \ cdot \ KIRI (-1 \ KANAN) \\ 4 \ cdot 1 + 2 \ cdot 2 + 0 \ cdot 2 \ \ 1 \ cdot 1 + 1 \ cdot 2 + 1 \ cdot \ kIRI (-1 \ KANAN) \\\ End {Array} \ Kanan] = \ meninggalkan [\ begin {array yang} {* {35} {R}} - 3 \\ 8 \\ 0 \\ End {Array} \ Kanan] \]

Jawaban: $ \ meninggalkan [\ begin {array yang} {* {35} {R}} - 3 \\ 8 \\ 0 \\\ End {Array} \ Kanan] $.

Tugas 6. Lakukan perkalian:

\ [\ Meninggalkan [\ begin {array yang} {* {35} {R}} 1 & 2 \ 3}} 1 & 2 \ KANAN] \ cdot \ KIRI [\ begin {array yang} {* {35} {R} } 3 & 1 & -1 \\ 4 & -1 & 3 \\ 2 & 6 & 0 \\ End {Array} \ Kanan] \]

Larutan. Sekali lagi, semuanya konsisten: $ \ meninggalkan [1 \ Times, 3 \ Kanan] \ cdot \ Left [3 \ Kali 3 \ Kanan] = \ meninggalkan [1 \ Times, 3 \ Kanan] $. Kami menganggap pekerjaan:

\ [\ Meninggalkan [\ begin {array yang} {* {35} {R}} 1 & 2 \ 3}} 1 & 2 \ KANAN] \ cdot \ KIRI [\ begin {array yang} {* {35} {R} } 3 & 1 & -1 \\ 4 & -1 & 3 \\ 2 & 6 & 0 \\ END {Array} \ Kanan] = \ Left [\ begin {Array} {* {35} {R}} 5 & -19 & 5 \\ End {Array} \ Kanan] \]

Bahkan, saya berada di memo menghitung semua tiga nomor tersebut - hitung sendiri. Dan saya hanya menuliskan jawabannya. :)

Jawaban: $ \ meninggalkan [\ begin {Matrix} 5 & -19 & 5 \\\ END {Matrix} \ Kanan] $.

Seperti yang Anda lihat, ketika Anda kalikan string vektor dan vektor kolom pada matriks persegi pada output, kami selalu mendapatkan string atau kolom dengan ukuran yang sama. Fakta ini memiliki banyak aplikasi - dari memecahkan persamaan linier untuk semua jenis transformasi koordinat (yang, sebagai hasilnya, juga mengurangi sistem persamaan, tapi jangan menjadi sekitar sedih).

Saya pikir semuanya jelas di sini. Pergi ke bagian akhir dari pelajaran hari ini.

Pembangunan matriks untuk tingkat

Di antara semua operasi mengalikan perhatian tertentu, yang dibangkitkan untuk gelar - ini adalah ketika kita kalikan objek yang sama pada diri mereka sendiri beberapa kali. Matriks tidak terkecuali, mereka juga dapat didirikan untuk berbagai derajat.

karya-karya tersebut selalu setuju:

\ [A \ cdot a = \ meninggalkan [n \ kali n \ right] \ cdot \ meninggalkan [n \ kali n \ right] = \ meninggalkan [n \ kali n \ right] \]

Dan menunjukkan persis sama dengan derajat biasa:

\ [\ Begin {menyelaraskan} & a \ cdot a = {{a} ^ {2}}; \\ & a \ cdot a \ cdot a = {{a} ^ {3}}; \\ & \ underbrace {a \ cdot a \ cdot \ ldots \ cdot sebuah} _ {n} = {{a} ^ {n}}. \\ \ End {Align} \]

Pada pandangan pertama, semuanya sederhana. Mari kita melihat tampilannya dalam praktek:

Tugas 7. Eduge matriks untuk tingkat tertentu:

$ {{\ Meninggalkan [\ begin {matrix} 1 & 1 \\ 0 & 1 \\ END {MATRIX} \ KANAN]} ^ {3}} $

Larutan. Nah, mari kita tegak ini. Pertama, erend di persegi:

\ [\ Begin {menyelaraskan} {{\ meninggalkan [\ begin {matrix} 1 & 1 \\ 0 & 1 \\ END {MATRIX} \ KANAN]} ^ {2}} = \ Left [\ begin {Matrix} 1 & 1 \\ 0 & 1 \\ END {MATRIX} \ KANAN] \ cdot \ kIRI [\ begin {Matrix} 1 & 1 \\ 0 & 1 \\ END {MATRIX} \ KANAN] = \\ \ \ kiri [ \ begin {array yang} {* {35} {r}} 1 \ cdot 1 + 1 \ cdot 0 & 1 \ cdot 1 + 1 \ cdot 1 \\ 0 \ cdot 1 + 1 \ cdot 0 & 0 \ cdot 1 + 1 \ cdot 1 \\\ Akhir {Array} \ Kanan] = \\ \ = \ meninggalkan [\ begin {array yang} {* {35} {R}} 1 & 2 \\ 0 & 1 \ \\ Akhir {Array } \ Kanan] \ End {Align} \]

\ [\ Begin {align} {{\ begin [\ begin [\ begin {matrix} 1 & 1 \\ 0 & 1 \ end {matrix} \ right]} ^ {{{\ begin {matriks } 1 & 1 \\ 0 & 1 \ end {matriks} \ kanan]} ^ {3}} \ cdot \ kiri [\ begin {matrix} 1 & 1 \\ 0 & 1 \ \ \ \ Kanan] = \\ \ = \ kiri [\ Begin {array} {* {r} {r}} 1 & 2 \\ 0 & 1 \ end {array} \ kanan] \ cdot {matriks } 1 & 1 \\ 0 & 1 \ end {matrix} \ kanan] = \\ \ = \ kiri [\ begin {array} {* {r}} 1 & 3 \\ 0 & 1 \\ Ujung {array} \ kanan] \ end {align} \]

Itu saja.:)

Jawaban: $ \ kiri [\ begin {matrix} 1 & 3 \\ 0 & 1 \ end {matrix} \ kanan] $.

TUGAS 8. Eduge Matriks ke tingkat yang ditentukan:

\ [{{\ kiri [\ Begin {Matrix} 1 & 1 \\ 0 & 1 \ end {matrix} \ kanan]} ^ {10}} \]

Larutan. Tetapi tidak perlu menangis pada kenyataan bahwa "derajat terlalu besar", "dunia tidak adil" dan "ajaran yang benar-benar hilang." Bahkan, semuanya mudah:

\ [\ begin {align} {{\ kiri [\ Mulai {Matrix} 1 & 1 \\ 0 & 1 \ end {matriks} \ kanan]} ^ {{{\ begin {Matrix } 1 & 1 \\ 0 & 1 \ end {matrix} \ kanan]} ^ {3}} \ cdot {{begin [\ begin {matrix} 1 & 1 \\ 0 & 1 \ Mulai {Matrix } \ Kanan]} ^ {3}} \ cdot {{\ begin [\ begin {matrix} 1 & 1 \\ 0 & 1 \ end {matriks} \ kanan]} ^ {cdot \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \} \ Mulai {Matrix} 1 & 1 \\ 0 & 1 \ end {matrix} \ kanan] = \\ & = \ kiri (\ kiri [\ Mulai {Matrix} 1 & 3 \\ 0 & 1 \\ {Matrix} \ Kanan] \ CDOT \ Kiri [\ Begin {Matrix} 1 & 3 \\ 0 & 1 \ end {matrix} \ kanan] \ kanan) \ CDOT \ kiri (\ begin {matrix} 1 & 3 \\ 0 & 1 \ end {matrix} \ kanan] \ CDOT \ kiri [\ begin {matrix} 1 & 1 \\ 0 & 1 \ \ \ KANAN] \ KANAN] = \ kiri [\ begin {matrix} 1 & 6 \\ 0 & 1 \ end {matrix} \ kanan] \ CDOT \ kiri [\ begin {matrix} 1 & 4 \\ 0 & 1 \\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Mulai} \ Kanan] = \\ & = \ kiri [\ Begin {Matrix} 1 & 10 \\ 0 & 1 \ end {matrix} \ kanan] \ end {aliign} \]

Catatan: Di baris kedua, kami menggunakan asosiatif multiplikasi. Sebenarnya, kami menggunakannya dalam tugas sebelumnya, tetapi di sana secara implisit.

Jawaban: $ \ kiri [\ Begin {Matrix} 1 & 10 \\ 0 & 1 \ \ end {matrix} \ kanan] $.

Seperti yang Anda lihat, tidak ada yang rumit dalam pembangunan matriks hingga tingkat tersebut. Contoh terakhir dapat digeneralisasi:

\ [{{\ kiri [\ Mulai {Matrix} 1 & 1 \\ 0 & 1 \ end {matrix} \ kanan]} ^ {n}} = \ kiri [\ begin {* {35} { R}} 1 & n \\ 0 & 1 \ \ end {array} \ kanan] \]

Fakta ini mudah dibuktikan melalui induksi matematika atau multiplikasi langsung. Namun, tidak selalu ketika gelar dapat ditangkap oleh pola tersebut. Oleh karena itu, penuh perhatian: seringkali gandakan beberapa matriks "stroy" ternyata lebih mudah dan lebih cepat daripada mencari beberapa pola reguler.

Secara umum, jangan mencari makna tertinggi di mana bukan. Kesimpulannya, pertimbangkan pembangunan matriks yang lebih besar - alternatifnya $ \ kiri [3 kali 3 \ kanan] $.

TUGAS 9. Eduge matriks ke tingkat yang ditentukan:

\ [{{\ left [\ begin {matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan]} ^ {3 &]

Larutan. Tidak akan mencari keteraturan. Kami bekerja "Stroy":

\ [{{\ kiri [\ Mulai {Matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan]} ^ {{\ Kiri [\ Begin {Matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan]} ^ {2}} \ cdot {matriks } 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan] \]

Untuk memulai, ereksi matriks ini di kotak:

\ [\ Begin {align} {{\ begtunya [\ begin {matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matriks} \ ^ {2} } = \ Kiri [\ Begin {Matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan] \ CDOT \ kiri [\ Mulai {Matrix} 0 & 1 \ 1 \ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan] = \\ & = \ kiri [\ begin {array} {*}} 2 & 1 & 1 \\ 1 & 2 & 1 \\ 1 & 1 & 2 \ \ end {array} \ kanan] \ end {align} \]

Sekarang didirikan ke dalam kubus:

\ [\ Begin {align} {{\ begin [\ begin [\ begin {matriks} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ {3} } = \ kiri [\ begin {array} {* {} {r}} 2 & 1 & 1 \\ 1 & 2 & 1 \\ 1 & 1 & 2 \ \ \ kanan] \ CDOT \ Kiri [\ Begin {Matrix} 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \ end {matrix} \ kanan] = \\ & = \ kiri [\ begin} {* {35} {R}} 2 & 3 & 3 \\ 3 & 2 & 3 \\ 3 & 3 & 2 \ end {array} \ kanan] \ end {align} \]

Itu saja. Tugas diselesaikan.

Jawaban: $ \ kiri [\ Begin {Matrix} 2 & 3 & 3 \\ 3 & 2 & 3 \\ 3 & 3 & 2 \ end {matrix} \ kanan] $.

Seperti yang Anda lihat, volume komputasi telah menjadi lebih, tetapi makna dari ini tidak berubah dari ini. :)

Pada pelajaran ini dapat diselesaikan. Lain kali kita akan melihat operasi terbalik: sesuai dengan pekerjaan yang ada kita akan mencari faktor-faktor asli.

Sama seperti Anda, mungkin sudah menebak, itu akan tentang matriks kembali dan metode lokasinya.

Lihat juga:

  1. Determinan
  2. Matriks terbalik.
  3. Uji coba EGE-2011 dalam Matematika, Opsi Nomor 8
  4. Area lingkaran
  5. Cara menghitung logaritma bahkan lebih cepat
  6. Websinar pada Tugas 13: Trigonometri

Tindakan dengan matriks.

Manual metodologis ini akan membantu Anda belajar melakukan Tindakan dengan matriks. : Penambahan (pengurangan) matriks, transpose matriks, perkalian matriks, menemukan matriks terbalik. Semua bahan diatur dalam bentuk yang sederhana dan mudah diakses, contoh yang sesuai diberikan, sehingga bahkan orang yang tidak siap akan dapat belajar melakukan tindakan dengan matriks.

Untuk kontrol diri dan tes mandiri Anda dapat mengunduh kalkulator matriks secara gratis >>>. Saya akan mencoba meminimalkan perhitungan teoretis, di beberapa tempat, penjelasan "pada jari" dan penggunaan istilah yang tidak ilmiah. Pecinta teori yang solid, tolong jangan mengkritik, tugas kami adalah .

Belajarlah untuk melakukan tindakan dengan matriks Untuk persiapan ultra-cepat pada topik (yang memiliki "membakar") ada kursus PDF yang intens

Matriks, penentu dan berdiri!

Ayo mulai. Matriks adalah tabel persegi panjang dari apa pun Elemen. Matriks adalah tabel persegi panjang dari apa pun . Sebagai Kami akan mempertimbangkan angka, yaitu, matriks numerik. ELEMEN

- Ini istilahnya. Istilah ini disarankan untuk diingat, itu akan sering bertemu, bukan secara kebetulan saya menggunakan font lemak untuk menyorotnya. Penamaan:

Matriks biasanya ditandai dengan huruf Latin Capital Contoh:

Pertimbangkan matriks "dua tiga": Matriks adalah tabel persegi panjang dari apa pun :Matriks ini terdiri dari enam Semua angka (elemen) di dalam matriks ada dalam diri mereka sendiri, yaitu, tidak ada pengurangan pidato tidak pergi:

Itu hanya nomor meja (set)! Juga setuju Jangan mengatur ulang

Angka, kecuali disebutkan sebaliknya. Setiap angka memiliki lokasinya sendiri, dan mereka tidak dapat ditarik keluar! Matriks yang dipertimbangkan memiliki dua baris:

Dan tiga kolom: STANDAR : Ketika mereka berbicara tentang ukuran matriks, maka pertama

Tunjukkan jumlah baris, dan hanya kemudian - jumlah kolom. Kami baru saja membongkar tulang dari matriks "dua tiga". Jika jumlah baris dan kolom matriks bertepatan, maka matriks disebut Kotak , Sebagai contoh:

- Matrix "Tiga Tiga". Jika dalam matriks satu kolom atau satu baris , maka matriks seperti itu juga disebut .

vektor. Bahkan, konsep matriks, kita tahu sejak sekolah, pertimbangkan, misalnya, titik dengan koordinat "x" dan "igrek": . Pada dasarnya, koordinat titik  и Dikunci dalam matriks "satu-dua". Ngomong-ngomong, inilah contohnya, mengapa urutan angka penting:

- Ini adalah dua titik yang sama sekali berbeda dari pesawat. Sekarang pergi langsung ke penelitian :

Tindakan dengan matriks. .

1) tindakan pertama. Mencapai minus dari matriks (membuat minus dalam matriks) Kembali ke matriks kami

. Seperti yang mungkin Anda perhatikan, ada terlalu banyak angka negatif dalam matriks ini. Sangat tidak nyaman dalam hal melakukan berbagai tindakan dengan matriks, tidak nyaman untuk menulis sebanyak minus, dan hanya terlihat jelek dalam desain. :Saya akan membuat minus di luar matriks, mengubah setiap elemen tanda matriks

Ulya, seperti yang Anda pahami, tanda itu tidak berubah, nol - dia dan di Afrika nol. Contoh Umpan:

. Terlihat jelek. :

Kami akan membuat minus dalam matriks, mengubah matriks setiap elemen Yah, ternyata jauh lebih cantik. Dan, yang paling penting, lakukan tindakan apa pun dengan matriks akan lebih mudah. Karena ada tanda rakyat matematika: .

semakin banyak minus - semakin banyak kebingungan dan kesalahan 2) .

Matriks biasanya ditandai dengan huruf Latin Capital

Tindakan kedua. Perkalian matriks ke nomor Semuanya sederhana untuk mengalikan matriks pada nomornya, yang Anda butuhkan setiap orang

Elemen matriks berkembang biak pada nomor yang diberikan. Dalam hal ini, pada tiga teratas.

Contoh lain yang berguna:

- Pergandaan matriks untuk fraksi Pertimbangkan dulu apa yang harus dilakukan :TIDAK DIBUTUHKAN Anda tidak perlu memasukkan matriks, pertama, hanya membuat tindakan lebih lanjut dengan matriks, kedua, itu membuatnya sulit untuk memeriksa keputusan oleh guru (terutama jika

- Jawaban Jawaban Akhir). Pertimbangkan dulu apa yang harus dilakukan Dan terutama,

Bagikan setiap elemen matriks untuk minus tujuh: Dari artikel Matematika untuk boneka atau mulai memulai

Kita ingat bahwa fraksi desimal dengan koma pada matematika yang lebih tinggi berusaha untuk menghindari segala cara. Satu-satunya hal itu diinginkan

Buat dalam contoh ini - untuk membuat minus dalam matriks: Tapi jika SEMUA Unsur-unsur matriks dibagi menjadi 7 tanpa residu.

Matriks biasanya ditandai dengan huruf Latin Capital

Maka Anda dapat (dan Anda perlu!) Itu akan dibagi. Dalam hal ini, Anda bisa dan DIPERLUKAN Lipat gandakan semua elemen matriks pada Karena semua jumlah matriks dibagi menjadi 2 .

tanpa residu.

Catatan: Dalam teori matematika yang lebih tinggi, konsep sekolah "Divisi" tidak. Alih-alih frasa "ini dibagi menjadi" selalu bisa dikatakan "kalikan oleh fraksi." Artinya, Divisi adalah kasus khusus multiplikasi. .

3) tindakan ketiga. Transposisi matriks.

Matriks biasanya ditandai dengan huruf Latin Capital

Untuk mengubah matriks, Anda perlu menuliskan garis-garisnya ke kolom matriks transposis.

Transpos matriks.

Garis di sini hanya satu dan, sesuai dengan aturan, perlu ditulis ke kolom:

- Matriks transposis. Matriks transposis biasanya dilambangkan dengan indeks yang tiba-tiba.

atau menyentuh tepat di atas.

Untuk mengubah matriks, Anda perlu menuliskan garis-garisnya ke kolom matriks transposis.

Langkah demi langkah contoh:

Pertama, tulis ulang string pertama ke kolom pertama:

Kemudian tulis ulang string kedua di kolom kedua:

Dan akhirnya, tulis ulang string ketiga di kolom ketiga:

Siap. Secara kiasan, transpos - itu berarti mengambil matriks untuk sudut kanan atas dan mengubahnya dengan lembut "pada diri sendiri" secara diagonal, "mengguncang" angka ke dalam kolom matriks transposis. Seperti di sini saya memiliki asosiasi. .

4) tindakan keempat. Jumlah (perbedaan) matriks

Jumlah aksi matriks sederhana.

Matriks biasanya ditandai dengan huruf Latin Capital

Tidak semua matriks dapat dilipat. Untuk melakukan penambahan matriks (mengurangi), perlu ukurannya sama.  и

Misalnya, jika matriks "dua hingga dua" diberikan, maka itu hanya dapat dilipat dengan matriks "dua dua" dan tidak ada yang lain! :

Lipat matriks Untuk melipat matriks, perlu untuk melipat elemen-elemen yang sesuai. .

Matriks biasanya ditandai dengan huruf Latin Capital

Untuk perbedaan matriks, aturannya serupa ,

Perlu untuk menemukan perbedaan antara elemen yang sesuai. :

 

Temukan matriks bedanya

Dan bagaimana cara mengatasi contoh ini lebih mudah untuk tidak bingung? Dianjurkan untuk menyingkirkan minus tambahan, untuk ini kita akan membuat minus dalam matriks .

Catatan: Dalam teori matematika yang lebih tinggi, konsep sekolah "pengurangan" tidak. Alih-alih frasa "dari ini, selalu mungkin untuk mengatakan" untuk ini menambahkan angka negatif. " Artinya, pengurangan adalah kasus khusus.

5) Aksi kelima. Multiplikasi Matriks.

Semakin jauh di hutan, partisan yang lebih tebal. Saya akan mengatakan segera, aturan multiplikasi matriks terlihat sangat aneh, dan tidak begitu sederhana untuk menjelaskannya, tetapi saya masih mencoba melakukan ini menggunakan contoh-contoh spesifik. Matriks apa yang bisa dikalikan? Ke matriks bisa dikalikan dengan matriks diperlukan, .

Ke jumlah kolom matriks sama dengan jumlah baris matriks Contoh: ?

Apakah mungkin untuk melipatgandakan matriks

pada matriks

Jadi, gandakan data matriks bisa.

Tetapi jika matriks mengatur ulang di beberapa tempat, maka, dalam hal ini, multiplikasi tidak lagi mungkin!

Oleh karena itu, perkalian tidak mungkin:  и Tidak begitu jarang, tugas ditemui ketika siswa diusulkan untuk melipatgandakan matriks, yang perkaliannya jelas tidak mungkin. Perlu dicatat bahwa dalam beberapa kasus Anda dapat mengalikan matriks dan begitu, dan seterusnya.

Misalnya, untuk matriks,

Mungkin bagaimana multiplikasi

dan multiplikasi.

Matriks biasanya ditandai dengan huruf Latin Capital

Bagaimana cara mengalikan matriks? Contoh: Penggandaan matriks lebih baik dijelaskan pada contoh spesifik, karena definisi ketat akan bingung (atau pemanggilan) sebagian besar pembaca.

Mari kita mulai dengan yang paling sederhana:

Multiply Matrix.

Bagaimana cara mengalikan matriks? Contoh:

Saya akan segera memberikan formula untuk setiap kasus:

- Cobalah segera tangkap pola.

Contohnya lebih sulit: Rumus: Akibatnya, matriks nol yang disebut diperoleh.

Cobalah untuk melakukan multiplikasi (jawaban yang benar

). Perhatikan bahwa

! Hampir selalu begitu! Contoh: Jadi,

Saat mengalikan matriks tidak dapat diatur ulang!

Bagaimana cara mengalikan matriks? Contoh:

Jika tugas diusulkan untuk melipatgandakan matriks

, Saya perlu kalikan dalam urutan ini. Tidak pernah sebaliknya.

Pergi ke matriks orde ketiga: Contoh:

Formula ini sangat mirip dengan formula sebelumnya:

Sekarang cobalah untuk mengetahuinya dalam penggandaan matriks berikut: .

Lipat gandakan matriks

Berikut ini adalah solusi yang sudah jadi, tetapi cobalah untuk tidak melihatnya terlebih dahulu!

6) tindakan keenam. Menemukan matriks kembali

Topik ini cukup luas, dan saya membuat item ini di halaman terpisah.

Sementara itu, kinerja selesai.

 Algoritma untuk multix multiplikasi memungkinkan Anda untuk secara efektif menggunakan sumber daya prosesor modern. Tetapi dengan jelas menunjukkan bahwa pemanfaatan maksimum sumber daya prosesor modern jauh dari tugas nontrivial. Pendekatan menggunakan microerler dan lokalisasi data maksimum dalam cache prosesor dapat berhasil digunakan untuk algoritma lain.

Setelah menguasai level entri, saya sarankan bekerja dengan matriks pada pelajaran sifat-sifat operasi pada matriks. Ekspresi matriks.

Semoga Anda beruntung!

Diposting oleh: Emelin Alexander

Matematika tertinggi untuk kelainan dan tidak hanya >>>

(Pergi ke halaman utama)

Bagaimana Anda bisa berterima kasih kepada penulis?

"Semuanya berlalu!" - Bantuan layanan online kepada siswa

pengantar

Multiplikasi matriks adalah salah satu algoritma dasar, yang banyak digunakan dalam berbagai metode numerik, dan khususnya dalam algoritma pembelajaran mesin. Banyak implementasi perambatan sinyal langsung dan terbalik dalam lapisan konvolusional jaringan strata didasarkan pada operasi ini. Jadi terkadang hingga 90-95% dari total waktu yang dihabiskan untuk pembelajaran mesin, ini untuk operasi ini. Mengapa ini terjadi? Jawabannya terletak pada implementasi algoritma ini yang sangat efektif untuk prosesor, akselerator grafis (dan belakangan ini dan akselerator spesial perkalian matriks). Multiplikasi matriks adalah salah satu dari sedikit algoritma yang memungkinkan untuk secara efektif menggunakan semua sumber daya komputasi prosesor dan akselerator grafis modern. Oleh karena itu, tidak mengherankan bahwa banyak algoritma yang mencoba mengurangi ke perkalian matriks - biaya tambahan yang terkait dengan persiapan data biasanya terbayar secara akurat dengan akselerasi total algoritma.

Jadi bagaimana algoritma perkalian matriks? Meskipun sekarang ada banyak implementasi algoritma ini, termasuk dalam kode open source. Namun sayangnya, kode implementasi ini (sebagian besar pada assembler) sangat kompleks. Ada artikel berbahasa Inggris yang baik.

, menggambarkan algoritma ini secara rinci. Yang mengejutkan saya, saya tidak menemukan analog di Habré. Adapun saya, alasan ini cukup untuk menulis artikelnya sendiri. Untuk membatasi jumlah presentasi, saya membatasi deskripsi algoritma berulir tunggal untuk prosesor konvensional. Topik multithreading dan algoritma untuk akselerator grafis jelas layak mendapatkan artikel terpisah.

Proses presentasi akan dilakukan oleh langkah-langkah VVID dengan contoh-contoh tentang akselerasi algoritma yang konsisten. Saya mencoba menulis tugas yang paling menyederhanakan, tetapi tidak ada lagi. Saya harap saya lakukan ... 

Pernyataan Masalah (Langkah ke-0) ASecara umum, fungsi multiplikasi matriks digambarkan sebagai: BC [i, j] = a * c [i, j] + b * jumlah (a [i, k] * b [k, j]); CDi mana matriksnya

Ini memiliki ukuran m x k, matriks

- k x n, dan matriks 

- m x n.

Kami tanpa mengurangi presentasi, kami dapat mengasumsikan bahwa A = 0 dan B = 1: 

C [i, j] = jumlah (a [i, k] * b [k, j]);

Implementasinya pada C ++ "di dahi" pada formula akan terlihat seperti ini:

Void gemm_v0 (int m, int n, int k, const float * a, const float * b, float * c) {untuk (int i = 0; i <m; + i) {untuk (untuk (int j = 0; j <n; ++ j) {c [i * n + j] = 0; untuk (int k = 0; k <k; ++ k) c [i * n + j] + = a [i * k + k] * b [k * n + j]; }}}

  1. Akan bodoh untuk mengharapkan produktivitas apa pun darinya, dan benar-benar pengukuran tes menunjukkan bahwa pada (m = n = k = 1152) dibutuhkan hampir 1,8 detik (mesin uji - [email protected], OS - Ubuntu 16.04.6 , Kompiler - G ++ - 6.5.0b Opsi kompiler - "-fpic -O3 -March = Haswell"). Jumlah minimum operasi untuk multiplikasi matriks adalah 2 * m * n * k = 2 * 10 ^ 9. Berbicara lainnya, kinerja adalah 1,6 gflops, yang sangat jauh dari batas teoritis kinerja berulir tunggal untuk prosesor ini (~ 120 gflops (float-32) jika terbatas pada penggunaan AVX2 / FMA dan ~ 200 gflops saat menggunakan AVX-512) . Jadi apa yang perlu diambil untuk mendekati batas teoretis? Selanjutnya, dalam beberapa optimasi berturut-turut, kami akan mencapai solusi yang sebagian besar mereproduksi apa yang digunakan di banyak perpustakaan standar. Dalam proses pengoptimalan, saya hanya akan menggunakan AVX2 / FMA, AVX-512 saya tidak akan khawatir, karena pemotongan mereka masih kecil.
  2. Hilangkan kekurangan yang jelas (langkah pertama) BPertama, hilangkan kekurangan algoritma yang paling jelas:
Perhitungan alamat elemen array dapat disederhanakan - untuk membuat porsi permanen dari siklus internal. 

Dalam versi asli, akses ke elemen array

Itu tidak secara berurutan. Ini dapat dirampingkan jika Anda mengubah urutan perhitungan sedemikian rupa sehingga siklus internal adalah bypass berurutan demi baris untuk ketiga matriks.

Void gemm_v1 (int m, int n, int k, const float * a, const float * b, float * c) {untuk (int i = 0; i <m; {float * c = c + i) * N; untuk (int j = 0; j <n; ++ j) c [j] = 0; untuk (int k = 0; k <k; ++ k) {const float * b + k * n; Float a = a [i * k + k]; untuk (int j = 0; j <n; ++ j) c [j] + = a * b [j]; }}}

Hasil pengukuran tes menunjukkan waktu eksekusi pada 250 ms, atau 11,4 gflops. Itu. Kami mendapat akselerasi 8 kali dengan suntingan kecil seperti itu! 

Vektorisasi siklus batin (langkah ke-2)

  1. Jika Anda hati-hati melihat siklus dalam (sesuai dengan variabel J), dapat dilihat bahwa perhitungan dapat dilakukan oleh blok (vektor). Hampir semua prosesor modern memungkinkan perhitungan di atas vektor tersebut. Secara khusus, set instruksi AVX beroperasi dengan vektor 256 bit. Yang memungkinkan Anda melakukan 8 operasi untuk bilangan real dengan akurasi tunggal untuk kebijaksanaan. AVX2 / FMA membuat satu langkah lagi - memungkinkan Anda untuk melakukan pengoperasian penggandaan dan penambahan fusi (d = a * b + c) di atas vektor. Prosesor Intel Desktop mulai dari generasi ke-4 memiliki 2 modul FMA 256-bit, yang memungkinkan mereka untuk secara teoritis melakukan 2 * 2 * 8 = 32 operasi (float-32) per bijaksana. Untungnya, instruksi AVX2 / FMA cukup mudah digunakan langsung dari C / C ++ menggunakan fungsi tertanam (intrinsik). Untuk AVX2 / FMA, mereka dinyatakan dalam file header <immintrin.h>.
  2. Void gemm_v2 (int m, int n, int k, float const * a, const float * b, float * c) {untuk (int i = 0; i <m; {float * c = c + i) * N; untuk (int j = 0; j <n; j + = 8) _mm256_storeu_ps (c + j + 0, _mm256_setzero_ps ()); untuk (int k = 0; k <k; ++ k) {const float * b + k * n; __m256_set1_ps (A [I * K + K]); Untuk (int j = 0; j <n; j + = 16) {_mm256_storeu_ps (c + j + 0, _mm256_fmadd_ps (a, _mm256_loadu_ps (b + j + 0), _mm256_loadu_ps (C + J + 0))); _mm256_storeu_ps (c + j + 8, _mm256_fmadd_ps (a, _mm256_loadu_ps (b + j + 8), _mm256_loadu_ps (C + J + 8))); }}}}

Jalankan tes, dapatkan waktu 217 ms atau 13.1 gflops. Ups! Akselerasi hanya 15%. Bagaimana? Di sini Anda perlu memperhitungkan dua faktor:

Kompiler sekarang pintar pergi (tidak semua!), Dan sepenuhnya mengatasi tugas autoctorisasi siklus sederhana. Sudah dalam versi 1, kompiler sebenarnya melibatkan instruksi AVX2 / FMA, karena optimasi manual tidak memberi kita hampir tidak ada keuntungan.

Tingkat perhitungan dalam hal ini tidak terletak pada kemampuan komputasi prosesor, tetapi dalam kecepatan pengunduhan dan pembuangan data. Dalam hal ini, prosesor untuk aktivasi 2 blok FMA 256-bit diperlukan untuk mengunduh 4 dan menurunkan 2 256-bit vektor per bijaksana. Ini dua kali lipat dari bandwidth L1 dari cache prosesor (512/256 bit), belum lagi bandwidth memori, yang merupakan urutan besarnya kurang (64-bit per saluran)).

Jadi, masalah utama dalam bandwidth memori terbatas dalam prosesor modern. Prosesor sebenarnya menganggur 90% dari waktu, mengharapkan ketika data dimuat dan disimpan dalam memori.

Langkah-langkah lebih lanjut untuk mengoptimalkan algoritma akan ditujukan untuk meminimalkan akses memori. СKami menulis Microker (langkah ke-3) СPada versi sebelumnya, 1 operasi FMA menyumbang 2 unduhan dan 1 bongkar. A и BSebagian besar dari semua unduhan dan unload terjadi dengan matriks yang dihasilkan

: Data darinya Anda perlu mengunduh, menambahkan produk C [i] [J] + = A [i] [K] * B [K] [j], dan kemudian simpan. Dan berkali-kali. Memori tercepat dengan mana prosesor dapat bekerja adalah registernya sendiri. Jika kita menjaga nilai matriks yang dihasilkan B.

Dalam register prosesor, selama perhitungan, Anda harus memuat hanya nilai matriks С. Sekarang kami memiliki 1 akun operasi FMA untuk hanya 2 unduhan.

Jika kita menyimpan nilai dua kolom tetangga matriks C [i] [j] dan c [i] [j + 1], maka kita dapat menggunakan kembali nilai dimuat dari matriks A [i] [k]. Dan 1 operasi FMA hanya membutuhkan 1,5 unduhan. Selain itu, sambil mempertahankan hasilnya dalam 2 register independen, kami akan mengizinkan prosesor untuk melakukan 2 operasi FMA untuk kebijaksanaan. Demikian pula, Anda dapat menyimpan nilai dua baris yang berdekatan dalam register - maka tabungan akan disimpan pada pemuatan nilai matriks СTotal prosesor desktop Intel mulai dari generasi ke-2 memiliki register vektor 16.256-bit (berlaku untuk mode prosesor 64-bit). 12 dari mereka dapat digunakan untuk menyimpan sepotong matriks yang dihasilkan

Ukuran 6x16. Akibatnya, kita dapat melakukan 12 * 8 = 96 operasi FMA dengan mengunduh hanya 16 + 6 = 22 nilai dari memori. Dan kami berhasil mengurangi akses ke memori dari 2,0 hingga 0,23 unduhan ke 1 operasi FMA - hampir 10 kali! 

Fungsi yang melakukan perhitungan sepotong kecil matriks С:

, biasanya disebut sebagai microner, berikut ini adalah contoh dari fungsi seperti itu: 

void micro_6x16 (int k, const float * a, int lda, int step, const float * b, int ldb, float * c, int ldc) {__m256 c00 = _mm256_setzero_ps (); __m256 c10 = _mm256_setzero_ps (); __m256 c20 = _mm256_setzero_ps (); __m256 c30 = _mm256_setzero_ps (); __m256 c40 = _mm256_setzero_ps (); __m256 c50 = _mm256_setzero_ps (); __m256 c01 = _mm256_setzero_ps (); __m256 c11 = _mm256_setzero_ps (); __m256 c21 = _mm256_setzero_ps (); __m256 c31 = _mm256_setzero_ps (); __m256 c41 = _mm256_setzero_ps (); __m256 c51 = _mm256_setzero_ps (); Const int offset0 = lda * 0; Const int offset1 = lda * 1; Const int offset2 = lda * 2; Const int offset3 = lda * 3; Const int offset4 = lda * 4; Const int offset5 = lda * 5; __M256 B0, B1, A0, A1; untuk (int k = 0; k <k; k ++) {b0 = _mm256_loadu_ps (b + 0); B1 = _mm256_loadu_ps (B + 8); A0 = _mm256_set1_ps ([Offset0]); A1 = _mm256_set1_ps ([Offset1]); C00 = _mm256_fmadd_ps (A0, B0, C00); C01 = _mm256_fmadd_ps (A0, B1, C01); C10 = _mm256_fmadd_ps (A1, B0, C10); c11 = _mm256_fmadd_ps (A1, B1, C11); A0 = _mm256_set1_ps (a [offset2]); A1 = _mm256_set1_ps ([offset3]); C20 = _mm256_fmadd_ps (A0, B0, C20); C21 = _mm256_fmadd_ps (A0, B1, C21); c30 = _mm256_fmadd_ps (A1, B0, C30); C31 = _mm256_fmadd_ps (A1, B1, C31); A0 = _mm256_set1_ps (a [offset4]); A1 = _mm256_set1_ps (a [offset5]); C40 = _mm256_fmadd_ps (A0, B0, C40); C41 = _mm256_fmadd_ps (A0, B1, C41); C50 = _mm256_fmadd_ps (A1, B0, C50); c51 = _mm256_fmadd_ps (A1, B1, C51); B + = ldb; A + = Langkah; } _mm256_storeu_ps (c + 0, _mm256_add_ps (c00, _mm256_loadu_ps (C + 0))))))))))))) _mmm256_storeu_ps (c + 8, _mm256_add_ps (c01, _mm256_loadu_ps (c + 8))); C + = ldc; _mmm256_storeu_ps (c + 0, _mm256_add_ps (c10, _mm256_loadu_ps (c + 0))); _mm256_storeu_ps (c + 8, _mm256_add_ps (c11, _mm256_loadu_ps (c + 8))))))))))))); C + = ldc; _mm256_storeu_ps (c + 0, _mm256_add_ps (c20, _mm256_loadu_ps (c + 0))); _mmm256_storeu_ps (c + 8, _mm256_add_ps (c21, _mm256_loadu_ps (C + 8))); C + = ldc; _mmm256_storeu_ps (c + 0, _mm256_add_ps (c30, _mm256_loadu_ps (c + 0))); _mmm256_storeu_ps (c + 8, _mm256_add_ps (c31, _mm256_loadu_ps (c + 8))); C + = ldc; _mmm256_storeu_ps (c + 0, _mm256_add_ps (c40, _mm256_loadu_ps (c + 0))); _mmm256_storeu_ps (c + 8, _mm256_add_ps (c41, _mm256_loadu_ps (c + 8))); C + = ldc; _mm256_storeu_ps (c + 0, _mm256_add_ps (c50, _mm256_loadu_ps (c + 0))); _mmm256_storeu_ps (c + 8, _mm256_add_ps (c51, _mm256_loadu_ps (c + 8)));}

Kami memperkenalkan fungsi bantu kecil untuk menginisialisasi nilai awal matriks

Void init_c (int m, int n, float * c, int ldc) {untuk (int i = 0; i <m; ++ i, c + = ldc) untuk (int j = j + j + = 8) _mm256_storeu_ps (c + j, _mm256_setzero_ps ());} 

Di sini LDA, LDB, LDC - dimensi terdepan dalam kasus umum) dari matriks yang sesuai.

Kemudian fungsi multiplikasi akan mengambil formulir berikut:

Void gemm_v3 (int m, int n, int k, float const * a, const float * b, float * c) {untuk (int i = 0; i <m; = 6) {untuk (untuk (untuk (untuk (int j = 0; ; j <n; j + = 16) {init_c (6, 16, c + i * n + j, n); micro_6x16 (k, a + i * k, k, 1, b + j, n, c + i * n + j, n); }}} B.

Kami menjalankannya dan mendapatkan waktu eksekusi 78,5 ms atau 36,2 gflops. Itu. Penggunaan mikrokernel memungkinkan untuk mempercepat perkalian matriks hampir 3 kali. Tetapi kecepatan yang dihasilkan masih jauh dari maksimum. Di mana hambatan sekarang?

  1. Memutar ulang matriks B (Langkah ke-4) BMicroicer untuk setiap iterasi memuat dua vektor 256-bit dari matriks
  2. Dan setiap kali dari baris baru. Ini membuat prosesor tidak mungkin untuk secara efektif melakukan caching data ini secara efektif. Untuk memperbaiki situasi ini, kami akan membuat dua perubahan: СSalin data matriks B.

Dalam buffer sementara sehingga data yang diperlukan untuk mikrokernel yang sama di dekatnya.

Ubah pesanan pencarian untuk matriks 

: Pertama kita akan berjalan melalui kolom dan hanya pada barisan. Ini akan memungkinkan untuk secara efisien menggunakan nilai matriks yang dipesan ulang.

Untuk menyimpan buffer, kami akan mendapatkan struktur kecil: B:

Struct buf_t {float * p; int n; BUF_T (Ukuran Int): N (Ukuran), P ((float *) _ mm_malloc (ukuran * 4, 64)) {} ~ buf_t () {_mm_free (P); }}; 

Perlu dicatat di sini bahwa mengunduh dan membongkar vektor AVX bekerja secara optimal selama data yang selaras, karena fungsi khusus digunakan untuk menyoroti memori.

Fungsi pemesanan ulang matriks 

Void Reorder_B_16 (int K, Const Float * B, int ldb, float * bufb) {untuk (int k = 0; k <k; + + k, b + = ldb, bufb + = 16) {_mm256_storeu_ps (BUFB + 0 , _mm256_loadu_ps (b + 0)); _mm256_storeu_ps (BUFB + 8, _mm256_loadu_ps (B + 8)); }}

Nah, pada kenyataannya, versi ke-4 dari fungsi GEMM:

Void Gemm_v4 (int m, int n, int k, const float * a, const float * b, float * c) {untuk (int j = 0; j + = 16) {BUF_T BUFB (16 * K ); Reorder_b_16 (k, b + j, n, bufb.p); untuk (int i = 0; i <m; i + = 6) {init_c (6, 16, c + i * n + j, n); micro_6x16 (k, a + i * k, k, 1, bufb.p, 16, c + i * n + j, n); }}}

Hasil tes (29,5 ms atau 96,5 gflops) menunjukkan bahwa kita berada di jalur yang benar. Sebenarnya mencapai sekitar 80% dari maksimum secara teoritis. BKemenangan? Sayangnya tidak ada. Hanya ukuran matriks yang kami gunakan untuk pengujian (m = n = k = 1152) ternyata nyaman untuk versi algoritma ini. Jika Anda meningkat hingga 100 kali (m = 1152, n = 1152, k = 115200), maka efisiensi algoritma akan turun menjadi 39,5 gflops - hampir 2,5 kali. СLokalisasikan data dalam cache L1 (langkah ke-5)

Jadi mengapa parameter yang meningkat, efektivitas algoritma jatuh? Jawabannya terletak pada besarnya buffer, yang kami gunakan untuk menyimpan nilai yang ditata ulang

. Untuk nilai-nilai besar, itu tidak menjadi cache prosesor. Solusi untuk masalah akan terbatas pada nilainya dengan ukuran cache data L1. Untuk prosesor Intel, ukuran cache data L1 adalah 32 KB. Dengan pembatasan ukuran buffer, mikrojoe akan berjalan tidak ada dalam semua nilai K, tetapi hanya dengan rentang yang merupakan ayat dalam cache L1. Hasil perhitungan menengah dari matriks 

Akan disimpan dalam memori utama.

Kami memperkenalkan Macroudro - fungsi bantu yang membuat perhitungan di atas area data yang akan ditutupi cache: 

void macro_v5 (int m, int n, int k, const float * a, int lda, float const * b, int ldb, float * BUFB, float * c, int ldc) {untuk (int j = 0; ; J + = 16) {Reorder_B_16 (K, B + J, LDB, BUFB); Untuk (int i = 0; i <m; i + = 6) micro_6x16 (k, a + i * lda, lda, 1, bufb, 16, c + i * ldc + j, ldc); }}

Dalam fungsi utama, kami akan menambahkan siklus sesuai dengan K, di mana kami akan menelepon MacRoyadro:

Void gemm_v5 (int m, int n, int k, const float * a, const float * b, float * c) {const int l1 = 32 * 1024; int mk = std :: min (L1 / 4/16, k); BUF_T BUFB (16 * MK); untuk (int k = 0; k <k; k + = mk) {int dk = std :: min (k, k + mk) - k; if (k == 0) init_c (m, n, c, n); MACRO_V5 (M, N, DK, A + K, K, B + K * N, N, BUFB.P, C, N); }} BHasil pengukuran menunjukkan bahwa kita bergerak ke arah yang benar: untuk (m = 1152, n = 1152, k = 115200) kinerja algoritma adalah 78,1 gflops. Ini jauh lebih baik daripada di versi sebelumnya, tetapi masih lebih buruk daripada untuk matriks berukuran sedang. AMemutar ulang matriks A dan melokalisasi dalam cache L2 (langkah ke-6)

Listing The Size K, yang diproses dalam satu lulus Microker, kami berhasil melokalisasi data matriks 

dalam cache l1. Data yang dimuat dari matriks Ahampir tiga kali lebih sedikit. Tapi mari kita coba melokalisasi mereka, pada saat yang sama menata ulang data sehingga mereka berbaring secara konsisten. Kami menulis fitur khusus untuk ini: Void reorder_a_6 (const float * a, int lda, int m, int k, float * bufa) {untuk (int i = 0; i <m; i + = 6) {untuk (int k = 0; k; k + = 4) {const float * pa = a + k; __m128 a0 = _mm_loadu_ps (pa + 0 * lda); __m128 A1 = _mm_loadu_ps (pa + 1 * lda); __m128 A2 = _mm_loadu_ps (pa + 2 * lda); __m128 A3 = _mm_loadu_ps (pa + 3 * lda); __m128 A4 = _mm_loadu_ps (PA + 4 * LDA); __m128 A5 = _mm_loadu_ps (PA + 5 * LDA); __m128 A00 = _mm_unpacklo_ps (A0, A2); __m128 A01 = _mm_unpacklo_ps (A1, A3); __m128 A10 = _mm_unpackhi_ps (A0, A2); __m128 A11 = _mm_unpackhi_ps (A1, A3); __m128 A20 = _mm_unpacklo_ps (A4, A5); __m128 A21 = _mm_unpackhi_ps (A4, A5); _mm_storeu_ps (Bufa + 0, _mm_unpacklo_ps (A00, A01)); _mm_storel_pi ((__ M64 *) (BUFA + 4), A20); _mm_storeu_ps (Bufa + 6, _mm_unpackhi_ps (A00, A01)); _mm_storeH_pi ((__ M64 *) (BUFA + 10), A20); _mm_storeu_ps (bufa + 12, _mm_unpacklo_ps (A10, A11)); _mm_storel_pi ((__ M64 *) (BUFA + 16), A21); _mm_storeu_ps (Bufa + 18, _mm_unpackhi_ps (A10, A11))); _mm_storeH_pi ((__ M64 *) (BUFA + 22), A21); BUFA + = 24; } A + = 6 * LDA; }} Karena, matriks data

Sekarang pergi secara konsisten, maka parameternya 

Lda. ADi Makroyader, kita tidak perlu lagi. Juga mengubah parameter panggilan Microker:

Void macro_v6 (int m, int n, int k, const float * a, const float * b, int ldb, float * bufb, float * c, int ldc) {untuk (int j + j + = 16) {Reorder_B_16 (K, B + J, LDB, BUFB); untuk (int i = 0; i <m; i + = 6) micro_6x16 (k, a + i * k, 1, 6, bufb, 16, c + i * ldc + j, ldc); }} 

Ukuran buffer untuk matriks yang dipesan ulang

Kami membatasi ukuran cache prosesor L2 (biasanya dari 256 hingga 1024 KB untuk berbagai jenis prosesor). Fungsi utama menambah siklus tambahan dengan variabel M:

void gemm_v6 (int m, int n, int k, float const * a, const float * b, float * c) {const int l1 = 32 * 1024, l2 = 256 * 1024; Int mk = std :: min (L1 / 4/16, k) / 4 * 4; int mm = std :: min (l2 / 4 / mk, m) / 6 * 6; BUF_T BUFB (16 * MK); BUF_T BUFA (MK * mm); untuk (int k = 0; k <k; k + = mk) {int dk = std :: min (k, k + mk) - k; untuk (int i = 0; i <m; i + = mm) {int dm = std :: min (m, i + mm) - i; if (k == 0) init_c (dm, n, c + i * n, n); Reorder_A_6 (A + I * K + K, K, DM, DK, BUFA.P); makro_v6 (dm, n, dk, bufa.p, b + k * n, n, bufb.p, c + i * n, n); }}} BHasil pengukuran tes untuk (M = 1152, N = 1152, K = 115200) - 88,9 Gflops - Mendekati satu langkah lagi ke hasil untuk matriks berukuran sedang. BKami menggunakan Cash L3 (Langkah ke-7)

Dalam prosesor, selain cache L1 dan L2, masih ada cache L3 (biasanya ukurannya 1-2 MB pada kernel). Mari kita coba menggunakannya dan, misalnya, untuk menyimpan nilai matriks yang dipesan ulang. 

Untuk menghindari fungsi panggilan yang tidak perlu. Reorder_B_16. Parameter resananb tambahan akan muncul di fungsi Makroyader, yang akan melaporkan bahwa matriks ini

Sudah dipesan: 

Void macro_v7 (int m, int n, int k, float const * a, const float * b, int ldb, float * bufb, bool reorderb, float * c, int ldc) {untuk (int j = 0; ; j + = 16) {if (reorderb) reorder_b_16 (k, b + j, ldb, bufb + k * j); untuk (int i = 0; i <m; i + = 6) micro_6x16 (k, a + i * k, 1, 6, bufb + k * j, 16, c + i * ldc + j, ldc); }}

Fungsi utamanya akan menambah siklus untuk N:

void gemm_v7 (int m, int n, int k, const float * a, const float * b, float * c) {const int l1 = 32 * 1024, l2 = 256 * 1024 * 1024; Int mk = std :: min (L1 / 4/16, k) / 4 * 4; int mm = std :: min (l2 / 4 / mk, m) / 6 * 6; int mn = std :: min (l3 / 4 / mk, n) / 16 * 16; BUF_T BUFB (MN * MK); BUF_T BUFA (MK * mm); untuk (int j = 0; j <n; j + = mn) {int dn = std :: min (n, j + mn) - j; untuk (int k = 0; k <k; k + = mk) {int dk = std :: min (k, k + mk) - k; untuk (int i = 0; i <m; i + = mm) {int dm = std :: min (m, i + mm) - i; if (k == 0) init_c (dm, dn, c + i * n + j, n); Reorder_A_6 (A + I * K + K, K, DM, DK, BUFA.P); makro_v7 (dm, dn, dk, bufa.p, b + k * n + j, n, bufb.p, i == 0, c + i * n + j, n); }}}}

Hasil pengukuran untuk (m = 1152, n = 1152, k = 115200) memberikan hasil pada 97,3 gflops. Itu. Kami bahkan melebihi hasilnya untuk matriks berukuran sedang. Bahkan, kami menerima algoritma universal (sebenarnya tidak, tentang batasan di bagian berikutnya), yang hampir sama efisien (sekitar 80% dari maksimum yang dapat dicapai secara teoritis) berfungsi untuk setiap ukuran matriks. Ini disarankan untuk berhenti dan menjelaskan bahwa kami pada akhirnya ternyata.

  • Skema umum algoritma Gambar di bawah ini menunjukkan skema algoritma yang dihasilkan: BMicro kernel. ASiklus-1. B.

Dengan variabel k. Data yang dipesan ulang dari matriks

  • Pangkuan dalam cache L1, menyusun ulang data dari matriks LA di Cache L2. Jumlahnya terakumulasi dalam register (cache l0). Hasilnya dicatat dalam memori utama. Dimensi mikrokernel ditentukan oleh panjang vektor SIMD dan jumlah register vektor. Panjang siklus ditentukan dengan ukuran cache L1, di mana ia disimpan AHalaman makro.
  • Siklus-2. dalam variabel i. Menjalankan microkernel pada data matriks yang dipesan ulang Byang terletak pada cache L2. B.

CYCLE-3.

Oleh variabel j. Menjalankan microkernel pada data matriks yang dipesan ulang

  • yang terletak pada cache L3. Secara opsional mengubah data yang hilang di Dimensi dari Makroard ditentukan dengan nilai cache. AFungsi dasar ASiklus-4. С.
  • dalam variabel i. Makro-man berjalan pada matriks . Setiap nilai penggorder iterasi A и B.
  • . Opsional menginisialisasi nilai matriks Siklus-5. B.

Dengan variabel k. Makro-Man berjalan pada matriks

CYCLE-6.

  1. Oleh variabel j. Makro-man berjalan pada matriks
  2. Apa yang tersisa di belakang layar?
  3. Dalam proses menyajikan prinsip-prinsip dasar yang digunakan dalam algoritma multiplikasi matriks, saya secara sadar menyederhanakan tugas, jika tidak, itu tidak akan masuk ke dalam artikel apa pun. Di bawah ini saya akan menjelaskan beberapa pertanyaan yang tidak penting untuk memahami esensi utama algoritma, tetapi sangat penting untuk implementasi praktis mereka:
  4. Pada kenyataannya, sayangnya, ukuran matriks tidak selalu dicap oleh ukuran microkernel, karena tepi matriks harus diproses secara khusus. Yang diperlukan untuk menerapkan mikrokernel dengan ukuran yang berbeda.
  5. Untuk berbagai jenis prosesor, berbagai set mikro dan fungsi pemesanan ulang diimplementasikan. Juga, mikrokernel-nya juga akan menjadi angka dengan akurasi ganda dan untuk bilangan kompleks. Untungnya, kebun binatang mikro hanya dibatasi oleh mereka dan pada tingkat atas kode cukup universal.
  6. Mikroofer sering ditulis langsung pada assembler. Juga melakukan pelepasan siklus tambahan. Tetapi ini tidak mengarah pada akselerasi yang signifikan - optimasi utama adalah secara efektif menggunakan hierarki cache dari memori prosesor.

Untuk matriks berukuran kecil (untuk setiap pengukuran), algoritma khusus digunakan - kadang-kadang menyusun ulang tidak efektif, kadang-kadang perlu untuk menerapkan keadaan matriks keadaan lain. Dan terkadang menerapkan mikrokernel khusus.

Dalam algoritma umum untuk multiplikasi matriks, ketiga matriks dapat ditransposisikan. Tampaknya jumlah kemungkinan algoritma meningkat 8 kali! Untungnya, aplikasi pemesanan ulang data input memungkinkan semua kasus untuk melakukan mikro yang tidak sengaja.

Hampir semua prosesor modern adalah multi-inti. Dan perpustakaan perkalian matriks menggunakan multithreading untuk mempercepat perhitungan. Biasanya, 1-3 siklus tambahan lainnya digunakan untuk ini, di mana tugas-tugas rusak oleh utas yang berbeda.

.

Kesimpulan

Добавить комментарий