الگوریتم‌های ضرب ماتریس

الگو:حل نشده ضرب ماتریس یکی از اعمال پایه در بسیاری از الگوریتم‌های آنالیز عددی محسوب می‌شود به همین دلیل در راستای بهبود زمان آن تلاش‌های بسیاری انجام شده‌است. کاربردهای ضرب ماتریس در بسیاری از زمینه‌های مختلف همچون علم محاسبه، بازشناخت الگو ، پردازش تصویر ، کار با نرم افزارهای ۳ بعدی و حتی زمینه‌های به ظاهر بی‌ربط مانند شمردن تعداد گشت‌ها در یک گراف دیده می‌شود. الگوریتم‌های بسیاری برای این‌ کار روی سیستم‌های رایانش موازی طراحی شده‌ است که در آن چند هسته به صورت همزمان و موازی عملیات را انجام می‌دهند.

اگر از تعریف ضرب ماتریس به صورت مستقیم استفاده کنیم برای ضرب دو ماتریس الگو:Math زمان الگو:Math طول خواهد کشید که به صورت الگو:Math می‌توانیم نمایش دهیم. الگوریتم‌هایی با زمان اجرای بهتری برای این‌کار ارائه شده‌اند. برای مثال در ده سال ۱۹۶۹ استراسن در این زمینه الگوریتمی بر پایه ماتریس های 2×2 ارائه داد اما به‌طور کلی هنوز نمی‌دانیم بهترین الگوریتم برای این کار چیست. (در واقع پیچیدگی زمانی آن مشخص نیست)

الگوریتم پیمایشی

طبق تعریف ضرب ماتریس می‌توانیم یک الگوریتم برای این کار ارائه دهیم. به ازای ماتریس $A$ که یک ماتریس $n\times m$ است و ماتریس $B$ که یک ماتریس $m\times p$ است می‌خواهیم ماتریس $C=AB$ که ماتریسی $n\times p$ است را محسابه کنیم. طبق تعریف ضرب ماتریس $c_{i,j}=\sum _{k=1}^m{a}_{i,k}\times b_{k,j}$ بنابراین به ازای هر دوتایی $(i,j)$ می‌توانیم با $O(m)$ مقدار $c_{i,j}$ را محاسبه کنیم. یعنی در کل الگوریتمی با زمان اجرای $O(n\times m\times p)$ خواهیم داشت. اگر فرض کنیم هر سه ماتریس $n\times n$ هستند آنگاه الگوریتم $O(n^3)$ خواهد بود.

1 Input: matrices الگو:Mvar and الگو:Mvar
2 Let الگو:Mvar be a new matrix of the appropriate size
3 For الگو:Mvar from 1 to الگو:Mvar:
4 For الگو:Mvar from 1 to الگو:Mvar:
5 Let الگو:Math
6 For الگو:Mvar from 1 to الگو:Mvar:
7 Set الگو:Math
8 Set الگو:Math
9 Return الگو:Mvar

بررسی رفتار حافظه نهان (کش)

یک ترتیب سطری و ستونی از ماتریس

در الگوریتم بالا ترتیب حلقه‌ها را می‌توانیم جابه‌جا کنیم. اگر چه این جابه‌جایی در مدت زمان اجرای الگوریتم تأثیری نخواهد داشت اما این ترتیب در بحث‌های مربوط به دسترسی حافظه (access pattern) و مسائل مربوط به استفاده از حافظه نهان پردازنده مهم است. مثلاً اینکه ماتریس‌ها به ترتیب سطری یا ستونی (یا ترکیبی از این دو) ذخیره شوند در زمان حافظهٔ نهان پردازنده تأثیر گذار خواهد بود.

حتی اگر حالت بهینه را در نظر بگیریم که حافظهٔ کش شرکت پذیر کامل با $M$ سطر حافظهٔ $b$ بیتی باشد و ماتریس‌های $A$ و $B$ به صورت سطری ذخیره شده‌باشند، این الگوریتم بهینه نخواهد بود. هنگامی که $n>\frac{M}{b}$ از آنجایی که ماتریس‌ها به صورت سطری ذخیره شده‌اند هر پیمایش حلقهٔ داخلی در الگوریتم (یک پیمایش روی سطر ماتریس اول و ستون ماتریس دوم) یک خطای کش به هنگام دسترسی به خانه‌ی‌های ماتریس دوم به همراه خواهد داشت؛ و این به این معناست که الگوریتم در بدترین حالت حاوی $\mathrm{\Theta }(n^3)$ خطای کش خواهد بود. امروزه -یعنی از سال ۲۰۱۰- خطای کش‌ها به نسبت اعمال پردازنده تأثیر بیشتری روی زمان اجرا می‌گذارند بنابراین بهتر است با روشی این خطای کش‌ها را کاهش دهیم.

برای حل این مشکل ماتریس‌ها را به بلوک‌هایی از اردر $\sqrt{M}\times \sqrt{M}$ تایی تقسیم می‌کنیم. با اینکار کل یک زیرجدول در حافظهٔ کش قرار می‌گیرد و این بلوک‌ها در هم ضرب می‌شوند. ضرب هر بلوکی هیچ خطای کشی به همراه نخواهد داشت.

01 Input: matrices الگو:Mvar and الگو:Mvar
02 Let الگو:Mvar be a new matrix of the appropriate size
03 Pick a tile size الگو:Math
04 For الگو:Mvar from 1 to الگو:Mvar in steps of الگو:Mvar:
05 For الگو:Mvar from 1 to الگو:Mvar in steps of الگو:Mvar:
06 For الگو:Mvar from 1 to الگو:Mvar in steps of الگو:Mvar:
07 Multiply الگو:Math and الگو:Math into الگو:Math, that is:
08 For الگو:Mvar from الگو:Mvar to الگو:Math:
09 For الگو:Mvar from الگو:Mvar to الگو:Math:
10 Let الگو:Math
11 For الگو:Mvar from الگو:Mvar to الگو:Math:
12 Set الگو:Math
13 Set الگو:Math
14 Return الگو:Mvar

تعداد خطاهای کش در این مدل برابر $\frac{n^3}{b\sqrt{M}}$ خواهدبود. مخرج $b\times \sqrt{M}$ باعث می‌شود در پردازنده‌های جدید خطاهای کش در زمان اجرا تأثیر گذار نشوند و صرفاً تحلیل زمانی الگوریتم تأثیر گذار باشد.

الگوریتم تقسیم و حل

حال سعی می‌کنیم روشی تقسیم و حل برای ضرب ماتریس‌ها ارائه دهیم. ابتدا فرض کنید ماتریس‌هایمان $n\times n$ هستند. در این روش مطابق زیر ماتریس‌ها را به چهار بلوک تقسیم می‌کنیم که اندازهٔ آن‌ها تقریباً برابرند.

$C=\left(\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right),A=\left(\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right),B=\left(\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right)$.

اگر ماتریس‌های‌مان اندازه‌شان توانی از دو باشد (یعنی ماتریسی با ابعاد $2^n\times 2^n$ ) می‌توانیم این الگوریتم را به کار بگیریم. به صورت زیر دو ماتریس را در هم ضرب می‌کنیم.

$\left(\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right)=\left(\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right)\left(\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right)=\left(\begin{array}{cc}{A}_{11}{B}_{11}+A_{12}{B}_{21}& A_{11}{B}_{12}+A_{12}{B}_{22}\\ A_{21}{B}_{11}+A_{22}{B}_{21}& A_{21}{B}_{12}+A_{22}{B}_{22}\end{array}\right)$

این الگوریتم شامل ۸ ضرب ماتریس‌های کوچکتر $2^{n-1}\times 2^{n-1}$ خواهد بود که به‌صورت بازگشتی محاسبه می‌شود و پایهٔ آن ضرب اسکالر $c_{1,1}=a_{1,1}\times b_{1,1}$ است. همچنین جمع کردن ماتریس‌ها به صورتی که در بالا گفته‌شده $\mathrm{\Theta }(n^2)$ طول خواهد کشید.

توجه کنید اگر ماتریس ما ابعادش توانی از ۲ نبود باز هم می‌توانیم این الگوریتم را به کار ببریم. کافیست با اضافه کردن سطرهایی تمام صفر و ستون‌هایی تمام صفر به پایین و راست ماتریس ابعادش را توانی از دو کنیم. با اضافه کردن آن‌ها اندازهٔ ماتریس حداکثر ۴ برابر خواهد شد (تعداد ستون‌ها و سطرها هر کدام ۲ برابر خواهند شد) بنابراین تفاوتی در تحلیل زمانی ایجاد نمی‌شود به‌علاوه افزودن سطر و ستون تمام صفر تأثیری در حاصل‌ضرب نخواهدگذاشت.

با توجه به مطالب گفته‌شده برای تحلیل زمانی آن می‌توانیم رابطهٔ زیر را بنویسیم:

$T(1)=\mathrm{\Theta }(1)$;

$T(n)=8T(n/2)+\mathrm{\Theta }(n^2)$،

بر طبق قضیه‌ی اصلی می‌توانیم این الگوریتم را تحلیل زمانی کنیم. می‌دانیم $f(n)=\mathrm{\Theta }(n^2)\subset 𝒪(n^{lo{g}_{2}8-\epsilon })$ بنابراین $T(n)=\mathrm{\Theta }(n^3)$ خواهد بود.

در نتیجه این الگوریتم با الگوریتم ابتدایی‌ای که بررسی کردیم تفاوتی از نظر زمانی ندارد.

ماتریس‌های غیر مربعی

این الگوریتم در عمل برای ماتریس‌های غیر مربعی سریع‌تر عمل می‌کند. کافیست به جای تقسیم کردن هر دو ماتریس به چهار تکه یکی از ماتریس‌ها را به دو تکهٔ برابر (یا تقریباً برابر) با تقسیم کردن سطرها یا ستون‌ها تقسیم کنیم. در زیر می‌توانید الگوریتم چنین کاری را ببینید: الگو:چپ‌چین

 Inputs: matrices الگو:Mvar of size الگو:Math, الگو:Mvar of size الگو:Math.
 Base case: if الگو:Math is below some threshold, use an unrolled version ofthe iterative algorithm.
 Recursive cases:
 If الگو:Math, split الگو:Mvar horizontally:
       $C=\left(\begin{array}{c}{A}_1\\ A_2\end{array}\right)B=\left(\begin{array}{c}{A}_{1}B\\ A_{2}B\end{array}\right)$
 Else, If الگو:Math, split الگو:Mvar vertically:
       $C=A\left(\begin{array}{cc}{B}_1& B_2\end{array}\right)=\left(\begin{array}{cc}A{B}_1& A{B}_2\end{array}\right)$
 Otherwise, الگو:Math. Split الگو:Mvar vertically and الگو:Mvar horizontally:
       $C=\left(\begin{array}{cc}{A}_1& A_2\end{array}\right)\left(\begin{array}{c}{B}_1\\ B_2\end{array}\right)=A_1{B}_1+A_2{B}_2$

بررسی رفتار حافظه نهان (کش)

الگوریتم گفته‌شده در این بخش تقسیم‌بندی را تا جایی می‌تواند ادامه دهد که کل ماتریس در حافظهٔ کش جا شوند و بنابراین از نظر تعداد خطاهای کش مانند روش تقسیم‌بندی بلوکی عمل می‌کند. با این تفاوت که در آن الگوریتم خود پیاده‌سازی الگوریتم با توجه به اندازهٔ کش پردازندهٔ هدف انجام می‌شود (پارامتر $\mathrm{\Theta }(sqrtM)$ ای را باید در خود متن الگوریتم تعیین کنیم) در حالیکه این الگوریتم برای کش‌های پویا با اندازه‌های مختلف بهینه‌تر عمل خواهد کرد.

تعداد خطاهای کش در این الگوریتم با $M$ خط حافظهٔ کش که هر خط $b$ بیت دارد به صورت زیر خواهد بود:

$\mathrm{\Theta }(m+n+p+\frac{mn+np+mp}{b}+\frac{mnp}{b\sqrt{M}})$

الگوریتم‌های بهتر از $\mathrm{\Theta }(n^3)$

کوچکترین $\omega$ای در زمان‌های مختلف که الگوریتم ضرب ماتریس با $𝒪(n^{\omega })$ وجود داشته‌است.

الگوریتم‌هایی وجود دارند که زمان اجرای بهتری از الگوریتم‌های فوق دارند. اولین الگوریتم کشف شده که اینگونه بود الگوریتم استراسن بود که در سال ۱۹۶۹ توسط وولکر استراسن (Volker Strassen) کشف شد. این الگوریتم به «الگوریتم سریع ضرب ماتریس» نیز معروف است. این الگوریتم بر مبنای ضرب دو ماتریس $2\times 2$ با ۷ عملیات ضرب است که در عوض تعداد بیشتری جمع و عملیات ریاضی این‌چنینی لازم دارد. با استفاده از این ایده به‌صورت بازگشتی الگوریتمی از $𝒪(n^{lo{g}_{2}7})\approx 𝒪(n^{2.807})$ به ما می‌دهد. این الگوریتم پیچیده‌است و ضرایب ثابت آن در تحلیل زمانی به اندازه‌ای زیاد است که تنها برای ماتریس‌های بزرگ کارامدتر از الگوریتم‌های قبلی عمل خواهد کرد.

سریعترین الگوریتم با $𝒪(n^k)$ الگوریتمی است که از تعمیم الگوریتم کوپراسمیت–وینوگارد به‌دست آمده و از نظر زمانی $𝒪(n^{2.3728639})$ می‌باشد. این الگوریتم توسط François Le Gall کشف شد و به قدری ضرایب زیادی دارد و سربار الگوریتم بالاست که تنها برای ماتریس‌های بسیار بزرگی که هم‌اکنون در علوم کامپیوتر کاربردی ندارند، کارامد خواهد بود.

با توجه به این‌که باید حداقل روی همهٔ اعضای دو ماتریس $n\times n$ پیمایش انجام بشود کران‌پایین $\mathrm{\Omega }(n^2)$ برای الگوریتم‌های ضرب ماتریس وجود دارد. راز (Raz) ثابت کرد که کران پایین $\mathrm{\Omega }(n^{2}lo{g}_n)$ نیز برای هر الگوریتم ضرب ماتریس نیز وجود دارد.

همچنین الگوریتم الگوریتم فریوالد یک الگوریتم احتمالی و مونت کارلو است که در $𝒪(n^2)$ چک می‌کند که آیا ضرب دو ماتریس $A,B$ برابر $C$ هست یا نه.

جستارهای وابسته

• ضرب ماتریس
• حافظه نهان
• ضرب زنجیره‌ای ماتریس
• الگوریتم فریوالد
• الگوریتم استراسن