Post on 24-Jul-2020
transcript
CHAIN MATRIX MULTIPLICATION
פנושאורי
חורין-וגיא בן
CHAIN MATRIX MULTIPLICATION
חזרה קצרה על הכפלת מטריצות •
הגדרת בעיית הכפלת שרשרת מטריצות •
פתרון רקורסיבי לבעיה •
memoizationי "ייעול הפתרון הרקורסיבי ע •
י תכנון דינאמי"הצגת פתרון יעיל יותר ע •
חזרה על הכפלת מטריצות
REVIEW OF MATRIX MULTIPLICATION
12
25
2*11*10*00*12*11*0
2*01*20*10*02*21*1
20
12
01
*110
021
' למסחייב להיות שווה השורות במטריצה השמאלית ' מס• הטורים במטריצה הימנית
:ינה אסוציאטיביתההכפלת מטריצות •
(A1 x A2 ) x A3 = A1 x (A2 x A3 )
:הכפלת מטריצות אינה קומוטטיבית•
A1 x A2 != A2 x A1
MATRIX CHAIN-PRODUCTS
C = A*B
A is d × e and B is e × f
O(def ) time
A C
B
d d
f
e
f
e
i
j
i,j
1
0
],[*],[],[e
k
jkBkiAjiC
MATRIX-CHAIN MULTIPLICATION
:הבעיה
A1, A2, …,Anבהינתן המטריצות
A1 x A2 x …. X Anהמכפלה נרצה לחשב את
מספר מינימאלי של הכפלותי "ע
.שהביא אותנו לתוצאה זו הסידורולהחזיר את
לפיו נכפול)אנחנו מחפשים סידור אופטימאלי , בעצם*
( הכפלות)הפעולות ' לנו את מס שיתן( את המטריצות . המינימאלי
MATRIX-CHAIN MULTIPLICATION (CONT.)
דוגמא:
A x B x C x D נרצה להכפיל את המטריצות 30 x 1 1 x 40 40 x 10 10 x 25
החישוב הבא מראה לנו כמה הכפלות נאלץ לעשות לפי כל אחד
: מהסידורים האפשריים של המטריצות
((AB)C)D 30x1x40 + 30x40x10 + 30x10x25 = 20,700
A(B(CD)) 40x10x25 + 1x40x25 + 30x1x25 = 11,750
(AB)(CD) 30x1x40 + 40x10x25 + 30x40x25 = 41,200
A((BC)D) 1x40x10 + 1x10x25 + 30x1x25 = 1400
DOES THE GREEDY APPROACH WORK?
in our example - A x B x C x D
30 x 1 1 x 40 40 x 10 10 x 25
A x B = 30x1x40 = 1,200, B x C = 1x40x10 = 400, C x D = 40x10x25 = 10,000
B * C costs 400
Remaining is A * BC * D
30x1 1x10 10x25
A x BC = 30x1x10 = 300 , BC x D = 1x10x25 = 250
Next do BC * D with cost of 250
Finally, A * BCD with cost of 750
Total cost = 1400
Yes
DOES THE GREEDY APPROACH WORK?
in an even simpler example, No.
A1 * A2 * A3
30x1 1x40 40x50
Greedy approach gives 30x1x40 + 30x40x50= 61200
Optimal answer is 1x40x50 + 30x1x50 = 3500
הפתרון הרקורסיבי
DATA VARIABLES
, נשים לב כי איננו צריכים את הערכים שבתוך המטריצות*
.אלא רק את הגדלים של המטריצות
.יהיה המערך שישמור לנו את הגדלים של המטריצות d[0..j]*
'וכו d[1] x d[2] הוא A2 הגודל של , d[0] x d[1] הוא A1 הגודל של *
d[i-1]*d[i]*d[i+1] היא : Ai Ai+1 * של ( ההכפלות' מס)העלות
דוגמא:
A1 A2 A3 A4
di : 13 5 89 3 34
cost(A1 A2 A3 A4 ) :הגדרה)
.ל"לחישוב המכפלה הנ הינו מספר ההכפלות המינימאלי
(A1(A2(A3A4))), costs = 26418
(A1((A2A3)A4)), costs = 4055
((A1A2 )( A3A4)), costs = 54201
((A1(A2 A3))A4), costs = 2856
((( A1A2)A3)A4), costs = 10582
A1 A2 A3 A4 13 5 89 3 34
Cost ((A1 x (A2 x (A3 x A4)))) :
Cost(A3 x A4) = d[2] x d[3] x d[4] = 89*3*34 = 9,078= A3A4
Cost(A2 x A3A4) = d[1] x d[2] x d[4] = 5*89*34 = 15,130 = A2A3A4
Cost(A1 x A2A3A4) = d[0] x d[1] x d[4] = 13*5*34 = 2,210 = A1A2A3A4
Cost ((A1 x (A2 x (A3 x A4)))) = 9,078 + 15,130 + 2,210 =
26,418
(A1(A2(A3A4)))
(A1((A2A3)A4))
((A1A2 )( A3A4))
((A1(A2 A3))A4)
((( A1A2)A3)A4)
A1 A2 A3 A4
2
1 3
A1 A2 A3 A4
1 2 3
RECURSIVE FORMULATION OF SOLUTION
m[i,j] = optimal cost for multiplying matrices i through j
m(i,j) = min [m(i,k) + m(k+1,j) + di-1dkdj]
for 1≤ i ≤ j ≤ , i ≤ k ≤ j-1
m(i,i) = 0
m[1,n] = optimal cost for entire problem
That‟s the way it looks -
j<i if}],1[],[{min
j=i if0],[
1j<ki
jki pppjkmkimjim
k T :
• If T is an optimal solution for A1, A2, … , An
1, …, k k+1, …, n
T1 T2
• then, T1 (resp. T2) is an optimal solution for A1,
A2, … , Ak (resp. Ak+1, Ak+2, … , An).
SUBPROBLEM OVERLAP
RecursiveMatrixChain(S, i, j): :אלגוריתם
S של n מטריצות להכפלה רצף : קלט
S ההכפלות שצריך לבצע בפתרון אופטימאלי של ' מס: פלט
. כל תאי המטריצה מאותחלים ל , בתחילת הריצה*
if i=j
then return 0
for k i to j do
Ni, j min{Ni,j, RecursiveMatrixChain(S, i ,k)+ RecursiveMatrixChain(S, k+1,j)+ pi pk+1 pj+1}
return Ni,j
SUBPROBLEM OVERLAP
!!!חישובים כפולים
1..4
1..1 2..4 1..2 3..4 1..3 4..4
2..2 3..4 2..3 4..4 3..3 4..4 1..1 2..2
3..3 4..4 2..2 3..3
3..3 1..2
1..1 2..2
2..3
2..2 3..3
1..1
!אקספוננציאליזמן החישוב הינו , ולכן
PROOF
: המבנה של פיתרון אופטימאלי הוא*
בנפרד ולולכן הפיתרון האופטימאלי מצריך מציאת פתרון אופטימאלי ל
.ואז לחבר אותם ביחד
הוכחה: נסתכל על פתרון אופטימאלי כלשהו. נניח בשלילה כי הוא אינו פותר אופטימאלית
, ההכפלות הנדרש כדי לחשב את ' הוא מס X נניח כי . את
ההכפלות הנדרש' מס z y -ההכפלות הנדרש כדי לחשב את ו' הוא מס
(.הכפלת שתי תתי המטריצות)כדי לחשב את השלב האחרון באלגוריתם
x + y + z : ההכפלות הנדרש כדי לפתור את הבעיה הינו' מס
מכיוון שהפתרון אינו פותר אופטימאלית את קיים פתרון אופטימאלי שכן פותר אותה
אם נשתמש בפתרון הזה כדי לפתור את הבעיה נגיע. הכפלות x‟ < x י "אופטימאלית ע
מצאנו פתרון יותר טוב מהפתרון, כלומר, הכפלות x „ + y + z < x + y + z לפתרון של
האופטימאלי עליו הסתכלנו בהתחלה סתירה לאופטימאליות הפתרון ההתחלתי
n1iA1iA
n1ii21 A...AA...AA
n11A
iA1iA1
iA1
ייעול הפתרון הרקורסיבי
memoizationי "ע
DYNAMIC PROGRAMMING ALGORITHM
,מכיוון שישנן כפילויות רבות של חישובים
.memoization-נשתמש ב
בתא מתאים בטבלה" ייזכר"פתרון שנחשב -כל תת
ולפני חישוב כל ערך נבדוק האם הוא כבר חושב
.או לא( נמצא בטבלה, משמע)
SUBPROBLEM OVERLAP
RecursiveMatrixChain(S, i, j): :אלגוריתם
S של n מטריצות להכפלה רצף : קלט
S ההכפלות שצריך לבצע בפתרון אופטימאלי של ' מס: פלט
.כל תאי המטריצה מאותחלים ל , בתחילת הריצה*
if i=j
return 0
for k i to j-1 do
if (Ni, k < +)
RC = Ni, k
else
RC = RecursiveMatrixChain(S, i ,k)
Ni, k = RC
if (Nk+1,j < +)
LC = Nk+1,j
else
LC = RecursiveMatrixChain(S, k+1,j)
Nk+1,j = LC
Ni, j min{Ni,j, RC + LC + di dk+1 dj+1}
return Ni,j
SUBPROBLEM OVERLAP
1..4
1..1 2..4 1..2 3..4 1..3 4..4
2..2 3..4 2..3 4..4 3..3 4..4 1..1 2..2
3..3 4..4 2..2 3..3
:נזכור את החישובים הכפולים ממקודם
3..3 1..2
1..1 2..2
2..3
2..2 3..3
1..1
RECURSIVEMATRIXCHAIN(S, 1 ,4): דוגמת ריצהif i=j
return 0
for k i to j-1 do
if (Ni, k < +)
RC = Ni, k
else
RC = RecursiveMatrixChain(S, i ,k)
Ni, k = RC
if (Nk+1,j < +)
LC = Nk+1,j
else
LC = RecursiveMatrixChain(S, k+1,j)
Nk+1,j = LC
Ni, j min{Ni,j, RC + LC + di dk+1 dj+1}
return Ni,j
1..4
1..1 2..4
1..2 3..4
1..3 4..4
2..2 3..4 2..3 4..4
3..3 4..4 1..1 2..2
3..3 4..4 2..2 3..3
1 2 3 4
1
2
3
4
i=1, j=4 K=1 i=1, j=1 i=2, j=4 i=2, j=2 i=3, j=4 i=3, j=3 i=4, j=4 i=2, j=3 i=1, j=2 i=1, j=3 RC=0 LC=0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
0
K=2
0
K=3
0
0
5x8x2
2..3 1..1
2..2 3..3
2 8 5 4 10
d1 d2 d3 d4 d5
LC=80
80
4x5x8
RC=160
160
LC=120
120+10x4x2 200 10x4x5
RC=200
200
N1, 4 min{200, 200 + 80 + 10x5x2} = 200
LC=160
160+10x4x8
N1, 3 min{480, 200 + 10x5x8} = 480
480
RC=480
N1, 4 min{200, 480 + 10x8x2} = 200
200: תשובה סופית
200
80 + 4x5x2 120
N2, 4 min{120, 160 + 4x8x2} = 120
הפסקה נעימה
י תכנון דינאמי"פתרון ע
(איטרטיבי)
DYNAMIC PROGRAMMING ALGORITHM
Algorithm matrixChain(S):
Input: sequence S of n matrices to be multiplied
Output: number of operations in an optimal parenthesization of S
for i 1 to n 1 do
Ni,i 0
for b 1 to n 1 do
{ b j i is the length of the problem }
for i 0 to n b - 1 do
j i b
Ni,j
for k i to j 1 do
Ni,j min{Ni,j, Ni,k + Nk+1,j + di dk+1 dj+1}
return N0,n-1
MCM DP—ORDER OF MATRIX
COMPUTATIONS
m(1,1) m(1,2) m(1,3) m(1,4) m(1,5) m(1,6)
m(2,2) m(2,3) m(2,4) m(2,5) m(2,6)
m(3,3) m(3,4) m(3,5) m(3,6)
m(4,4) m(4,5) m(4,6)
m(5,5) m(5,6)
m(6,6)
answer
N 0 1
0
1
2 …
n-1
…
n-1 j
i
Dynamic Programming Algorithm Visualization
The bottom-up construction
fills in the N array by
diagonals
Ni,j gets values from
previous entries in i-th row
and j-th column
Filling in each entry in the
N table takes O(n) time.
Total run time: O(n3)
Getting actual optimal
solution can be done by
remembering “k” for each
N entry
}{min 11,1,,
jkijkkijki
ji dddNNN
i
j
MCM DP Example
S[1,6]=3 -> 654321 AAAAAA
DYNAMIC PROGRAMMING ALGORITHM
VISUALIZATION A0: 30 X 35; A1: 35 X15; A2: 15X5;
A3: 5X10; A4: 10X20; A5: 20 X 25
7125
}
1137520*10*3504375
,712520*5*3510002625
,1300020*15*3525000
min{
5414,43,1
5314,32,1
5214,21,1
4,1
dddNN
dddNN
dddNN
N
}{min 11,1,,
jkijkkijki
ji dddNNN
ההכפלות המינימאלי' אז עכשיו אנחנו יודעים מה מס
.שידרשו לנו כדי להכפיל את שרשרת המטריצות
(נשחזר)אבל איך נדע
??את הסידור שהביא אותנו לתוצאה
DYNAMIC PROGRAMMING
ALGORITHM
Algorithm matrixChain(S):
Input: sequence S of n matrices to be multiplied
Output: number of operations in an optimal parenthesization of S
for i 0 to n 1 do
Ni,i 0 ; Tii i;
for b 1 to n 1 do
{ b j i is the length of the problem }
for i 0 to n b - 1 do
j i b
Ni,j ; Tij i;
for k i to j 1 do
If (Ni,j> Ni,k + Nk+1,j + di dk+1 dj+1)
Ti,jk
Ni,j min{Ni,j, Ni,k + Nk+1,j + di dk+1 dj+1}
return N0,n-1
נוסיף את טבלת
מקומות החלוקה
:שלנו לאלגוריתם
T -טבלת ה
DYNAMIC PROGRAMMING ALGORITHM
VISUALIZATION
(A0*(A1*A2))*((A3*A4)*A5)
Consider an example with sequence of dimensions
<5,2,3,4,6,7,8>
m[i, j] = mini k < j{m[i, k] + m[k+1, j] + pi1 pk pj }
1 2 3 4 5 6
1 0 30 64 132 226 348
2 0 24 72 156 268
3 0 72 198 366
4 0 168 392
5 0 336
6 0
EXAMPLE
m[i, j] = mini k < j{m[i, k] + m[k+1, j] + pi1 pk pj } s[i, j] = a value of k that gives the minimum
s 1 2 3 4 5 6
1 1 1 1 1 1
2 2 3 4 5
3 3 4 5
4 4 5
5 5
[1,6]
[2,6] A1
[2,5] A6
[2,4] A5
A4 [2,3]
A2 A3 A1(((( A2A3)A4)A5) A6)
ONE MORE EXAMPLE
A1 * A2 * A3 * A4
30x1 1x40 40x10 10x25
d =
m =
s =
30 1 40 10 25
0
-1
1200
1
700
1
1400
1
0
-1
400
2
650
3
0
-1
10000
3
0
-1
PSEUDOCODE TO PRINT
void printParens(s, i, j){
if (i == j)
print “A”i
else
print “(“
printParens (s, i, s[i,j])
printParens (s, s[i,j], j)
print “)”
}
For the factor table in previous example, the output of printParens(s,1,6) is -
„(A1 x ((A2 x A3) x A4))‟
RUNNING TIME FOR DP PROGRAMS
#overall sub problems #choices.
We have to fill in n2/2 entries of M. For each it finds the minimum of fewer than n expressions involving a few arithmetic operations. thus the total number of steps is -
O(n2) O(n) = O(n3)
Each call to printParens results in writing exactly one matrix number or – [ “x” , “(“ , “)”], so there are
2n–1 calls, and printParens takes Θ(n) time.
THE COST =COSTS OF SOLVING SUBPROBLEMS
+ COST OF MAKING CHOICE.
CHOICE COST IS PI-1PKPJ.
Running time (n3)
Storage (n2)
That’s what happens when you don’t do the chain ….