மேட்ரிக்ஸ் பெருக்கல் என்பது நேரியல் இயற்கணிதத்தில் ஒரு அடிப்படை செயல்பாடாகும்.
பட செயலாக்கம், இயந்திர கற்றல் மற்றும் பல பயன்பாடுகளில் இதைப் பொதுவாகப் பயன்படுத்துகிறோம். NumPy என்பது அறிவியல் கம்ப்யூட்டிங்கிற்கான குறிப்பிடத்தக்க பைதான் தொகுப்பு ஆகும்.
இருப்பினும், இந்த இடுகையில், NumPy ஐப் பயன்படுத்தாமல் பைத்தானில் மேட்ரிக்ஸ் பெருக்கல் செய்வதற்கான பல்வேறு முறைகளைப் பார்ப்போம்.
நாங்கள் பயன்படுத்துவோம் உள்ளமைந்த சுழல்கள், உள்ளமைக்கப்பட்ட வரைபடம்() செயல்பாடு மற்றும் பட்டியல் புரிதல்.
கூடுதலாக, ஒவ்வொரு மூலோபாயத்தின் நன்மைகள் மற்றும் குறைபாடுகள் மற்றும் அவை ஒவ்வொன்றையும் எப்போது பயன்படுத்த வேண்டும் என்பதைப் பார்ப்போம். நீங்கள் நேரியல் இயற்கணிதத்திற்கு புதியவராக இருந்தால் மற்றும் அணி பெருக்கல் பற்றி மேலும் அறிய விரும்பினால்; தொடர்ந்து படிக்கவும்.
மேட்ரிக்ஸ் பெருக்கத்தை நாம் எங்கே பயன்படுத்துகிறோம்?
மேட்ரிக்ஸ் பெருக்கல் பயன்படுத்தப்படுகிறது கணினி வரைகலை 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]]
நன்மைகள்:
- புரிந்துகொள்வது எளிது.
- புதியவர்கள் அல்லது மேட்ரிக்ஸ் பெருக்கத்தின் ஆழமான புரிதலை விரும்புபவர்களுக்கு சிறந்தது.
குறைபாடுகள்:
- மாற்று நுட்பங்களைப் போல பயனுள்ளதாக இல்லை, குறிப்பாக பெரிய மெட்ரிக்குகளுக்கு.
- மாற்று அணுகுமுறைகளைப் போல இது படிக்கக்கூடியதாக இல்லை.
வரைபடம்() செயல்பாட்டு முறை
வரைபடம்() செயல்பாட்டு முறையானது பைத்தானில் மேட்ரிக்ஸ் பெருக்கல் செய்வதற்கு மாற்று அணுகுமுறையை வழங்குகிறது. இந்த அணுகுமுறையில், உள்ளமைக்கப்பட்ட வரைபடம்() செயல்பாட்டைப் பயன்படுத்துகிறோம். எனவே, செயல்படக்கூடிய ஒவ்வொரு உறுப்புக்கும் (பட்டியல், டூப்பிள், முதலியன) வழங்கப்பட்ட செயல்பாட்டைப் பயன்படுத்தும் செயல்பாட்டு நிரலாக்கக் கருவியைப் பயன்படுத்துகிறோம். மேலும், வரைபடம்() செயல்பாடு இரண்டு அளவுருக்களை ஏற்றுக்கொள்கிறது, ஒரு செயல்பாடு மற்றும் ஒரு செயலி. மேலும், இது செயல்படும் ஒவ்வொரு உறுப்புக்கும் செயல்பாட்டைப் பயன்படுத்தும் ஒரு மறு செய்கையை வழங்குகிறது.
இந்த அணுகுமுறையில், மேட்ரிக்ஸின் ஒவ்வொரு உறுப்பினருக்கும் சென்று, உள்ளமைக்கப்பட்ட வரைபடம்() செயல்பாட்டைப் பயன்படுத்தி பெருக்கல் செய்கிறோம்.
ஜிப்() செயல்பாடு இணையாக உள்ள மெட்ரிக்ஸின் ஒவ்வொரு உறுப்பையும் மீண்டும் செய்ய பயன்படுகிறது.
இறுதியாக, முடிவுகளைச் சேர்க்க கூட்டு() செயல்பாடு பயன்படுத்தப்படுகிறது.
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]]
நன்மைகள்
- அடுக்கப்பட்ட சுழல்கள் அணுகுமுறையை விட மிகவும் பயனுள்ளதாக இருக்கும்
- குறியீட்டை எளிமையாக்க இது செயல்பாட்டு நிரலாக்கத்தைப் பயன்படுத்துகிறது.
குறைபாடுகள்
- செயல்பாட்டு நிரலாக்கத்தை நன்கு அறிந்திராத சிலர் அதை குறைவாக படிக்கலாம்.
- உள்ளமைக்கப்பட்ட சுழல்கள் நுட்பத்தை விட இது குறைவாகவே புரிந்துகொள்ளக்கூடியது.
பட்டியல் புரிந்துகொள்ளும் முறை
பட்டியல் புரிதல் ஒரு புதிய பட்டியலை ஒரே வரியில் உருவாக்க உதவுகிறது. எனவே, இது ஏற்கனவே உள்ள பட்டியலில் உள்ள ஒவ்வொரு உறுப்பினருக்கும் ஒரு வெளிப்பாட்டைப் பயன்படுத்துவதன் மூலம் ஆகும்.
இந்த அணுகுமுறையில், ஒவ்வொரு மேட்ரிக்ஸ் உறுப்பினர் மூலமாகவும் மீண்டும் மீண்டும் மீண்டும் செய்வதன் மூலம் பெருக்கல் மேற்கொள்ளப்படுகிறது. நாங்கள் அடுக்கு பட்டியல் புரிதலைப் பயன்படுத்துகிறோம்.
# 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]]
நன்மைகள்
- வரைபடம்() செயல்பாட்டு முறையுடன் ஒப்பிடும்போது, குறுகிய மற்றும் படிக்கக்கூடியது.
குறைபாடுகள்
- வரைபடம்() செயல்பாட்டைப் பயன்படுத்துவதை விட இது குறைவான செயல்திறன் கொண்டதாக இருக்கலாம், குறிப்பாக பெரிய மெட்ரிக்குகளுக்கு.
- உள்ளமைக்கப்பட்ட சுழல்கள் அணுகுமுறையை விட இது மிகவும் கடினம்.
தீர்மானம்
இந்த இடுகையில், பைத்தானில் மெட்ரிக்குகளைப் பெருக்கும் போது NumPy ஐப் பயன்படுத்துவதற்கான மாற்றுகளைப் பார்த்தோம். உள்ளமைக்கப்பட்ட சுழல்கள், உள்ளமைக்கப்பட்ட வரைபடம்() செயல்பாடு மற்றும் பட்டியல் புரிதல் ஆகியவற்றில் மேட்ரிக்ஸ் பெருக்கலைச் செய்தோம்.
சிறந்த மூலோபாயம் உங்கள் திட்டத்தின் குறிப்பிட்ட தேவைகளை சார்ந்திருக்கும்.
ஒவ்வொரு உத்திகளுக்கும் அதன் சொந்த நன்மை தீமைகள் உள்ளன. செயல்பாடு சரியாக இயங்குகிறதா என்பதை உறுதிப்படுத்த, பல்வேறு மேட்ரிக்ஸ் பரிமாணங்கள் மற்றும் மதிப்புகளுடன் சில சோதனை நிகழ்வுகளைச் சேர்ப்பது நல்லது.
இந்த முறைகள் எவ்வளவு சிறப்பாகச் செயல்படுகின்றன என்பதை ஒப்பிட்டுப் பார்க்க, சில செயல்திறன் சோதனைகளையும் நீங்கள் சேர்க்க வேண்டும்.
ஒரு பதில் விடவும்