एक SciPy ट्यूटोरियल जिसमें आप Python में मशीन लर्निंग के लिए ज़रूरी रैखिक बीजगणित की बुनियादी बातें सीखेंगे, NumPy के साथ कैसे करना है उस पर फोकस के साथ।
मशीन लर्निंग में सचमुच गहराई से उतरने के लिए आपको जिन चीज़ों की ज़रूरत है, उनका बड़ा हिस्सा रेखीय बीजगणित है, और यही इस ट्यूटोरियल का विषय है। आज की पोस्ट उन रेखीय बीजगणित विषयों को कवर करती है जिन्हें समझना आपको यह अंतर्दृष्टि विकसित करने में मदद करेगा कि मशीन लर्निंग विधियाँ कैसे और कब काम करती हैं—वेक्टर और मैट्रिक्स के स्तर पर नज़र डालकर।
ट्यूटोरियल के अंत तक, उम्मीद है कि आप किसी एल्गोरिदम पर और करीब से नज़र डालने के लिए अधिक आत्मविश्वास महसूस करेंगे!
सामग्री
भूमिका
डेटा साइंस सीखना चाहते हैं तो जिन तीन बुनियादी विषयों में महारत ज़रूरी है, उनमें से एक मशीन लर्निंग है। और जब आप सच में मशीन लर्निंग पर उतरते हैं, तो यह ज़रूरी हो जाता है कि आप और गहराई में जाएँ और एल्गोरिदम कैसे काम करते हैं इसकी समझ और सहज बोध विकसित करें।
और मेरा मानना है कि आप, एक (उदीयमान) डेटा वैज्ञानिक, मुझसे सहमत होंगे कि इस मुकाम तक पहुँचना कठिन हो सकता है।
लेकिन ऐसा होना ज़रूरी नहीं।
SciPy बनाम NumPy
DataCamp के NumPy ट्यूटोरियल से आपने समझ लिया होगा कि यह लाइब्रेरी Python में वैज्ञानिक कंप्यूटिंग के लिए कोर लाइब्रेरियों में से एक है। इस लाइब्रेरी में टूल्स और तकनीकों का एक संग्रह है जिनका उपयोग विज्ञान और इंजीनियरिंग की समस्याओं के गणितीय मॉडलों को कंप्यूटर पर हल करने के लिए किया जा सकता है। लेकिन वह एक टूल जिसे आप सबसे ज़्यादा उपयोग करेंगे, एक उच्च-प्रदर्शन बहु-आयामी array ऑब्जेक्ट है: यह एक शक्तिशाली डेटा संरचना है जो आपको arrays और matrices को कुशलता से compute करने देती है।
अब, SciPy मूलतः NumPy पर आधारित है।
यह भी वैज्ञानिक कंप्यूटिंग के लिए कोर पैकेजों में से एक है जो गणितीय एल्गोरिदम और सुविधाजनक फ़ंक्शंस प्रदान करता है, लेकिन यह Python के NumPy एक्सटेंशन पर बना है। इसका मतलब है कि SciPy और NumPy अक्सर साथ में उपयोग किए जाते हैं!
आगे इस ट्यूटोरियल में, आपको स्पष्ट हो जाएगा कि इन दोनों लाइब्रेरियों के बीच सहयोग किस तरह स्वाभाविक हो गया है।
NumPy और SciPy के साथ इंटरैक्ट करें
दोनों पैकेज के साथ कुशलता से काम करने के लिए, पहले आपको इस लाइब्रेरी की कुछ बुनियादी बातें और इसकी शक्तिशाली डेटा संरचना के बारे में पता होना चाहिए। इन arrays के साथ काम करने के लिए, बहुत-सी उच्च-स्तरीय गणितीय फ़ंक्शंस हैं जो इन matrices और arrays पर ऑपरेट करती हैं।
आगे जो है, उसमें आपको उन विषयों का एक संक्षिप्त अवलोकन मिलेगा जिन्हें SciPy के साथ प्रभावी ढंग से काम करने के लिए समझना ज़रूरी है। मूल रूप से, आपको array संरचना, डेटा टाइप्स को संभालने और arrays के आकार (shape) को बदलने के तरीकों का ज्ञान होना चाहिए। अगर यह सब आपको नया लग रहा है, तो DataCamp का Python NumPy Tutorial देखें और सीखते समय NumPy चीट शीट पर एक नज़र ज़रूर डालें।
यदि आप यह सब पहले से जानते हैं, तो अगले सेक्शन को छोड़ दें और “Linear Algebra With SciPy” पर जाएँ, पर अपनी linear algebra के लिए SciPy चीट शीट तैयार रखें!
NumPy ndarray ऑब्जेक्ट्स की मूल बातें
संरचनात्मक रूप से, एक array मूलतः pointers का समूह है। यह एक memory address, data type, shape और strides का संयोजन होता है। इसमें raw डेटा, किसी तत्व का स्थान और उसकी व्याख्या करने का तरीका जैसी जानकारी होती है।
जब आप arrays के निम्न-स्तर के विवरण में जाते हैं तो memory address और strides महत्वपूर्ण होते हैं, जबकि data type और shape वे बातें हैं जिन्हें शुरुआती लोगों को ज़रूर समझना चाहिए। दो अन्य attributes जिन पर आप विचार करना चाहेंगे, वे हैं data और size, जिनसे आप अपने array के बारे में और जानकारी ले सकते हैं।
नीचे दिए गए DataCamp Light chunk में ndarray attributes के उपयोग को फिर से देखें। Array myArray पहले से लोड है। आप इसे IPython shell में टाइप करके और ENTER दबाकर देख सकते हैं।
# Inspect the data of `myArray`
print(myArray.data)
# Inspect the data type of `myArray`
print(_________________)
# Inspect the shape of `myArray`
print(__________________)
# Inspect the size of `myArray`
print(__________________)
ऊपर दिए गए code chunk के परिणामों में आप देखेंगे कि myArray का data type int64 है। जब आप arrays के साथ गहराई से काम करेंगे, तो आपको यह बात अवश्य याद रहेगी कि astype() मेथड से एक data type से दूसरे में arrays को बदला जा सकता है।
फिर भी, जब आप SciPy और NumPy को साथ में उपयोग करते हैं, तो निम्न type handling वाली NumPy फ़ंक्शंस भी उपयोगी लगेंगी, खासकर जब आप complex numbers के साथ काम कर रहे हों:
# Return the real part of `myArray` elements
np.real(myArray)
# Return the imaginary part of `myArray` elements
np.imag(myArray)
# Return a real array if the complex parts are close to 0
np.real_if_close(myArray,tol=1000)
# Cast `myArray` to float
np.cast['f'](myArray)
ऊपर दिए गए कोड के परिणाम देखने के लिए print() कॉल जोड़कर देखें। तब आपको दिखेगा कि complex numbers में real और imaginary दोनों भाग होते हैं। np.real() और np.imag() फ़ंक्शंस क्रमशः ये भाग वापस लौटाने के लिए बनाए गए हैं।
वैकल्पिक रूप से, आप np.cast का उपयोग करके किसी array ऑब्जेक्ट को किसी दूसरे data type में कास्ट कर सकते हैं, जैसे ऊपर के उदाहरण में float।
ऊपर दिए कोड chunk में वास्तव में जो थोड़ा कठिन दिखता है, वह है np.real_if_close() फ़ंक्शन। जब आप इसे कोई complex इनपुट देते हैं, जैसे myArray, तो यदि complex भाग शून्य के क़रीब हैं, आपको एक real array वापस मिलेगा। “0 के क़रीब” की यह सीमा आप स्वयं फ़ंक्शन को दिए जाने वाले tol argument से समायोजित कर सकते हैं। थ्रेशहोल्ड के साथ खेलकर देखें कि क्या होता है!
Array बनाना
अब आपने देख लिया है कि अपने array का निरीक्षण कैसे करें और उसके data type में बदलाव कैसे करें, लेकिन आपने स्पष्ट रूप से यह नहीं देखा कि arrays कैसे बनाए जाएँ। आपको पहले से पता होगा कि आप np.array() का उपयोग कर सकते हैं, लेकिन array बनाने के लिए अन्य routines भी हैं जिनके बारे में आपको पता होना चाहिए: np.eye() और np.identity()।
np.eye() फ़ंक्शन आपको उस धनात्मक पूर्णांक के बराबर आयामों वाली एक square मैट्रिक्स बनाने देता है जिसे आप फ़ंक्शन के argument के रूप में देते हैं। प्रविष्टियाँ सामान्यतः शून्य से भरी होती हैं, केवल मैट्रिक्स की विकर्ण (diagonal) एक से भरी होती है। np.identity() फ़ंक्शन भी इसी तरह काम करता है और एक identity array लौटाता है।
हालाँकि, ध्यान दें कि np.eye() एक अतिरिक्त argument k ले सकता है, जिसे आप उस diagonal के index को चुनने के लिए निर्धारित कर सकते हैं जिसे आप ones से भरना चाहते हैं।
अन्य array निर्माण फ़ंक्शंस जो linear algebra की matrices के साथ काम करते समय निश्चित रूप से काम आएँगे, ये हैं:
np.arange() दो संख्याओं के बीच समान अंतर वाले मानों वाला array बनाता है। आप तत्वों के बीच की दूरी निर्धारित कर सकते हैं,
यही बात np.linspace() पर भी लागू होती है, पर इस फ़ंक्शन में आप अपने array में तत्वों की संख्या निर्धारित करते हैं।
अंत में, np.logspace() भी समान अंतर वाले मानों के arrays बनाता है, लेकिन इस बार लघुगणकीय पैमाने पर। इसका अर्थ है कि spacing अब logarithmic है: दो संख्याएँ उनके base-10 logarithms के बीच समान दूरी पर होती हैं।
ये फ़ंक्शंस meshes के रूप में arrays बनाते हैं, जिनका उपयोग mesh grids बनाने में किया जा सकता है, जिसके बारे में आप इस पोस्ट में पहले पढ़ चुके हैं।
ध्यान दें कि नीचे दिए गए code chunk में numpy पहले से np के रूप में आयात है!
# Create a 2X2 identity matrix with `np.eye()`
__________________
# Create a 3X3 identity matrix with `np.identity()`
__________________
# Uniformly spaced values: spacing
_________(3, 7, 2)
# Uniformly spaced values: number of samples
___________(2, 3, 5)
# Uniformly spaced values: logarithmic spacing
___________(2, 3, 4)
अब जब आपने स्मृति ताज़ा कर ली है और जान लिया है कि arrays के data types को कैसे संभालना है, तो अब indexing और slicing के विषय पर भी बात करने का समय है।
Indexing और Slicing
Indexing में आप मूल रूप से square brackets [] का उपयोग करके array मानों को index करते हैं। दूसरे शब्दों में, यदि आप किसी array के चुने हुए तत्वों—एक subset—तक पहुँचना चाहते हैं, तो आप indexing का उपयोग कर सकते हैं। अपने डेटा को slice करना subsetting जैसा ही है, लेकिन इसे थोड़ा अधिक उन्नत मान सकते हैं। जब आप किसी array को slice करते हैं, तो आप केवल अलग-अलग मानों पर नहीं, बल्कि “regions” के साथ काम करते हैं, न कि केवल “locations” के साथ।
दोनों अवधारणाएँ नीचे दिए गए कोड उदाहरणों से फिर से देखें:
# Slice `myArray` at index 0 and 1
print(____________)
# Slice `my_2dArray` at row 0 and 1, column 1
print(________________)
# Slice `my_3dArray` at row 1
print(my_3dArray[1,...])
# Boolean indexing: only values < 2
print(myArray[____________])
# Fancy indexing
print(my_2dArray[[1, 0, 1, 0],[0, 1, 2, 0]])
अब जब आपकी slicing और indexing की समझ ताज़ा हो गई है, तो आपको कुछ index ट्रिक्स में भी रुचि हो सकती है जो SciPy के साथ वैज्ञानिक कंप्यूटिंग करते समय आपके काम को और कुशल बना सकती हैं। चार फ़ंक्शंस अक्सर सामने आएँगी: np.mgrid(), np.ogrid(), np.r और np.c।
यदि आपके पास NumPy का कुछ अनुभव है, तो आखिरी दो फ़ंक्शंस आप पहले से जानते होंगे। np.r और np.c का उपयोग क्रमशः row-wise या column-wise arrays को stack करने के लिए किया जाता है। इन फ़ंक्शंस की मदद से आप np.concatenate() का उपयोग किए बिना जल्दी से arrays बना सकते हैं।
# Create a dense meshgrid
np.mgrid[1:11:2, -12:-3:3]
# Create an open meshgrid
np.ogrid[1:11:2, -12:-3:3]
# Stack arrays vertically
np.r_[3,[0]*5,-1:1:10j]
# Stack arrays horizontally
np.c_[array, my_2dArray]
इन चार फ़ंक्शंस में से पहले दो को देखते हुए, आप पूछ सकते हैं कि meshgrid की आवश्यकता क्यों पड़ेगी। आप meshgrids का उपयोग एक समकोण (rectilinear) ग्रिड की प्रत्येक स्थिति पर x- और y-निर्देशांक वाली दो arrays बनाने के लिए कर सकते हैं। np.meshgrid() फ़ंक्शन दो 1D arrays लेता है और दो 2D मैट्रिसेस बनाता है जो उन दोनों arrays में (x, y) के सभी युग्मों के अनुरूप होती हैं।
np.mgrid() MATLAB के meshgrid का एक कार्यान्वयन है और समान shape वाली arrays लौटाता है। इसका मतलब है कि आउटपुट arrays के आयामों और उनकी संख्या, indexing dimensions की संख्या के बराबर होते हैं।
दूसरी ओर, np.ogrid() एक open meshgrid देता है और उतना dense नहीं होता जितना np.mgrid() के परिणाम में होता है। ऊपर दिए गए code chunk में आप दोनों के बीच दृश्य अंतर देख सकते हैं।
इन दोनों फ़ंक्शंस के बीच के अंतर के बारे में आप यहाँ भी पढ़ सकते हैं।
एक और फ़ंक्शन जिसका उपयोग आप indexing/slicing के उद्देश्य से कर सकते हैं, वह है np.select()। आप इसका उपयोग conditions के आधार पर arrays की सूची से मान लौटाने के लिए कर सकते हैं। पहली argument में आप conditions निर्धारित करते हैं और दूसरी argument में वह array देते हैं जिसे आप इस चयन प्रक्रिया के लिए मानना चाहते हैं।
निम्न उदाहरण देखें:
# Initialize a 2D array
my_2dArray = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
# Select values from `my_2dArray`
np.select([my_2dArray < 4],[my_2dArray * 2])
बहुत बढ़िया! अब जब आपने अपने मूल array के सही मान चुन लिए हैं, तो आप shape का चयन कर सकते हैं और अपने नए array को संशोधित कर सकते हैं।
Shape का चयन और हेरफेर
NumPy आपके arrays के shape को चुनने और उसे बदलने के अनेक तरीके देता है और संभवतः आप इनमें से कई पहले से जानते होंगे। निम्न सेक्शन केवल उन फ़ंक्शंस का संक्षिप्त अवलोकन देगा जो काम आ सकते हैं, इसलिए पोस्ट इन सबको विस्तार से कवर नहीं करती।
तो, क्या ऐसे फ़ंक्शंस हैं जो SciPy के साथ काम करते समय विशेष रूप से काम आते हैं?
हाँ, सबसे उपयोगी वे हैं जो arrays को flatten करने, stack करने और split करने में मदद करते हैं। आपने पहले ही np.c और np.r फ़ंक्शंस देख लिए हैं जिन्हें आप अक्सर np.concatenate() के बजाय प्राथमिकता देंगे, लेकिन और भी कई हैं जिनके बारे में आपको पता होना चाहिए!
जैसे np.hstack() से अपने arrays को क्षैतिज रूप से stack करना या np.vstack() से उन्हें ऊर्ध्वाधर रूप से stack करना। इसी तरह, आप np.vsplit() और np.hsplit() का उपयोग क्रमशः ऊर्ध्वाधर और क्षैतिज रूप से arrays को विभाजित करने के लिए कर सकते हैं। लेकिन संभवतः आप यह सब पहले से जानते होंगे।
इसे निम्न code chunk में साबित करें:
#Stack arrays horizontally (column-wise)
print(_________((np.eye(2), my_2dArray)))
# Stack arrays vertically (row-wise)
print(__________((myArray, my_2dArray)))
# Split the array horizontally at the 2nd index
print(___________(my_2dArray, 2))
# Split the array vertically at the 2nd index
print(____________(my_2dArray, 2))
याद रखें कि np.eye() फ़ंक्शन 2X2 identity array बनाता है, जो ऊपर दिए गए code chunk में आपके लिए लोड किए गए 2-D array के साथ stack करने के लिए बिल्कुल उपयुक्त है।
यदि आप arrays को stack करने की शर्तों के बारे में अधिक जानना चाहते हैं, तो यहाँ जाएँ। हालाँकि, आप arrays और फ़ंक्शंस को देखकर भी यह सहज ज्ञान बना सकते हैं कि यदि आप दो arrays को row या column द्वारा जोड़ना चाहते हैं तो किन ‘नियमों’ का पालन करना है।
arrays को split करते समय सबसे महत्वपूर्ण बात संभवतः आपके array का shape है, क्योंकि आपको सही index चुनना होगा जहाँ आप split चाहते हैं।
arrays को stack और split करने वाली फ़ंक्शंस के अलावा, यह भी ध्यान रखें कि आपके पास ऐसे फ़ंक्शंस भी हैं जो यह सुनिश्चित करने में मदद करती हैं कि आप एक निश्चित आयाम (dimension) वाले arrays के साथ काम कर रहे हैं—जो वैज्ञानिक कंप्यूटिंग में गहराई तक जाते समय अनिवार्य हैं।
निम्न फ़ंक्शंस पर विचार करें:
#Permute `myArray` dimensions
print(np.transpose(myArray))
# Flatten `my_3dArray`
print(my_3dArray.flatten())
# Reshape but don't change the data
print(my_2dArray.reshape(4,2))
# Resize to (6,4)
print(np.resize(my_3dArray, (6,4)))
ध्यान दें कि reshaping और resizing में अंतर है। पहले में आप डेटा का shape बदलते हैं पर डेटा स्वयं नहीं बदलता। जबकि resize करने पर, आपके चुने गए shape के आधार पर array में निहित डेटा बदल भी सकता है।
splitting और stacking routines तथा वे फ़ंक्शंस जो आपको अपने arrays में और हेरफेर करने देती हैं, इनके अलावा एक और चीज़ है जिसे आपको विचार में रखना चाहिए—“vectorization”। जब आप किसी फ़ंक्शन को किसी array पर लागू करते हैं, तो आमतौर पर वह array के प्रत्येक तत्व पर लागू होता है। उदाहरण के लिए, किसी array पर np.cos(), np.sin() या np.tan() लगाकर देखें। आप देखेंगे कि यह सभी तत्वों पर काम करता है। जब ऐसा होता है, तो आप समझ लें कि फ़ंक्शन vectorized है।
लेकिन, जब आप स्वयं फ़ंक्शंस परिभाषित करते हैं, जैसा कि वैज्ञानिक कंप्यूटिंग में आप अक्सर करेंगे, तो आप उन्हें भी vectorize करना चाहेंगे। ऐसे मामलों में, आप np.vectorize() को कॉल कर सकते हैं:
# Define a function `myfunc`
def myfunc(a,b):
if a > b:
return a - b
else:
return a + b
# Vectorize `myfunc`
vectorizedFunc = np.vectorize(myfunc)
# Apply
vectorizedFunc(myArray, 2)
अन्य vectorized गणितीय फ़ंक्शंस की बात करें जिन्हें आप जानना चाहेंगे, तो np.angle() complex array तत्वों के कोण देने के लिए उपयोगी है, और बुनियादी त्रिकोणमितीय, घातीय (exponential) या लघुगणकीय (logarithmic) फ़ंक्शंस भी काम आएँगी।
SciPy के साथ रैखिक बीजगणित
अब जबकि आप जानते हैं कि दोनों पैकेजों का लाभ कैसे उठाना है, तो इस ट्यूटोरियल के विषय, यानी रैखिक बीजगणित, में गहराई से जाने का समय है।
लेकिन Python का उपयोग कैसे करना है, इसमें जाने से पहले, सुनिश्चित कर लें कि आपका कार्यक्षेत्र पूरी तरह तैयार है!
SciPy इंस्टॉल करें
सबसे पहले यह सुनिश्चित करें कि आपके सिस्टम पर Python इंस्टॉल है। अगर अभी तक नहीं किया है, तो इस पेज पर जाएँ :) यदि आप Windows पर काम कर रहे हैं, तो सुनिश्चित करें कि आपने Python को PATH एनवायरनमेंट वेरिएबल में जोड़ा है। इसके अलावा, pip जैसे पैकेज मैनेजर को इंस्टॉल करना न भूलें, जिससे आप Python की ओपन-सोर्स लाइब्रेरीज़ का उपयोग कर सकें।
ध्यान दें कि Python 3 के हालिया संस्करणों में pip शामिल होता है, इसलिए जाँच लें कि यह मौजूद है और अगर है, तो अन्य पैकेज इंस्टॉल करने से पहले इसे अपग्रेड कर लें:
लेकिन केवल पैकेज मैनेजर इंस्टॉल करना पर्याप्त नहीं है; आपको लाइब्रेरी के लिए व्हील भी डाउनलोड करना होगा: अपना SciPy व्हील पाने के लिए यहाँ जाएँ। डाउनलोड के बाद, अपने पीसी पर डाउनलोड डायरेक्टरी में टर्मिनल खोलें और इसे इंस्टॉल करें। इसके अलावा, आप जाँच सकते हैं कि इंस्टॉलेशन सफल रहा या नहीं और आप कौन-सा पैकेज संस्करण चला रहे हैं, इसकी पुष्टि कर सकते हैं:
# Install the wheel install "scipy‑0.18.1‑cp36‑cp36m‑win_amd64.whl"# Confirm successful installimport scipy# Check package versionscipy.__version__संचालित द्वारा
इन चरणों के बाद, आप तैयार हैं!
टिप: Anaconda Python डिस्ट्रीब्यूशन डाउनलोड करके पैकेज इंस्टॉल करें। यह तेज़ी से शुरू करने का आसान तरीका है, क्योंकि Anaconda में न केवल डेटा साइंस के लिए सबसे लोकप्रिय 100 Python, R और Scala पैकेज शामिल हैं, बल्कि Jupyter और Spyder जैसे कई ओपन कोर्स डेवलपमेंट एनवायरनमेंट भी शामिल हैं। यदि आप Jupyter Notebook के साथ काम शुरू करना चाहते हैं, तो यह Jupyter नोटबुक ट्यूटोरियल देखें।
यदि आपने इसे अभी तक डाउनलोड नहीं किया है, तो इसे पाने के लिए यहाँ जाएँ।
वेक्टर और मैट्रिक्स: मूल बातें
अब जबकि आपने सुनिश्चित कर लिया है कि आपका कार्यक्षेत्र तैयार है, आप अंततः Python में रैखिक बीजगणित के साथ शुरुआत कर सकते हैं। मूल रूप से, यह अनुशासन वेक्टर स्पेस और उनके बीच मौजूद रैखिक मैपिंग्स का अध्ययन करता है। इन रैखिक मैपिंग्स को मैट्रिक्स से व्यक्त किया जा सकता है, जिससे गणना भी आसान हो जाती है।
याद रखें कि वेक्टर स्पेस रैखिक बीजगणित में एक मौलिक अवधारणा है। यह वह स्पेस है जहाँ आपके पास वस्तुओं (वेक्टरों) का संग्रह होता है और जहाँ आप दो वेक्टरों को जोड़ या स्केल कर सकते हैं बिना इस कि परिणामी वेक्टर उस स्पेस से बाहर चला जाए। यह भी याद रखें कि वेक्टर किसी मैट्रिक्स की पंक्तियाँ (या स्तंभ) होते हैं।
लेकिन यह Python में कैसे काम करता है?
आप np.array() फ़ंक्शन से आसानी से वेक्टर बना सकते हैं। इसी तरह, आप किसी भी एक- या दो-आयामी ndarray को np.matrix() या np.mat() कमांड से मैट्रिक्स संरचना दे सकते हैं।
इसे नीचे दिए गए कोड खंड में आज़माएँ:
# Create a vector
myVector = np.array([1,2,3,4])
# Create a matrix
myMatrix = np.matrix(np.random.random((5,5)))
तो क्या एरे और मैट्रिक्स एक जैसे ही हैं, बस फ़ॉर्मेटिंग अलग है?
बिल्कुल नहीं। कुछ अंतर हैं:
मैट्रिक्स 2-डी होता है, जबकि एरे सामान्यतः n-डी होते हैं,
जैसा कि ऊपर दिए गए फ़ंक्शंस से संकेत मिलता है, मैट्रिक्स ndarray का सबक्लास है,
एरे और मैट्रिक्स दोनों में .T() होता है, लेकिन केवल मैट्रिक्स में .H() और .I() होता है,
मैट्रिक्स गुणा, एरे के एलिमेंट-वाइज़ गुणा से अलग तरह से काम करता है, और
इसके अलावा, ** ऑपरेशन के परिणाम मैट्रिक्स और एरे के लिए अलग होते हैं
जब आप मैट्रिक्स के साथ काम कर रहे हों, तो कभी-कभी आपको ऐसे मैट्रिक्स मिलेंगे जिनमें अधिकांश तत्व शून्य होते हैं। इन्हें “स्पार्स मैट्रिक्स” कहते हैं, जबकि जिनमें अधिकांश गैर-शून्य तत्व हों, उन्हें “डेंस मैट्रिक्स” कहते हैं।
अपने आप में यह मामूली लग सकता है, पर जब आप रैखिक बीजगणित के लिए SciPy के साथ काम कर रहे होते हैं, तो कुछ चीजें करने के लिए आप जिन मॉड्यूल्स का उपयोग करते हैं, वे इससे प्रभावित हो सकते हैं। खास तौर पर, आप डेंस मैट्रिक्स के लिए scipy.linalg का उपयोग कर सकते हैं, लेकिन जब आप स्पार्स मैट्रिक्स के साथ काम कर रहे हों, तो scipy.sparse मॉड्यूल को भी देखें, जिसमें अपना scipy.sparse.linalg भी शामिल है।
स्पार्स मैट्रिक्स बनाने के लिए कई विकल्प हैं। नीचे दिया गया कोड खंड कुछ विकल्पों को सूचीबद्ध करता है:
इसके अलावा, कुछ अन्य फ़ंक्शंस भी हैं जिनका उपयोग आप स्पार्स मैट्रिक्स बनाने के लिए कर सकते हैं: bsr_matrix() से ब्लॉक स्पार्स रो मैट्रिक्स, coo_matrix() से COOrdinate फ़ॉर्मेट स्पार्स मैट्रिक्स, dia_matrix() से DIAgonal स्टोरेज स्पार्स मैट्रिक्स, और lil_matrix() से रो-आधारित लिंक्ड लिस्ट स्पार्स मैट्रिक्स।
विकल्प बहुत हैं, लेकिन अगर आप खुद स्पार्स मैट्रिक्स बना रहे हैं, तो किसे चुनें?
यह कठिन नहीं है।
मूल रूप से, सबसे पहले देखें कि आप इसे कैसे इनिशियलाइज़ करने वाले हैं। इसके बाद, सोचें कि आप अपने स्पार्स मैट्रिक्स के साथ क्या करने वाले हैं।
और ठोस रूप में, आप निम्नलिखित चेकलिस्ट से तय कर सकते हैं कि कौन-सा स्पार्स मैट्रिक्स प्रकार उपयोग करें:
यदि आप मैट्रिक्स को एक-एक करके संख्याएँ भरकर बनाना चाहते हैं, तो coo_matrix() या dok_matrix() चुनें।
यदि आप मैट्रिक्स को एक एरे को डायगोनल के रूप में लेकर इनिशियलाइज़ करना चाहते हैं, तो dia_matrix() चुनें।
स्लाइस-आधारित मैट्रिक्स के लिए, lil_matrix() का उपयोग करें।
यदि आप छोटे मैट्रिक्स के ब्लॉक्स से मैट्रिक्स बना रहे हैं, तो bsr_matrix() इस्तेमाल करने पर विचार करें।
यदि आप अपनी पंक्तियों और स्तंभों तक तेज़ी से पहुँच चाहते हैं, तो क्रमशः csr_matrix() और csc_matrix() फ़ंक्शंस का उपयोग करके अपने मैट्रिक्स को कन्वर्ट करें। ये दोनों फ़ंक्शंस मैट्रिक्स इनिशियलाइज़ करने के लिए उपयुक्त नहीं हैं, लेकिन गुणा करते समय आप निश्चित रूप से गति में अंतर देखेंगे।
बिल्कुल आसान!
वेक्टर ऑपरेशंस
अब जब आपने वेक्टर, डेंस मैट्रिक्स और स्पार्स मैट्रिक्स के बीच अंतर सीखा या ताज़ा किया है, तो अब वेक्टरों पर करीब से नज़र डालने और उन पर किए जा सकने वाले गणितीय ऑपरेशंस को देखने का समय है। यह ट्यूटोरियल यहाँ विशेष रूप से गणितीय ऑपरेशंस पर ध्यान केंद्रित करता है ताकि आप मैट्रिक्स के साथ समानताओं और अंतरों को देख सकें, और क्योंकि रैखिक बीजगणित का बड़ा हिस्सा अंततः मैट्रिक्स के साथ काम करना ही है।
आप पहले ही देख चुके हैं कि आप np.array() से आसानी से वेक्टर बना सकते हैं। लेकिन अब जब आपके पास वेक्टर हैं, तो आप उन पर किए जा सकने वाले कुछ बुनियादी ऑपरेशंस भी जानना चाहेंगे। नीचे दिए गए कोड खंड में vector1 और vector2 पहले से लोड हैं:
# Addition of `vector1` and `vector2`
vector3 = vector1 + vector2
# Print `vector3`
print(_______)
# Subtraction of `vector2` and `vector1`
vector4 = ________ - vector1
# print `vector4`
print(vector4)
# Dot product of `vector1` and `vector2`
dotProduct = np.dot(vector1, vector2)
# Print `dotProduct`
print(dotProduct)
# Cross product of `vector1` and `vector2`
crossProduct = np.cross(________, vector2)
# Print `crossProduct`
print(____________)
अब जब आपने कुछ वेक्टर ऑपरेशंस देख लिए हैं, तो अब असली मैट्रिक्स वाले काम पर आगे बढ़ते हैं!
मैट्रिक्स: ऑपरेशंस और रूटीन
जैसे आप पिछला सेक्शन शुरू में छोड़कर आए थे, वैसे ही यहाँ भी आपको पता है कि मैट्रिक्स कैसे बनाते हैं, लेकिन अभी यह नहीं जानते कि उन्हें अपने लाभ के लिए कैसे उपयोग करें। यह सेक्शन आपको कुछ मैट्रिक्स फ़ंक्शंस और बुनियादी मैट्रिक्स रूटीन का एक अवलोकन देगा, जिनसे आप कुशलतापूर्वक काम कर सकते हैं।
सबसे पहले, कुछ फ़ंक्शंस पर चलते हैं। यदि आपने पहले NumPy के साथ काम किया है, तो ये काफ़ी सहज लगेंगे, और यदि अनुभव नहीं भी है, तो भी आप देखेंगे कि इन्हें शुरू करना आसान है।
आइए कुछ फ़ंक्शंस के उदाहरण देखते हैं।
एरे या मैट्रिसेज़ को जोड़ने और घटाने के लिए np.add() और np.subtract() हैं, और भाग देने व गुणा करने के लिए np.divide() और np.multiply। यह कोई बड़ा रहस्य नहीं लगता, है न? साथ ही np.dot() फ़ंक्शन, जिसे आपने पिछले सेक्शन में डॉट प्रोडक्ट निकालने के लिए देखा था, मैट्रिक्स के साथ भी उपयोग किया जा सकता है। लेकिन ध्यान रखें कि यहाँ वेक्टरों की जगह दो मैट्रिक्स पास करें।
ये तो बुनियादी हैं, सही?
अब थोड़े कम बुनियादी बनें। गुणन के मामले में आप कुछ और फ़ंक्शंस पर भी विचार कर सकते हैं, जैसे वेक्टरों के डॉट प्रोडक्ट के लिए np.vdot(), एरे के इनर या आउटर प्रोडक्ट के लिए np.inner() या np.outer(), और दो एरे के क्रोनेकर प्रोडक्ट के लिए np.tensordot() और np.kron():
टिप: ऊपर के कोड खंड में प्रिंट स्टेटमेंट्स जोड़ें ताकि आपको हर प्रोडक्ट का परिणाम दिखे।
इनके अलावा, linalg मॉड्यूल के कुछ फ़ंक्शंस पर भी विचार करना उपयोगी हो सकता है: मैट्रिक्स एक्सपोनेंशियल फ़ंक्शंस linalg.expm(), linalg.expm2() और linalg.expm3()। इन तीनों के बीच अंतर एक्सपोनेंशियल की गणना के तरीकों में है। सामान्य मैट्रिक्स एक्सपोनेंशियल के लिए पहले वाले पर टिके रहें, लेकिन तीनों को आज़माकर परिणामों का फर्क देखना निश्चित रूप से उपयोगी है!
साथ ही त्रिकोणमितीय फ़ंक्शंस जैसे linalg.cosm(), linalg.sinm() और linalg.tanm(), हाइपरबोलिक त्रिकोणमितीय फ़ंक्शंस जैसे linalg.coshm(), linalg.sinhm() और linalg.tanhm(), साइन फ़ंक्शन linalg.signm(), मैट्रिक्स लॉगरिद्म linalg.logm(), और मैट्रिक्स वर्गमूल linalg.sqrtm()।
इसके अतिरिक्त, आप linalg.funm() फ़ंक्शन की मदद से किसी मैट्रिक्स फ़ंक्शन का मान भी निकाल सकते हैं। नीचे दिया गया उदाहरण देखें:
linalg.funm(myMatrix, lambda x: x*x)
आप देखते हैं कि पहले आर्ग्युमेंट के रूप में वह मैट्रिक्स पास करते हैं जिस पर आप फ़ंक्शन लगाना चाहते हैं और दूसरा आर्ग्युमेंट वह फ़ंक्शन (यहाँ lambda फ़ंक्शन) होता है जिसे आप पास किए गए मैट्रिक्स पर अप्लाई करना चाहते हैं। ध्यान दें कि linalg.funm() को जो फ़ंक्शन पास करते हैं, वह वेक्टराइज़्ड होना चाहिए।
अब कुछ बुनियादी मैट्रिक्स रूटीन पर नज़र डालते हैं। पहली चीज़ जो आप शायद देखना चाहेंगे, वे हैं मैट्रिक्स एट्रिब्यूट्स: ट्रांसपोज़ के लिए T, कॉन्जुगेट ट्रांसपोज़ के लिए H, इनवर्स के लिए I, और एरे में कास्ट करने के लिए A।
जब आप किसी मैट्रिक्स का ट्रांसपोज़ करते हैं, तो आप एक नया मैट्रिक्स बनाते हैं जिसकी पंक्तियाँ मूल मैट्रिक्स के स्तंभ होते हैं। दूसरी ओर, कॉन्जुगेट ट्रांसपोज़ में हर मैट्रिक्स एलिमेंट के लिए पंक्ति और स्तंभ सूचकांक परस्पर बदल जाते हैं। किसी मैट्रिक्स का इनवर्स ऐसा मैट्रिक्स होता है, जिसे यदि मूल मैट्रिक्स से गुणा किया जाए, तो एक आइडेंटिटी मैट्रिक्स प्राप्त होता है।
लेकिन इन एट्रिब्यूट्स के अलावा, कुछ वास्तविक फ़ंक्शंस भी हैं जिनसे आप बुनियादी मैट्रिक्स रूटीन कर सकते हैं, जैसे ट्रांसपोज़ के लिए np.transpose() और मैट्रिक्स इनवर्स के लिए linalg.inv()।
इसके अलावा, आप मुख्य डायगोनल पर स्थित तत्वों का योग या ट्रेस np.trace() से प्राप्त कर सकते हैं। इसी प्रकार, आप NumPy के linalg.matrix_rank से मैट्रिक्स रैंक, यानी किसी एरे के Singular Value Decomposition के वे सिंगुलर वैल्यूज़ की संख्या जो किसी दिए गए थ्रेशहोल्ड से अधिक हों, भी प्राप्त कर सकते हैं।
अगर अभी मैट्रिक्स रैंक समझ न आए तो चिंता न करें; इस ट्यूटोरियल में आगे आप इसके बारे में और देखेंगे।
फ़िलहाल, दो और रूटीन पर ध्यान दें जिनका आप उपयोग कर सकते हैं:
linalg.norm से मैट्रिक्स का नॉर्म निकाला जा सकता है: मैट्रिक्स नॉर्म एक संख्या होती है जो मैट्रिक्स के एंट्रियों के आधार पर परिभाषित होती है। नॉर्म एक उपयोगी मात्रा है जो मैट्रिक्स के बारे में महत्वपूर्ण जानकारी देती है क्योंकि यह बताती है कि तत्व कितने बड़े हैं।
इसके अलावा, आप डिटरमिनेंट भी निकाल सकते हैं, जो एक उपयोगी मान है और किसी स्क्वेयर मैट्रिक्स के तत्वों से निकाला जाता है, linalg.det() के साथ। डिटरमिनेंट किसी स्क्वेयर मैट्रिक्स को एक एकल संख्या में समेट देता है, जो यह निर्धारित करती है कि वह स्क्वेयर मैट्रिक्स इनवर्टिबल है या नहीं।
अंत में, रैखिक समीकरणों की बड़ी प्रणालियों को हल करना मैट्रिक्स का सबसे बुनियादी अनुप्रयोगों में से एक है। यदि आपके पास \(Ax = b\) प्रणाली है, जहाँ \(A\) एक स्क्वेयर मैट्रिक्स है और \(b\) एक सामान्य मैट्रिक्स, तो आपके पास \(x\) निकालने के लिए दो तरीके हैं, जो इस पर निर्भर करते हैं कि आप किस प्रकार के मैट्रिक्स के साथ काम कर रहे हैं:
# Dense matrix solver
linalg.solve(A, b)
# Linear least-square solver
linalg.lstsq(F,E)
स्पार्स मैट्रिक्स को हल करने के लिए आप linalg.spsolve() का उपयोग कर सकते हैं। जब आप समीकरण हल नहीं कर पाते, तो linalg.lstsq() कमांड की मदद से \(x\) का एक नियतात्मक सन्निकटन प्राप्त करना संभव हो सकता है।
अब जबकि आपको अंदाज़ा हो गया है कि मैट्रिक्स कैसे बनाते हैं और उन्हें गणितीय ऑपरेशंस के लिए कैसे उपयोग करते हैं, अब कुछ और उन्नत विषयों पर चलते हैं, जिनकी आपको मशीन लर्निंग में वाकई उतरने के लिए ज़रूरत पड़ेगी।
ईजेनवैल्यूज़ और ईजेनवेक्टर्स
पहला विषय जिसे आप लेंगे, वे हैं ईजेनवैल्यूज़ और ईजेनवेक्टर्स।
ईजेनवैल्यूज़ मैट्रिक्स के केंद्र तक पहुँचने का नया तरीका देते हैं। लेकिन उससे पहले, आय़ए समझते हैं कि ईजेनवेक्टर्स क्या होते हैं। लगभग सभी वेक्टर किसी मैट्रिक्स से गुणा किए जाने पर दिशा बदलते हैं। हालाँकि, कुछ अपवादस्वरूप परिणामी वेक्टर, उस गुणा के बाद भी उसी दिशा में रहते हैं। यही ईजेनवेक्टर्स हैं।
दूसरे शब्दों में, किसी ईजेनवेक्टर को मैट्रिक्स से गुणा करें, और उस गुणन का परिणामी वेक्टर, मूल ईजेनवेक्टर और \(\lambda\) (ईजेनवैल्यू) के गुणन के बराबर होता है: \[Ax = \lambda x. \]
इसका मतलब है कि ईजेनवैल्यू बहुत मूल्यवान जानकारी देता है: यह बताता है कि किसी ईजेनवेक्टर को (मैट्रिक्स से गुणा करने पर) खींचा गया है, सिकुड़ा है, उलट गया है, या अपरिवर्तित रहा है।
# Solve eigenvalue problem
la, v = linalg.eig(myMatrix)
# Unpack eigenvalues
l1, l2 = la
# First eigenvector
v[:,0]
# Second eigenvector
v[:,1]
# Or unpack eigenvalues with `eigvals()`
linalg.eigvals(myMatrix)
आप linalg SciPy मॉड्यूल के eig() फ़ंक्शन का उपयोग स्क्वेयर मैट्रिक्स के साधारण या सामान्यीकृत ईजेनवैल्यू समस्याओं को हल करने के लिए करते हैं।
ध्यान दें कि eigvals() फ़ंक्शन मैट्रिक्स के ईजेनवैल्यूज़ निकालने का एक और तरीका है।
जब आप स्पार्स मैट्रिक्स के साथ काम कर रहे हों, तो आप scipy.sparse मॉड्यूल पर निर्भर कर सकते हैं, जो ईजेनवैल्यूज़ और ईजेनवेक्टर्स खोजने के लिए उपयुक्त फ़ंक्शंस देता है:
ध्यान दें कि ऊपर दिए गए कोड में यह निर्दिष्ट किया गया है कि कितने ईजेनवैल्यूज़ और ईजेनवेक्टर्स निकाले जाने हैं, यहाँ 1।
ईजेनवैल्यूज़ और ईजेनवेक्टर्स कंप्यूटर विज़न और मशीन लर्निंग की कई तकनीकों में महत्वपूर्ण अवधारणाएँ हैं, जैसे डायमेंशनलिटी रिडक्शन के लिए प्रिंसिपल कंपोनेंट एनालिसिस (PCA) और चेहरा पहचान के लिए EigenFaces।
सिंगुलर वैल्यू डीकंपोज़िशन (SVD)
अगला, यदि आप डेटा साइंस वाकई सीखना चाहते हैं, तो आपको SVD के बारे में जानना चाहिए। किसी मैट्रिक्स \(A\) का सिंगुलर वैल्यू डीकंपोज़िशन, \(A\) को तीन मैट्रिसेज़ के गुणन में तोड़ना या फैक्टराइज़ करना है: \(A = U * \Sigma * V^t\)।
यदि मैट्रिक्स \(A\) का साइज़ \(M\) x \(N\) है, तो व्यक्तिगत मैट्रिसेज़ के साइज़ इस प्रकार होंगे:
मैट्रिक्स \(U\) का साइज़ \(M\) x \(M\) होगा
मैट्रिक्स \(V\) का साइज़ \(N\) x \(N\) होगा
मैट्रिक्स \(\Sigma\) का साइज़ \(M\) x \(N\) होगा
\(*\) संकेत करता है कि मैट्रिसेज़ का गुणन हो रहा है और \(^t\) जिसे आप \(V^t\) में देखते हैं, बताता है कि मैट्रिक्स का ट्रांसपोज़ लिया गया है, यानी पंक्तियाँ और स्तंभ आपस में बदल दिए गए हैं।
सरल शब्दों में, सिंगुलर वैल्यू डीकंपोज़िशन किसी मैट्रिक्स को सरल, अर्थपूर्ण हिस्सों में तोड़ने का तरीका देता है। इन हिस्सों में वह डेटा हो सकता है जिसमें हमारी रुचि हो।
# Singular Value Decomposition
U,s,Vh = linalg.svd(myMatrix)
# Initialize `M` and `N`
M,N = myMatrix.shape
# Construct sigma matrix in SVD
Sig = linalg.diagsvd(s,M,N)
ध्यान दें कि स्पार्स मैट्रिक्स के लिए आप डीकंपोज़िशन करने के लिए sparse.linalg.svds() फ़ंक्शन का उपयोग कर सकते हैं।
यदि आप डेटा साइंस में नए हैं, तो यह मैट्रिक्स डीकंपोज़िशन आपको शुरू में अस्पष्ट लग सकता है: हो सकता है आपको तुरंत कोई अनुप्रयोग न दिखे। लेकिन SVD कई कार्यों में उपयोगी है, जैसे डेटा कंप्रेशन, शोर घटाना और डेटा विश्लेषण। आगे आप देखेंगे कि SVD का उपयोग इमेज कंप्रेशन में कैसे किया जा सकता है:
# Import the necessary packagesimport numpy as npfrom scipy import linalgfrom skimage import dataimport matplotlib.pyplot as plt# Get an image from`skimage`img= data.camera()# Check number of singular valueslinalg.svdvals(img)# Singular Value DecompositionU, s, Vh = linalg.svd(img)# Use only 32 singular valuesA = np.dot(U[:,0:32], np.dot(np.diag(s[0:32]), Vh[0:32,:]))fig = plt.figure(figsize=(8,3))# Add a subplot to the figureax = fig.add_subplot(121)# Plot `img` on grayscaleax.imshow(img, cmap='gray')# Add a second subplot to the figureax2 = fig.add_subplot(122)# Plot `A`in the second subplotax2.imshow(A)# Add a titlefig.suptitle('Image Compression with SVD', fontsize=14, fontweight='bold')# Show the plotplt.show()संचालित द्वारा
जिससे आपको नीचे जैसा परिणाम मिलेगा:
उन उदाहरणों पर भी विचार करें जहाँ SVD का उपयोग होता है:
SVD का प्रिंसिपल कंपोनेंट एनालिसिस (PCA) से गहरा संबंध है, जिसका उपयोग डायमेंशनलिटी रिडक्शन में होता है: दोनों का परिणाम “नई धुरियाँ” होती हैं जो आपके डेटा के फीचर स्पेस की धुरियों के रैखिक संयोजनों से निर्मित होती हैं। ये “नई धुरियाँ” डेटा बिंदुओं में वैरिएंस को प्रत्येक दिशा के योगदान के आधार पर विभाजित करती हैं। यह देखने के लिए कि PCA डेटा पर कैसे काम करता है, हमारा Scikit-Learn ट्यूटोरियल देखें।
एक और कड़ी डेटा माइनिंग और नेचुरल लैंग्वेज प्रोसेसिंग (NLP) से है: लैटेंट सेमैण्टिक इंडेक्सिंग (LSI)। यह एक तकनीक है जिसका उपयोग दस्तावेज़ पुनर्प्राप्ति और शब्द समानता में किया जाता है। लैटेंट सेमैण्टिक इंडेक्सिंग, SVD का उपयोग करती है ताकि दस्तावेज़ों को उन संकल्पनाओं से समूहित किया जा सके जो उन दस्तावेज़ों में पाए गए विभिन्न शब्दों से बन सकती हैं। विभिन्न शब्दों को एक संकल्पना में समूहित किया जा सकता है। यहाँ भी, SVD शब्दों और उनके दस्तावेज़ों के बीच शोरयुक्त सहसम्बंध को कम करती है और मूल डेटा के आयामों की संख्या घटाती है।
देखा, SVD आपके डेटा साइंस सफ़र में एक महत्वपूर्ण अवधारणा है जिसे आपको कवर करना चाहिए। इसलिए आपको इस ट्यूटोरियल से आगे जाकर SVD में गहराई से जाने पर विचार करना चाहिए: उदाहरण के लिए, इस मैट्रिक्स डीकंपोज़िशन के बारे में और पढ़ने के लिए इस पेज पर जाएँ।
आगे क्या?
आप ट्यूटोरियल के अंत तक पहुँच गए हैं! अब यहाँ से आगे आप कहाँ जाते हैं, यह पूरी तरह आप पर निर्भर है।
लेकिन ठहरिए!
उन कोर्सों को न चूकें जो रैखिक बीजगणित में और गहराई तक जाते हैं: यह ट्यूटोरियल केवल विषय का परिचय था और इसने सब कुछ कवर नहीं किया है!
Python के साथ डेटा विश्लेषण की बुनियादी बातें सिर्फ चार घंटे में सीखें। यह ऑनलाइन पाठ्यक्रम Python इंटरफ़ेस का परिचय देगा और लोकप्रिय पैकेजों का अन्वेषण करेगा।
मशीन लर्निंग में सचमुच गहराई से उतरने के लिए आपको जिन चीज़ों की ज़रूरत है, उनका बड़ा हिस्सा रेखीय बीजगणित है, और यही इस ट्यूटोरियल का विषय है। आज की पोस्ट उन रेखीय बीजगणित विषयों को कवर करती है जिन्हें समझना आपको यह अंतर्दृष्टि विकसित करने में मदद करेगा कि मशीन लर्निंग विधियाँ कैसे और कब काम करती हैं—वेक्टर और मैट्रिक्स के स्तर पर नज़र डालकर।
ट्यूटोरियल के अंत तक, उम्मीद है कि आप किसी एल्गोरिदम पर और करीब से नज़र डालने के लिए अधिक आत्मविश्वास महसूस करेंगे!
सामग्री
भूमिका
डेटा साइंस सीखना चाहते हैं तो जिन तीन बुनियादी विषयों में महारत ज़रूरी है, उनमें से एक मशीन लर्निंग है। और जब आप सच में मशीन लर्निंग पर उतरते हैं, तो यह ज़रूरी हो जाता है कि आप और गहराई में जाएँ और एल्गोरिदम कैसे काम करते हैं इसकी समझ और सहज बोध विकसित करें।
और मेरा मानना है कि आप, एक (उदीयमान) डेटा वैज्ञानिक, मुझसे सहमत होंगे कि इस मुकाम तक पहुँचना कठिन हो सकता है।
लेकिन ऐसा होना ज़रूरी नहीं।
SciPy बनाम NumPy
DataCamp के NumPy ट्यूटोरियल से आपने समझ लिया होगा कि यह लाइब्रेरी Python में वैज्ञानिक कंप्यूटिंग के लिए कोर लाइब्रेरियों में से एक है। इस लाइब्रेरी में टूल्स और तकनीकों का एक संग्रह है जिनका उपयोग विज्ञान और इंजीनियरिंग की समस्याओं के गणितीय मॉडलों को कंप्यूटर पर हल करने के लिए किया जा सकता है। लेकिन वह एक टूल जिसे आप सबसे ज़्यादा उपयोग करेंगे, एक उच्च-प्रदर्शन बहु-आयामी array ऑब्जेक्ट है: यह एक शक्तिशाली डेटा संरचना है जो आपको arrays और matrices को कुशलता से compute करने देती है।
अब, SciPy मूलतः NumPy पर आधारित है।
यह भी वैज्ञानिक कंप्यूटिंग के लिए कोर पैकेजों में से एक है जो गणितीय एल्गोरिदम और सुविधाजनक फ़ंक्शंस प्रदान करता है, लेकिन यह Python के NumPy एक्सटेंशन पर बना है। इसका मतलब है कि SciPy और NumPy अक्सर साथ में उपयोग किए जाते हैं!
आगे इस ट्यूटोरियल में, आपको स्पष्ट हो जाएगा कि इन दोनों लाइब्रेरियों के बीच सहयोग किस तरह स्वाभाविक हो गया है।
NumPy और SciPy के साथ इंटरैक्ट करें
दोनों पैकेज के साथ कुशलता से काम करने के लिए, पहले आपको इस लाइब्रेरी की कुछ बुनियादी बातें और इसकी शक्तिशाली डेटा संरचना के बारे में पता होना चाहिए। इन arrays के साथ काम करने के लिए, बहुत-सी उच्च-स्तरीय गणितीय फ़ंक्शंस हैं जो इन matrices और arrays पर ऑपरेट करती हैं।
आगे जो है, उसमें आपको उन विषयों का एक संक्षिप्त अवलोकन मिलेगा जिन्हें SciPy के साथ प्रभावी ढंग से काम करने के लिए समझना ज़रूरी है। मूल रूप से, आपको array संरचना, डेटा टाइप्स को संभालने और arrays के आकार (shape) को बदलने के तरीकों का ज्ञान होना चाहिए। अगर यह सब आपको नया लग रहा है, तो DataCamp का Python NumPy Tutorial देखें और सीखते समय NumPy चीट शीट पर एक नज़र ज़रूर डालें।
यदि आप यह सब पहले से जानते हैं, तो अगले सेक्शन को छोड़ दें और “Linear Algebra With SciPy” पर जाएँ, पर अपनी linear algebra के लिए SciPy चीट शीट तैयार रखें!
NumPy
ndarrayऑब्जेक्ट्स की मूल बातेंसंरचनात्मक रूप से, एक array मूलतः pointers का समूह है। यह एक memory address, data type, shape और strides का संयोजन होता है। इसमें raw डेटा, किसी तत्व का स्थान और उसकी व्याख्या करने का तरीका जैसी जानकारी होती है।
जब आप arrays के निम्न-स्तर के विवरण में जाते हैं तो memory address और strides महत्वपूर्ण होते हैं, जबकि data type और shape वे बातें हैं जिन्हें शुरुआती लोगों को ज़रूर समझना चाहिए। दो अन्य attributes जिन पर आप विचार करना चाहेंगे, वे हैं
dataऔरsize, जिनसे आप अपने array के बारे में और जानकारी ले सकते हैं।नीचे दिए गए DataCamp Light chunk में
ndarrayattributes के उपयोग को फिर से देखें। ArraymyArrayपहले से लोड है। आप इसे IPython shell में टाइप करके और ENTER दबाकर देख सकते हैं।ऊपर दिए गए code chunk के परिणामों में आप देखेंगे कि
myArrayका data typeint64है। जब आप arrays के साथ गहराई से काम करेंगे, तो आपको यह बात अवश्य याद रहेगी किastype()मेथड से एक data type से दूसरे में arrays को बदला जा सकता है।फिर भी, जब आप SciPy और NumPy को साथ में उपयोग करते हैं, तो निम्न type handling वाली NumPy फ़ंक्शंस भी उपयोगी लगेंगी, खासकर जब आप complex numbers के साथ काम कर रहे हों:
ऊपर दिए गए कोड के परिणाम देखने के लिए
print()कॉल जोड़कर देखें। तब आपको दिखेगा कि complex numbers में real और imaginary दोनों भाग होते हैं।np.real()औरnp.imag()फ़ंक्शंस क्रमशः ये भाग वापस लौटाने के लिए बनाए गए हैं।वैकल्पिक रूप से, आप
np.castका उपयोग करके किसी array ऑब्जेक्ट को किसी दूसरे data type में कास्ट कर सकते हैं, जैसे ऊपर के उदाहरण में float।ऊपर दिए कोड chunk में वास्तव में जो थोड़ा कठिन दिखता है, वह है
np.real_if_close()फ़ंक्शन। जब आप इसे कोई complex इनपुट देते हैं, जैसेmyArray, तो यदि complex भाग शून्य के क़रीब हैं, आपको एक real array वापस मिलेगा। “0 के क़रीब” की यह सीमा आप स्वयं फ़ंक्शन को दिए जाने वालेtolargument से समायोजित कर सकते हैं। थ्रेशहोल्ड के साथ खेलकर देखें कि क्या होता है!Array बनाना
अब आपने देख लिया है कि अपने array का निरीक्षण कैसे करें और उसके data type में बदलाव कैसे करें, लेकिन आपने स्पष्ट रूप से यह नहीं देखा कि arrays कैसे बनाए जाएँ। आपको पहले से पता होगा कि आप
np.array()का उपयोग कर सकते हैं, लेकिन array बनाने के लिए अन्य routines भी हैं जिनके बारे में आपको पता होना चाहिए:np.eye()औरnp.identity()।np.eye()फ़ंक्शन आपको उस धनात्मक पूर्णांक के बराबर आयामों वाली एक square मैट्रिक्स बनाने देता है जिसे आप फ़ंक्शन के argument के रूप में देते हैं। प्रविष्टियाँ सामान्यतः शून्य से भरी होती हैं, केवल मैट्रिक्स की विकर्ण (diagonal) एक से भरी होती है।np.identity()फ़ंक्शन भी इसी तरह काम करता है और एक identity array लौटाता है।हालाँकि, ध्यान दें कि
np.eye()एक अतिरिक्त argumentkले सकता है, जिसे आप उस diagonal के index को चुनने के लिए निर्धारित कर सकते हैं जिसे आप ones से भरना चाहते हैं।अन्य array निर्माण फ़ंक्शंस जो linear algebra की matrices के साथ काम करते समय निश्चित रूप से काम आएँगे, ये हैं:
np.arange()दो संख्याओं के बीच समान अंतर वाले मानों वाला array बनाता है। आप तत्वों के बीच की दूरी निर्धारित कर सकते हैं,np.linspace()पर भी लागू होती है, पर इस फ़ंक्शन में आप अपने array में तत्वों की संख्या निर्धारित करते हैं।np.logspace()भी समान अंतर वाले मानों के arrays बनाता है, लेकिन इस बार लघुगणकीय पैमाने पर। इसका अर्थ है कि spacing अब logarithmic है: दो संख्याएँ उनके base-10 logarithms के बीच समान दूरी पर होती हैं।ये फ़ंक्शंस meshes के रूप में arrays बनाते हैं, जिनका उपयोग mesh grids बनाने में किया जा सकता है, जिसके बारे में आप इस पोस्ट में पहले पढ़ चुके हैं।
ध्यान दें कि नीचे दिए गए code chunk में
numpyपहले सेnpके रूप में आयात है!अब जब आपने स्मृति ताज़ा कर ली है और जान लिया है कि arrays के data types को कैसे संभालना है, तो अब indexing और slicing के विषय पर भी बात करने का समय है।
Indexing और Slicing
Indexing में आप मूल रूप से square brackets
[]का उपयोग करके array मानों को index करते हैं। दूसरे शब्दों में, यदि आप किसी array के चुने हुए तत्वों—एक subset—तक पहुँचना चाहते हैं, तो आप indexing का उपयोग कर सकते हैं। अपने डेटा को slice करना subsetting जैसा ही है, लेकिन इसे थोड़ा अधिक उन्नत मान सकते हैं। जब आप किसी array को slice करते हैं, तो आप केवल अलग-अलग मानों पर नहीं, बल्कि “regions” के साथ काम करते हैं, न कि केवल “locations” के साथ।दोनों अवधारणाएँ नीचे दिए गए कोड उदाहरणों से फिर से देखें:
अब जब आपकी slicing और indexing की समझ ताज़ा हो गई है, तो आपको कुछ index ट्रिक्स में भी रुचि हो सकती है जो SciPy के साथ वैज्ञानिक कंप्यूटिंग करते समय आपके काम को और कुशल बना सकती हैं। चार फ़ंक्शंस अक्सर सामने आएँगी:
np.mgrid(),np.ogrid(),np.rऔरnp.c।यदि आपके पास NumPy का कुछ अनुभव है, तो आखिरी दो फ़ंक्शंस आप पहले से जानते होंगे।
np.rऔरnp.cका उपयोग क्रमशः row-wise या column-wise arrays को stack करने के लिए किया जाता है। इन फ़ंक्शंस की मदद से आपnp.concatenate()का उपयोग किए बिना जल्दी से arrays बना सकते हैं।इन चार फ़ंक्शंस में से पहले दो को देखते हुए, आप पूछ सकते हैं कि meshgrid की आवश्यकता क्यों पड़ेगी। आप meshgrids का उपयोग एक समकोण (rectilinear) ग्रिड की प्रत्येक स्थिति पर x- और y-निर्देशांक वाली दो arrays बनाने के लिए कर सकते हैं।
np.meshgrid()फ़ंक्शन दो 1D arrays लेता है और दो 2D मैट्रिसेस बनाता है जो उन दोनों arrays में (x, y) के सभी युग्मों के अनुरूप होती हैं।np.mgrid()MATLAB के meshgrid का एक कार्यान्वयन है और समान shape वाली arrays लौटाता है। इसका मतलब है कि आउटपुट arrays के आयामों और उनकी संख्या, indexing dimensions की संख्या के बराबर होते हैं।np.ogrid()एक open meshgrid देता है और उतना dense नहीं होता जितनाnp.mgrid()के परिणाम में होता है। ऊपर दिए गए code chunk में आप दोनों के बीच दृश्य अंतर देख सकते हैं।इन दोनों फ़ंक्शंस के बीच के अंतर के बारे में आप यहाँ भी पढ़ सकते हैं।
एक और फ़ंक्शन जिसका उपयोग आप indexing/slicing के उद्देश्य से कर सकते हैं, वह है
np.select()। आप इसका उपयोग conditions के आधार पर arrays की सूची से मान लौटाने के लिए कर सकते हैं। पहली argument में आप conditions निर्धारित करते हैं और दूसरी argument में वह array देते हैं जिसे आप इस चयन प्रक्रिया के लिए मानना चाहते हैं।निम्न उदाहरण देखें:
बहुत बढ़िया! अब जब आपने अपने मूल array के सही मान चुन लिए हैं, तो आप shape का चयन कर सकते हैं और अपने नए array को संशोधित कर सकते हैं।
Shape का चयन और हेरफेर
NumPy आपके arrays के shape को चुनने और उसे बदलने के अनेक तरीके देता है और संभवतः आप इनमें से कई पहले से जानते होंगे। निम्न सेक्शन केवल उन फ़ंक्शंस का संक्षिप्त अवलोकन देगा जो काम आ सकते हैं, इसलिए पोस्ट इन सबको विस्तार से कवर नहीं करती।
तो, क्या ऐसे फ़ंक्शंस हैं जो SciPy के साथ काम करते समय विशेष रूप से काम आते हैं?
हाँ, सबसे उपयोगी वे हैं जो arrays को flatten करने, stack करने और split करने में मदद करते हैं। आपने पहले ही
np.cऔरnp.rफ़ंक्शंस देख लिए हैं जिन्हें आप अक्सरnp.concatenate()के बजाय प्राथमिकता देंगे, लेकिन और भी कई हैं जिनके बारे में आपको पता होना चाहिए!जैसे
np.hstack()से अपने arrays को क्षैतिज रूप से stack करना याnp.vstack()से उन्हें ऊर्ध्वाधर रूप से stack करना। इसी तरह, आपnp.vsplit()औरnp.hsplit()का उपयोग क्रमशः ऊर्ध्वाधर और क्षैतिज रूप से arrays को विभाजित करने के लिए कर सकते हैं। लेकिन संभवतः आप यह सब पहले से जानते होंगे।इसे निम्न code chunk में साबित करें:
याद रखें कि
np.eye()फ़ंक्शन 2X2 identity array बनाता है, जो ऊपर दिए गए code chunk में आपके लिए लोड किए गए 2-D array के साथ stack करने के लिए बिल्कुल उपयुक्त है।यदि आप arrays को stack करने की शर्तों के बारे में अधिक जानना चाहते हैं, तो यहाँ जाएँ। हालाँकि, आप arrays और फ़ंक्शंस को देखकर भी यह सहज ज्ञान बना सकते हैं कि यदि आप दो arrays को row या column द्वारा जोड़ना चाहते हैं तो किन ‘नियमों’ का पालन करना है।
arrays को split करते समय सबसे महत्वपूर्ण बात संभवतः आपके array का shape है, क्योंकि आपको सही index चुनना होगा जहाँ आप split चाहते हैं।
arrays को stack और split करने वाली फ़ंक्शंस के अलावा, यह भी ध्यान रखें कि आपके पास ऐसे फ़ंक्शंस भी हैं जो यह सुनिश्चित करने में मदद करती हैं कि आप एक निश्चित आयाम (dimension) वाले arrays के साथ काम कर रहे हैं—जो वैज्ञानिक कंप्यूटिंग में गहराई तक जाते समय अनिवार्य हैं।
निम्न फ़ंक्शंस पर विचार करें:
ध्यान दें कि reshaping और resizing में अंतर है। पहले में आप डेटा का shape बदलते हैं पर डेटा स्वयं नहीं बदलता। जबकि resize करने पर, आपके चुने गए shape के आधार पर array में निहित डेटा बदल भी सकता है।
splitting और stacking routines तथा वे फ़ंक्शंस जो आपको अपने arrays में और हेरफेर करने देती हैं, इनके अलावा एक और चीज़ है जिसे आपको विचार में रखना चाहिए—“vectorization”। जब आप किसी फ़ंक्शन को किसी array पर लागू करते हैं, तो आमतौर पर वह array के प्रत्येक तत्व पर लागू होता है। उदाहरण के लिए, किसी array पर
np.cos(),np.sin()याnp.tan()लगाकर देखें। आप देखेंगे कि यह सभी तत्वों पर काम करता है। जब ऐसा होता है, तो आप समझ लें कि फ़ंक्शन vectorized है।लेकिन, जब आप स्वयं फ़ंक्शंस परिभाषित करते हैं, जैसा कि वैज्ञानिक कंप्यूटिंग में आप अक्सर करेंगे, तो आप उन्हें भी vectorize करना चाहेंगे। ऐसे मामलों में, आप
np.vectorize()को कॉल कर सकते हैं:अन्य vectorized गणितीय फ़ंक्शंस की बात करें जिन्हें आप जानना चाहेंगे, तो
np.angle()complex array तत्वों के कोण देने के लिए उपयोगी है, और बुनियादी त्रिकोणमितीय, घातीय (exponential) या लघुगणकीय (logarithmic) फ़ंक्शंस भी काम आएँगी।SciPy के साथ रैखिक बीजगणित
अब जबकि आप जानते हैं कि दोनों पैकेजों का लाभ कैसे उठाना है, तो इस ट्यूटोरियल के विषय, यानी रैखिक बीजगणित, में गहराई से जाने का समय है।
लेकिन Python का उपयोग कैसे करना है, इसमें जाने से पहले, सुनिश्चित कर लें कि आपका कार्यक्षेत्र पूरी तरह तैयार है!
SciPy इंस्टॉल करें
सबसे पहले यह सुनिश्चित करें कि आपके सिस्टम पर Python इंस्टॉल है। अगर अभी तक नहीं किया है, तो इस पेज पर जाएँ :) यदि आप Windows पर काम कर रहे हैं, तो सुनिश्चित करें कि आपने Python को PATH एनवायरनमेंट वेरिएबल में जोड़ा है। इसके अलावा,
pipजैसे पैकेज मैनेजर को इंस्टॉल करना न भूलें, जिससे आप Python की ओपन-सोर्स लाइब्रेरीज़ का उपयोग कर सकें।ध्यान दें कि Python 3 के हालिया संस्करणों में pip शामिल होता है, इसलिए जाँच लें कि यह मौजूद है और अगर है, तो अन्य पैकेज इंस्टॉल करने से पहले इसे अपग्रेड कर लें:
लेकिन केवल पैकेज मैनेजर इंस्टॉल करना पर्याप्त नहीं है; आपको लाइब्रेरी के लिए व्हील भी डाउनलोड करना होगा: अपना SciPy व्हील पाने के लिए यहाँ जाएँ। डाउनलोड के बाद, अपने पीसी पर डाउनलोड डायरेक्टरी में टर्मिनल खोलें और इसे इंस्टॉल करें। इसके अलावा, आप जाँच सकते हैं कि इंस्टॉलेशन सफल रहा या नहीं और आप कौन-सा पैकेज संस्करण चला रहे हैं, इसकी पुष्टि कर सकते हैं:
इन चरणों के बाद, आप तैयार हैं!
टिप: Anaconda Python डिस्ट्रीब्यूशन डाउनलोड करके पैकेज इंस्टॉल करें। यह तेज़ी से शुरू करने का आसान तरीका है, क्योंकि Anaconda में न केवल डेटा साइंस के लिए सबसे लोकप्रिय 100 Python, R और Scala पैकेज शामिल हैं, बल्कि Jupyter और Spyder जैसे कई ओपन कोर्स डेवलपमेंट एनवायरनमेंट भी शामिल हैं। यदि आप Jupyter Notebook के साथ काम शुरू करना चाहते हैं, तो यह Jupyter नोटबुक ट्यूटोरियल देखें।
यदि आपने इसे अभी तक डाउनलोड नहीं किया है, तो इसे पाने के लिए यहाँ जाएँ।
वेक्टर और मैट्रिक्स: मूल बातें
अब जबकि आपने सुनिश्चित कर लिया है कि आपका कार्यक्षेत्र तैयार है, आप अंततः Python में रैखिक बीजगणित के साथ शुरुआत कर सकते हैं। मूल रूप से, यह अनुशासन वेक्टर स्पेस और उनके बीच मौजूद रैखिक मैपिंग्स का अध्ययन करता है। इन रैखिक मैपिंग्स को मैट्रिक्स से व्यक्त किया जा सकता है, जिससे गणना भी आसान हो जाती है।
याद रखें कि वेक्टर स्पेस रैखिक बीजगणित में एक मौलिक अवधारणा है। यह वह स्पेस है जहाँ आपके पास वस्तुओं (वेक्टरों) का संग्रह होता है और जहाँ आप दो वेक्टरों को जोड़ या स्केल कर सकते हैं बिना इस कि परिणामी वेक्टर उस स्पेस से बाहर चला जाए। यह भी याद रखें कि वेक्टर किसी मैट्रिक्स की पंक्तियाँ (या स्तंभ) होते हैं।
लेकिन यह Python में कैसे काम करता है?
आप
np.array()फ़ंक्शन से आसानी से वेक्टर बना सकते हैं। इसी तरह, आप किसी भी एक- या दो-आयामीndarrayकोnp.matrix()याnp.mat()कमांड से मैट्रिक्स संरचना दे सकते हैं।इसे नीचे दिए गए कोड खंड में आज़माएँ:
तो क्या एरे और मैट्रिक्स एक जैसे ही हैं, बस फ़ॉर्मेटिंग अलग है?
बिल्कुल नहीं। कुछ अंतर हैं:
n-डी होते हैं,ndarrayका सबक्लास है,.T()होता है, लेकिन केवल मैट्रिक्स में.H()और.I()होता है,**ऑपरेशन के परिणाम मैट्रिक्स और एरे के लिए अलग होते हैंजब आप मैट्रिक्स के साथ काम कर रहे हों, तो कभी-कभी आपको ऐसे मैट्रिक्स मिलेंगे जिनमें अधिकांश तत्व शून्य होते हैं। इन्हें “स्पार्स मैट्रिक्स” कहते हैं, जबकि जिनमें अधिकांश गैर-शून्य तत्व हों, उन्हें “डेंस मैट्रिक्स” कहते हैं।
अपने आप में यह मामूली लग सकता है, पर जब आप रैखिक बीजगणित के लिए SciPy के साथ काम कर रहे होते हैं, तो कुछ चीजें करने के लिए आप जिन मॉड्यूल्स का उपयोग करते हैं, वे इससे प्रभावित हो सकते हैं। खास तौर पर, आप डेंस मैट्रिक्स के लिए
scipy.linalgका उपयोग कर सकते हैं, लेकिन जब आप स्पार्स मैट्रिक्स के साथ काम कर रहे हों, तोscipy.sparseमॉड्यूल को भी देखें, जिसमें अपनाscipy.sparse.linalgभी शामिल है।स्पार्स मैट्रिक्स बनाने के लिए कई विकल्प हैं। नीचे दिया गया कोड खंड कुछ विकल्पों को सूचीबद्ध करता है:
इसके अलावा, कुछ अन्य फ़ंक्शंस भी हैं जिनका उपयोग आप स्पार्स मैट्रिक्स बनाने के लिए कर सकते हैं:
bsr_matrix()से ब्लॉक स्पार्स रो मैट्रिक्स,coo_matrix()से COOrdinate फ़ॉर्मेट स्पार्स मैट्रिक्स,dia_matrix()से DIAgonal स्टोरेज स्पार्स मैट्रिक्स, औरlil_matrix()से रो-आधारित लिंक्ड लिस्ट स्पार्स मैट्रिक्स।विकल्प बहुत हैं, लेकिन अगर आप खुद स्पार्स मैट्रिक्स बना रहे हैं, तो किसे चुनें?
यह कठिन नहीं है।
मूल रूप से, सबसे पहले देखें कि आप इसे कैसे इनिशियलाइज़ करने वाले हैं। इसके बाद, सोचें कि आप अपने स्पार्स मैट्रिक्स के साथ क्या करने वाले हैं।
और ठोस रूप में, आप निम्नलिखित चेकलिस्ट से तय कर सकते हैं कि कौन-सा स्पार्स मैट्रिक्स प्रकार उपयोग करें:
coo_matrix()याdok_matrix()चुनें।dia_matrix()चुनें।lil_matrix()का उपयोग करें।bsr_matrix()इस्तेमाल करने पर विचार करें।csr_matrix()औरcsc_matrix()फ़ंक्शंस का उपयोग करके अपने मैट्रिक्स को कन्वर्ट करें। ये दोनों फ़ंक्शंस मैट्रिक्स इनिशियलाइज़ करने के लिए उपयुक्त नहीं हैं, लेकिन गुणा करते समय आप निश्चित रूप से गति में अंतर देखेंगे।बिल्कुल आसान!
वेक्टर ऑपरेशंस
अब जब आपने वेक्टर, डेंस मैट्रिक्स और स्पार्स मैट्रिक्स के बीच अंतर सीखा या ताज़ा किया है, तो अब वेक्टरों पर करीब से नज़र डालने और उन पर किए जा सकने वाले गणितीय ऑपरेशंस को देखने का समय है। यह ट्यूटोरियल यहाँ विशेष रूप से गणितीय ऑपरेशंस पर ध्यान केंद्रित करता है ताकि आप मैट्रिक्स के साथ समानताओं और अंतरों को देख सकें, और क्योंकि रैखिक बीजगणित का बड़ा हिस्सा अंततः मैट्रिक्स के साथ काम करना ही है।
आप पहले ही देख चुके हैं कि आप
np.array()से आसानी से वेक्टर बना सकते हैं। लेकिन अब जब आपके पास वेक्टर हैं, तो आप उन पर किए जा सकने वाले कुछ बुनियादी ऑपरेशंस भी जानना चाहेंगे। नीचे दिए गए कोड खंड मेंvector1औरvector2पहले से लोड हैं:अब जब आपने कुछ वेक्टर ऑपरेशंस देख लिए हैं, तो अब असली मैट्रिक्स वाले काम पर आगे बढ़ते हैं!
मैट्रिक्स: ऑपरेशंस और रूटीन
जैसे आप पिछला सेक्शन शुरू में छोड़कर आए थे, वैसे ही यहाँ भी आपको पता है कि मैट्रिक्स कैसे बनाते हैं, लेकिन अभी यह नहीं जानते कि उन्हें अपने लाभ के लिए कैसे उपयोग करें। यह सेक्शन आपको कुछ मैट्रिक्स फ़ंक्शंस और बुनियादी मैट्रिक्स रूटीन का एक अवलोकन देगा, जिनसे आप कुशलतापूर्वक काम कर सकते हैं।
सबसे पहले, कुछ फ़ंक्शंस पर चलते हैं। यदि आपने पहले NumPy के साथ काम किया है, तो ये काफ़ी सहज लगेंगे, और यदि अनुभव नहीं भी है, तो भी आप देखेंगे कि इन्हें शुरू करना आसान है।
आइए कुछ फ़ंक्शंस के उदाहरण देखते हैं।
एरे या मैट्रिसेज़ को जोड़ने और घटाने के लिए
np.add()औरnp.subtract()हैं, और भाग देने व गुणा करने के लिएnp.divide()औरnp.multiply। यह कोई बड़ा रहस्य नहीं लगता, है न? साथ हीnp.dot()फ़ंक्शन, जिसे आपने पिछले सेक्शन में डॉट प्रोडक्ट निकालने के लिए देखा था, मैट्रिक्स के साथ भी उपयोग किया जा सकता है। लेकिन ध्यान रखें कि यहाँ वेक्टरों की जगह दो मैट्रिक्स पास करें।ये तो बुनियादी हैं, सही?
अब थोड़े कम बुनियादी बनें। गुणन के मामले में आप कुछ और फ़ंक्शंस पर भी विचार कर सकते हैं, जैसे वेक्टरों के डॉट प्रोडक्ट के लिए
np.vdot(), एरे के इनर या आउटर प्रोडक्ट के लिएnp.inner()याnp.outer(), और दो एरे के क्रोनेकर प्रोडक्ट के लिएnp.tensordot()औरnp.kron():टिप: ऊपर के कोड खंड में प्रिंट स्टेटमेंट्स जोड़ें ताकि आपको हर प्रोडक्ट का परिणाम दिखे।
इनके अलावा,
linalgमॉड्यूल के कुछ फ़ंक्शंस पर भी विचार करना उपयोगी हो सकता है: मैट्रिक्स एक्सपोनेंशियल फ़ंक्शंसlinalg.expm(),linalg.expm2()औरlinalg.expm3()। इन तीनों के बीच अंतर एक्सपोनेंशियल की गणना के तरीकों में है। सामान्य मैट्रिक्स एक्सपोनेंशियल के लिए पहले वाले पर टिके रहें, लेकिन तीनों को आज़माकर परिणामों का फर्क देखना निश्चित रूप से उपयोगी है!साथ ही त्रिकोणमितीय फ़ंक्शंस जैसे
linalg.cosm(),linalg.sinm()औरlinalg.tanm(), हाइपरबोलिक त्रिकोणमितीय फ़ंक्शंस जैसेlinalg.coshm(),linalg.sinhm()औरlinalg.tanhm(), साइन फ़ंक्शनlinalg.signm(), मैट्रिक्स लॉगरिद्मlinalg.logm(), और मैट्रिक्स वर्गमूलlinalg.sqrtm()।इसके अतिरिक्त, आप
linalg.funm()फ़ंक्शन की मदद से किसी मैट्रिक्स फ़ंक्शन का मान भी निकाल सकते हैं। नीचे दिया गया उदाहरण देखें:आप देखते हैं कि पहले आर्ग्युमेंट के रूप में वह मैट्रिक्स पास करते हैं जिस पर आप फ़ंक्शन लगाना चाहते हैं और दूसरा आर्ग्युमेंट वह फ़ंक्शन (यहाँ lambda फ़ंक्शन) होता है जिसे आप पास किए गए मैट्रिक्स पर अप्लाई करना चाहते हैं। ध्यान दें कि
linalg.funm()को जो फ़ंक्शन पास करते हैं, वह वेक्टराइज़्ड होना चाहिए।अब कुछ बुनियादी मैट्रिक्स रूटीन पर नज़र डालते हैं। पहली चीज़ जो आप शायद देखना चाहेंगे, वे हैं मैट्रिक्स एट्रिब्यूट्स: ट्रांसपोज़ के लिए
T, कॉन्जुगेट ट्रांसपोज़ के लिएH, इनवर्स के लिएI, और एरे में कास्ट करने के लिएA।इन्हें आज़माएँ:
जब आप किसी मैट्रिक्स का ट्रांसपोज़ करते हैं, तो आप एक नया मैट्रिक्स बनाते हैं जिसकी पंक्तियाँ मूल मैट्रिक्स के स्तंभ होते हैं। दूसरी ओर, कॉन्जुगेट ट्रांसपोज़ में हर मैट्रिक्स एलिमेंट के लिए पंक्ति और स्तंभ सूचकांक परस्पर बदल जाते हैं। किसी मैट्रिक्स का इनवर्स ऐसा मैट्रिक्स होता है, जिसे यदि मूल मैट्रिक्स से गुणा किया जाए, तो एक आइडेंटिटी मैट्रिक्स प्राप्त होता है।
लेकिन इन एट्रिब्यूट्स के अलावा, कुछ वास्तविक फ़ंक्शंस भी हैं जिनसे आप बुनियादी मैट्रिक्स रूटीन कर सकते हैं, जैसे ट्रांसपोज़ के लिए
np.transpose()और मैट्रिक्स इनवर्स के लिएlinalg.inv()।इसके अलावा, आप मुख्य डायगोनल पर स्थित तत्वों का योग या ट्रेस
np.trace()से प्राप्त कर सकते हैं। इसी प्रकार, आप NumPy केlinalg.matrix_rankसे मैट्रिक्स रैंक, यानी किसी एरे के Singular Value Decomposition के वे सिंगुलर वैल्यूज़ की संख्या जो किसी दिए गए थ्रेशहोल्ड से अधिक हों, भी प्राप्त कर सकते हैं।अगर अभी मैट्रिक्स रैंक समझ न आए तो चिंता न करें; इस ट्यूटोरियल में आगे आप इसके बारे में और देखेंगे।
फ़िलहाल, दो और रूटीन पर ध्यान दें जिनका आप उपयोग कर सकते हैं:
linalg.normसे मैट्रिक्स का नॉर्म निकाला जा सकता है: मैट्रिक्स नॉर्म एक संख्या होती है जो मैट्रिक्स के एंट्रियों के आधार पर परिभाषित होती है। नॉर्म एक उपयोगी मात्रा है जो मैट्रिक्स के बारे में महत्वपूर्ण जानकारी देती है क्योंकि यह बताती है कि तत्व कितने बड़े हैं।linalg.det()के साथ। डिटरमिनेंट किसी स्क्वेयर मैट्रिक्स को एक एकल संख्या में समेट देता है, जो यह निर्धारित करती है कि वह स्क्वेयर मैट्रिक्स इनवर्टिबल है या नहीं।अंत में, रैखिक समीकरणों की बड़ी प्रणालियों को हल करना मैट्रिक्स का सबसे बुनियादी अनुप्रयोगों में से एक है। यदि आपके पास \(Ax = b\) प्रणाली है, जहाँ \(A\) एक स्क्वेयर मैट्रिक्स है और \(b\) एक सामान्य मैट्रिक्स, तो आपके पास \(x\) निकालने के लिए दो तरीके हैं, जो इस पर निर्भर करते हैं कि आप किस प्रकार के मैट्रिक्स के साथ काम कर रहे हैं:
स्पार्स मैट्रिक्स को हल करने के लिए आप
linalg.spsolve()का उपयोग कर सकते हैं। जब आप समीकरण हल नहीं कर पाते, तोlinalg.lstsq()कमांड की मदद से \(x\) का एक नियतात्मक सन्निकटन प्राप्त करना संभव हो सकता है।टिप: DataCamp का SciPy चीट शीट न चूकें।
अब जबकि आपको अंदाज़ा हो गया है कि मैट्रिक्स कैसे बनाते हैं और उन्हें गणितीय ऑपरेशंस के लिए कैसे उपयोग करते हैं, अब कुछ और उन्नत विषयों पर चलते हैं, जिनकी आपको मशीन लर्निंग में वाकई उतरने के लिए ज़रूरत पड़ेगी।
ईजेनवैल्यूज़ और ईजेनवेक्टर्स
पहला विषय जिसे आप लेंगे, वे हैं ईजेनवैल्यूज़ और ईजेनवेक्टर्स।
ईजेनवैल्यूज़ मैट्रिक्स के केंद्र तक पहुँचने का नया तरीका देते हैं। लेकिन उससे पहले, आय़ए समझते हैं कि ईजेनवेक्टर्स क्या होते हैं। लगभग सभी वेक्टर किसी मैट्रिक्स से गुणा किए जाने पर दिशा बदलते हैं। हालाँकि, कुछ अपवादस्वरूप परिणामी वेक्टर, उस गुणा के बाद भी उसी दिशा में रहते हैं। यही ईजेनवेक्टर्स हैं।
दूसरे शब्दों में, किसी ईजेनवेक्टर को मैट्रिक्स से गुणा करें, और उस गुणन का परिणामी वेक्टर, मूल ईजेनवेक्टर और \(\lambda\) (ईजेनवैल्यू) के गुणन के बराबर होता है: \[Ax = \lambda x. \]
इसका मतलब है कि ईजेनवैल्यू बहुत मूल्यवान जानकारी देता है: यह बताता है कि किसी ईजेनवेक्टर को (मैट्रिक्स से गुणा करने पर) खींचा गया है, सिकुड़ा है, उलट गया है, या अपरिवर्तित रहा है।
आप
linalgSciPy मॉड्यूल केeig()फ़ंक्शन का उपयोग स्क्वेयर मैट्रिक्स के साधारण या सामान्यीकृत ईजेनवैल्यू समस्याओं को हल करने के लिए करते हैं।ध्यान दें कि
eigvals()फ़ंक्शन मैट्रिक्स के ईजेनवैल्यूज़ निकालने का एक और तरीका है।जब आप स्पार्स मैट्रिक्स के साथ काम कर रहे हों, तो आप
scipy.sparseमॉड्यूल पर निर्भर कर सकते हैं, जो ईजेनवैल्यूज़ और ईजेनवेक्टर्स खोजने के लिए उपयुक्त फ़ंक्शंस देता है:ध्यान दें कि ऊपर दिए गए कोड में यह निर्दिष्ट किया गया है कि कितने ईजेनवैल्यूज़ और ईजेनवेक्टर्स निकाले जाने हैं, यहाँ 1।
ईजेनवैल्यूज़ और ईजेनवेक्टर्स कंप्यूटर विज़न और मशीन लर्निंग की कई तकनीकों में महत्वपूर्ण अवधारणाएँ हैं, जैसे डायमेंशनलिटी रिडक्शन के लिए प्रिंसिपल कंपोनेंट एनालिसिस (PCA) और चेहरा पहचान के लिए EigenFaces।
सिंगुलर वैल्यू डीकंपोज़िशन (SVD)
अगला, यदि आप डेटा साइंस वाकई सीखना चाहते हैं, तो आपको SVD के बारे में जानना चाहिए। किसी मैट्रिक्स \(A\) का सिंगुलर वैल्यू डीकंपोज़िशन, \(A\) को तीन मैट्रिसेज़ के गुणन में तोड़ना या फैक्टराइज़ करना है: \(A = U * \Sigma * V^t\)।
यदि मैट्रिक्स \(A\) का साइज़ \(M\) x \(N\) है, तो व्यक्तिगत मैट्रिसेज़ के साइज़ इस प्रकार होंगे:
\(*\) संकेत करता है कि मैट्रिसेज़ का गुणन हो रहा है और \(^t\) जिसे आप \(V^t\) में देखते हैं, बताता है कि मैट्रिक्स का ट्रांसपोज़ लिया गया है, यानी पंक्तियाँ और स्तंभ आपस में बदल दिए गए हैं।
सरल शब्दों में, सिंगुलर वैल्यू डीकंपोज़िशन किसी मैट्रिक्स को सरल, अर्थपूर्ण हिस्सों में तोड़ने का तरीका देता है। इन हिस्सों में वह डेटा हो सकता है जिसमें हमारी रुचि हो।
ध्यान दें कि स्पार्स मैट्रिक्स के लिए आप डीकंपोज़िशन करने के लिए
sparse.linalg.svds()फ़ंक्शन का उपयोग कर सकते हैं।यदि आप डेटा साइंस में नए हैं, तो यह मैट्रिक्स डीकंपोज़िशन आपको शुरू में अस्पष्ट लग सकता है: हो सकता है आपको तुरंत कोई अनुप्रयोग न दिखे। लेकिन SVD कई कार्यों में उपयोगी है, जैसे डेटा कंप्रेशन, शोर घटाना और डेटा विश्लेषण। आगे आप देखेंगे कि SVD का उपयोग इमेज कंप्रेशन में कैसे किया जा सकता है:
जिससे आपको नीचे जैसा परिणाम मिलेगा:
उन उदाहरणों पर भी विचार करें जहाँ SVD का उपयोग होता है:
देखा, SVD आपके डेटा साइंस सफ़र में एक महत्वपूर्ण अवधारणा है जिसे आपको कवर करना चाहिए। इसलिए आपको इस ट्यूटोरियल से आगे जाकर SVD में गहराई से जाने पर विचार करना चाहिए: उदाहरण के लिए, इस मैट्रिक्स डीकंपोज़िशन के बारे में और पढ़ने के लिए इस पेज पर जाएँ।
आगे क्या?
आप ट्यूटोरियल के अंत तक पहुँच गए हैं! अब यहाँ से आगे आप कहाँ जाते हैं, यह पूरी तरह आप पर निर्भर है।
लेकिन ठहरिए!
उन कोर्सों को न चूकें जो रैखिक बीजगणित में और गहराई तक जाते हैं: यह ट्यूटोरियल केवल विषय का परिचय था और इसने सब कुछ कवर नहीं किया है!
बेशक, DataCamp का मशीन लर्निंग ट्यूटोरियल करने पर भी विचार करें, जो इस रैखिक बीजगणित पर आधारित Scipy ट्यूटोरियल के बाद आपकी लर्निंग करिकुलम में निश्चित रूप से मूल्य जोड़ेगा। लेकिन, यदि आप बुनियाद पर लौटना चाहते हैं, तो हमारा NumPy ट्यूटोरियल या Intermediate Python for Data Science कोर्स देखें।