მატრიცული გამრავლება არის ფუნდამენტური ოპერაცია წრფივი ალგებრაში.
ჩვენ ჩვეულებრივ ვიყენებთ მას მრავალ აპლიკაციებში, როგორიცაა გამოსახულების დამუშავება, მანქანური სწავლება და მრავალი სხვა. NumPy არის პითონის მნიშვნელოვანი პაკეტი სამეცნიერო გამოთვლებისთვის.
თუმცა, ამ პოსტში განვიხილავთ პითონში მატრიცის გამრავლების სხვადასხვა მეთოდს NumPy-ის გამოყენების გარეშე.
ჩვენ გამოვიყენებთ წყობილი მარყუჟები, ჩაშენებული map() ფუნქცია და სიის გაგება.
გარდა ამისა, ჩვენ განვიხილავთ თითოეული სტრატეგიის უპირატესობებსა და ნაკლოვანებებს, ასევე, როდის გამოვიყენოთ თითოეული მათგანი. თუ ახალი ხართ წრფივი ალგებრაში და გსურთ გაიგოთ მეტი მატრიცის გამრავლების შესახებ; გააგრძელე კითხვა.
სად ვიყენებთ მატრიცის გამრავლებას?
მატრიცული გამრავლება გამოიყენება კომპიუტერული გრაფიკა 2D და 3D ვიზუალის შესაცვლელად. მაგალითად, შეგიძლიათ ეკრანზე ობიექტების როტაცია, მასშტაბირება და თარგმნა. მატრიცები გამოიყენება გამოსახულების დამუშავებისას სურათების პიქსელების მასივების სახით გამოსაჩენად. გარდა ამისა, მატრიცები შეიძლება გამოყენებულ იქნას ოპერაციების ჩასატარებლად, როგორიცაა გამოსახულების ფილტრაცია.
ჩვენ ასევე ვიყენებთ მატრიცებს მანქანა სწავლის. მათ შეუძლიათ დაგვეხმარონ მონაცემთა და მოდელის პარამეტრების წარმოდგენაში. ჩვენ შეგვიძლია ჩავატაროთ მრავალი ოპერაცია, როგორიცაა წერტილოვანი პროდუქტების გამოთვლა და მატრიცულ-ვექტორული პროდუქტები.
რა თქმა უნდა, ეს ოპერაცია ასევე უაღრესად ხელსაყრელია სამეცნიერო ოპერაციებში. ჩვენ შეგვიძლია გამოვიყენოთ ის ფიზიკასა და ინჟინერიაში ფიზიკური რაოდენობების აღსაწერად. აქედან გამომდინარე, ჩვენ შეგვიძლია ვიმოქმედოთ ვექტორებით და ტენსორებით.
რატომ არ შეიძლება ავირჩიოთ NumPy-ის გამოყენება?
მიუხედავად იმისა, რომ NumPy არის ა პითონის ბიბლიოთეკა, ის ყოველთვის არ არის იდეალური ვარიანტი მატრიცის გამრავლებისთვის. ჩვენ შეიძლება არ ავირჩიოთ NumPy-ის გამოყენება ისეთი მიზეზების გამო, როგორიცაა ზომა და დამოკიდებულება, სწავლა და ძველი სისტემები.
პითონის ჩაშენებული ფუნქციების გამოყენება ან მორგებული კოდის შემუშავება შეიძლება უფრო ეფექტური იყოს ზოგიერთ შემთხვევაში. თუმცა, მნიშვნელოვანია აღინიშნოს, რომ NumPy არის ძლიერი ბიბლიოთეკა. გარდა ამისა, შეგიძლიათ გამოიყენოთ იგი მატრიცის გამრავლებისთვის.
ახლა მოდით შევხედოთ როგორ მივაღწიოთ მატრიცის გამრავლებას NumPy-ის გარეშე.
წყობილი მარყუჟების მეთოდი
წყობილი მარყუჟების ტექნიკა იყენებს წყობილ მარყუჟებს პითონში მატრიცის გამრავლების შესასრულებლად. ფუნქცია იმეორებს თითოეულ მატრიცის ელემენტს. და ის ამრავლებს მათ წყობილი მარყუჟების სერიის გამოყენებით. ფუნქცია აბრუნებს შედეგს, რომელიც ინახება ახალ მატრიცაში.
ეს მიდგომა გასაგებია. თუმცა, ეს შეიძლება არ იყოს ისეთი ეფექტური, როგორც სხვა გზები, განსაკუთრებით უფრო დიდი მატრიცებისთვის. თუმცა, ეს შესანიშნავი არჩევანია თქვენთვის, თუ ახალი ხართ წრფივი ალგებრაში.
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])
# დააყენეთ შედეგის მატრიცა ნულზე.
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
მოდით მივიღოთ მაგალითი, თუ როგორ უნდა გავაკეთოთ ეს. თქვენ შეგიძლიათ დაამატოთ ქვემოთ მოცემული კოდის ეს სტრიქონები ამ მაგალითის შესამოწმებლად.
# 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]]
უპირატესობები:
- ადვილად აღსაქმელი.
- შესანიშნავია დამწყებთათვის ან მათთვის, ვინც ეძებს მატრიცის გამრავლების უფრო ღრმა გაგებას.
ნაკლოვანებები:
- არ არის ისეთი ეფექტური, როგორც ალტერნატიული ტექნიკა, განსაკუთრებით დიდი მატრიცებისთვის.
- ის ისე არ იკითხება, როგორც ალტერნატიული მიდგომები.
map() ფუნქციის მეთოდი
map() ფუნქციის მეთოდი იძლევა ალტერნატიულ მიდგომას პითონში მატრიცის გამრავლების გასაკეთებლად. ამ მიდგომაში ჩვენ ვიყენებთ ჩაშენებულ map() ფუნქციას. აქედან გამომდინარე, ჩვენ ვიყენებთ ფუნქციონალური პროგრამირების ხელსაწყოს, რომელიც იყენებს მოწოდებულ ფუნქციას თითოეულ განმეორებად ელემენტზე (სია, დუბლი და ა.შ.). ასევე, Map() ფუნქცია იღებს ორ პარამეტრს, ფუნქციას და iterable-ს. და ის აბრუნებს გამეორებას, რომელიც იყენებს ფუნქციას თითოეულ გამეორებად ელემენტზე.
ამ მიდგომით, ჩვენ გავდივართ მატრიცის თითოეულ წევრს და ვაკეთებთ გამრავლებას წყობილი map() ფუნქციის გამოყენებით.
zip() ფუნქცია გამოიყენება მატრიცების თითოეული ელემენტის პარალელურად გასამეორებლად.
და ბოლოს, sum() ფუნქცია გამოიყენება შედეგების დასამატებლად.
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
ახლა, ისევ, ჩვენ შეგვიძლია შევამოწმოთ ჩვენი კოდი მაგალითით.
# 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]]
უპირატესობები
- უფრო ეფექტური ვიდრე stacked loops მიდგომა
- კოდის გასამარტივებლად ის იყენებს ფუნქციურ პროგრამირებას.
ნაკლოვანებები
- ზოგიერთი ადამიანი, ვინც არ იცნობს ფუნქციონალურ პროგრამირებას, შეიძლება ნაკლებად იკითხებოდეს.
- ეს ნაკლებად გასაგებია, ვიდრე წყობილი მარყუჟების ტექნიკა.
სიის გააზრების მეთოდი
სიის გააზრება საშუალებას გაძლევთ შექმნათ ახალი სია კოდის ერთი ხაზით. აქედან გამომდინარე, ეს არის გამოხატვის გამოყენებით არსებული სიის თითოეულ წევრზე.
ამ მიდგომით, გამრავლება ხორციელდება მატრიცის თითოეული წევრის განმეორებით გამეორებით. ჩვენ ვიყენებთ ფენიანი სიის გააზრებას.
# 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]]
უპირატესობები
- map() ფუნქციის მეთოდთან შედარებით, უფრო მოკლე და იკითხებადი.
ნაკლოვანებები
- ეს შეიძლება იყოს ნაკლებად ეფექტური ვიდრე map() ფუნქციის გამოყენება, განსაკუთრებით დიდი მატრიცებისთვის.
- ეს უფრო რთულია, ვიდრე წყობილი მარყუჟების მიდგომა.
დასკვნა
ამ პოსტში ჩვენ გადავხედეთ NumPy-ის გამოყენების ალტერნატივებს პითონში მატრიცების გამრავლებისას. ჩვენ შევასრულეთ მატრიცის გამრავლება წყობილ მარყუჟებში, ჩაშენებული map() ფუნქცია და სიის გააზრება.
საუკეთესო სტრატეგია დაეყრდნობა თქვენი პროექტის კონკრეტულ საჭიროებებს.
თითოეულ სტრატეგიას აქვს თავისი დადებითი და უარყოფითი მხარეები. იმისათვის, რომ დარწმუნდეთ, რომ ფუნქცია გამართულად მუშაობს, მიზანშეწონილია დაამატოთ რამდენიმე სატესტო შემთხვევა სხვადასხვა მატრიცის ზომებითა და მნიშვნელობებით.
თქვენ ასევე უნდა შეიტანოთ შესრულების რამდენიმე ტესტი, რათა შევადაროთ რამდენად კარგად მუშაობს ეს მეთოდები.
დატოვე პასუხი