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 के विषय पर भी बात करने का समय है।

# 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]])

# 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]

# 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])

#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))

#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)))

# 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)

SciPy इंस्टॉल करें

सबसे पहले यह सुनिश्चित करें कि आपके सिस्टम पर Python इंस्टॉल है। अगर अभी तक नहीं किया है, तो इस पेज पर जाएँ :) यदि आप Windows पर काम कर रहे हैं, तो सुनिश्चित करें कि आपने Python को PATH एनवायरनमेंट वेरिएबल में जोड़ा है। इसके अलावा, pip जैसे पैकेज मैनेजर को इंस्टॉल करना न भूलें, जिससे आप Python की ओपन-सोर्स लाइब्रेरीज़ का उपयोग कर सकें।

ध्यान दें कि Python 3 के हालिया संस्करणों में pip शामिल होता है, इसलिए जाँच लें कि यह मौजूद है और अगर है, तो अन्य पैकेज इंस्टॉल करने से पहले इसे अपग्रेड कर लें:

 pip install pip --upgrade pip --versionसंचालित द्वारा

लेकिन केवल पैकेज मैनेजर इंस्टॉल करना पर्याप्त नहीं है; आपको लाइब्रेरी के लिए व्हील भी डाउनलोड करना होगा: अपना 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 भी शामिल है।

स्पार्स मैट्रिक्स बनाने के लिए कई विकल्प हैं। नीचे दिया गया कोड खंड कुछ विकल्पों को सूचीबद्ध करता है:

# Create a 2X2 identity matrix
np.eye(3, k=1)        

# Create a 2x2 identity matrix
np.mat(np.identity(2))         

# Compressed Sparse Row matrix
sparse.csr_matrix(C)  

# Compressed Sparse Column matrix
sparse.csc_matrix(C)  

# Dictionary Of Keys matrix
sparse.dok_matrix(C)  

इसके अलावा, कुछ अन्य फ़ंक्शंस भी हैं जिनका उपयोग आप स्पार्स मैट्रिक्स बनाने के लिए कर सकते हैं: bsr_matrix() से ब्लॉक स्पार्स रो मैट्रिक्स, coo_matrix() से COOrdinate फ़ॉर्मेट स्पार्स मैट्रिक्स, dia_matrix() से DIAgonal स्टोरेज स्पार्स मैट्रिक्स, और lil_matrix() से रो-आधारित लिंक्ड लिस्ट स्पार्स मैट्रिक्स।

विकल्प बहुत हैं, लेकिन अगर आप खुद स्पार्स मैट्रिक्स बना रहे हैं, तो किसे चुनें?

यह कठिन नहीं है।

मूल रूप से, सबसे पहले देखें कि आप इसे कैसे इनिशियलाइज़ करने वाले हैं। इसके बाद, सोचें कि आप अपने स्पार्स मैट्रिक्स के साथ क्या करने वाले हैं।

और ठोस रूप में, आप निम्नलिखित चेकलिस्ट से तय कर सकते हैं कि कौन-सा स्पार्स मैट्रिक्स प्रकार उपयोग करें:

• यदि आप मैट्रिक्स को एक-एक करके संख्याएँ भरकर बनाना चाहते हैं, तो coo_matrix() या dok_matrix() चुनें।
• यदि आप मैट्रिक्स को एक एरे को डायगोनल के रूप में लेकर इनिशियलाइज़ करना चाहते हैं, तो dia_matrix() चुनें।
• स्लाइस-आधारित मैट्रिक्स के लिए, lil_matrix() का उपयोग करें।
• यदि आप छोटे मैट्रिक्स के ब्लॉक्स से मैट्रिक्स बना रहे हैं, तो bsr_matrix() इस्तेमाल करने पर विचार करें।
• यदि आप अपनी पंक्तियों और स्तंभों तक तेज़ी से पहुँच चाहते हैं, तो क्रमशः csr_matrix() और csc_matrix() फ़ंक्शंस का उपयोग करके अपने मैट्रिक्स को कन्वर्ट करें। ये दोनों फ़ंक्शंस मैट्रिक्स इनिशियलाइज़ करने के लिए उपयुक्त नहीं हैं, लेकिन गुणा करते समय आप निश्चित रूप से गति में अंतर देखेंगे।

बिल्कुल आसान!

# 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(____________)

# Vector dot product
vectorDotProduct = np.vdot(vector1, vector2)

# Inner product
innerProduct = np.inner(vector1, vector2)

# Outer product
outerProduct = np.outer(vector1, vector2)

# Tensor dot product
tensorDotProduct = np.tensordot(matrix1, matrix2)

# Kronecker product
kronProduct = np.kron(matrix1, matrix2)

linalg.funm(myMatrix, lambda x: x*x)

# Transposition
myMatrix._

# Conjugate transposition
myMatrix._

# Inverse
myMatrix._

# Array
myMatrix._

# Dense matrix solver
linalg.solve(A, b)

# Linear least-square solver
linalg.lstsq(F,E)

ईजेनवैल्यूज़ और ईजेनवेक्टर्स

पहला विषय जिसे आप लेंगे, वे हैं ईजेनवैल्यूज़ और ईजेनवेक्टर्स।

ईजेनवैल्यूज़ मैट्रिक्स के केंद्र तक पहुँचने का नया तरीका देते हैं। लेकिन उससे पहले, आय़ए समझते हैं कि ईजेनवेक्टर्स क्या होते हैं। लगभग सभी वेक्टर किसी मैट्रिक्स से गुणा किए जाने पर दिशा बदलते हैं। हालाँकि, कुछ अपवादस्वरूप परिणामी वेक्टर, उस गुणा के बाद भी उसी दिशा में रहते हैं। यही ईजेनवेक्टर्स हैं।

दूसरे शब्दों में, किसी ईजेनवेक्टर को मैट्रिक्स से गुणा करें, और उस गुणन का परिणामी वेक्टर, मूल ईजेनवेक्टर और \(\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 मॉड्यूल पर निर्भर कर सकते हैं, जो ईजेनवैल्यूज़ और ईजेनवेक्टर्स खोजने के लिए उपयुक्त फ़ंक्शंस देता है:

la, v = sparse.linalg.eigs(myMatrix,1)संचालित द्वारा

ध्यान दें कि ऊपर दिए गए कोड में यह निर्दिष्ट किया गया है कि कितने ईजेनवैल्यूज़ और ईजेनवेक्टर्स निकाले जाने हैं, यहाँ 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 में गहराई से जाने पर विचार करना चाहिए: उदाहरण के लिए, इस मैट्रिक्स डीकंपोज़िशन के बारे में और पढ़ने के लिए इस पेज पर जाएँ।