Python शुरुआती लोगों के लिए नम्पाय ट्यूटोरियल

NumPy क्या है? Python?

Numpy एक खुला स्रोत Python यह गणितीय, वैज्ञानिक, इंजीनियरिंग और डेटा साइंस प्रोग्रामिंग के लिए एक लाइब्रेरी है। यह गणितीय और सांख्यिकीय कार्यों के लिए एक बहुत ही उपयोगी लाइब्रेरी है। Pythonयह बहु-आयामी सरणियों और मैट्रिक्स गुणन के साथ पूरी तरह से काम करता है, और C के साथ आसानी से एकीकृत हो जाता है।C++ और Fortran.

किसी भी वैज्ञानिक परियोजना के लिए, NumPy एक उपयोगी उपकरण है। यह N-आयामी सरणी, रैखिक बीजगणित, यादृच्छिक संख्या निर्माण, फूरियर रूपांतरण और अन्य कार्यों के लिए बनाया गया है।

NumPy देता है Python बहु-आयामी सरणियों और मैट्रिक्स के लिए प्रथम श्रेणी का समर्थन, साथ ही उन पर कार्य करने वाले गणितीय संक्रियाओं का एक बड़ा समूह। इस गाइड में, हम उन आवश्यक कार्यों की समीक्षा करेंगे जिन्हें आपको 'ट्यूटोरियल' पर आगे बढ़ने से पहले जानना आवश्यक है।TensorFlow'.

NumPy का उपयोग क्यों करें?

NumPy मेमोरी के मामले में कुशल है, इसलिए यह शुद्ध प्रोग्रामिंग विधियों की तुलना में बड़ी मात्रा में संख्यात्मक डेटा को अधिक आसानी से संभाल सकता है। Python सूचियों के लिए भी यह बहुत सुविधाजनक है। मैट्रिक्स गुणन और पुनर्व्यवस्थापन के लिए भी यह बहुत उपयोगी है।pingऔर यह तेज़ है क्योंकि भारी काम संकलित C रूटीन को सौंप दिया जाता है। वास्तव में, TensorFlow, Py जैसी लाइब्रेरीज़Torch और Scikit-learn अपने बैकएंड में मैट्रिक्स गणित के लिए NumPy एरे पर निर्भर करते हैं, जो NumPy को अधिकांश आधुनिक डेटा साइंस और AI वर्कफ़्लो के अंतर्गत एक मूक प्रेरक शक्ति बनाता है।

NumPy कैसे स्थापित करें

NumPy लाइब्रेरी को इंस्टॉल करने के लिए, हमारे ट्यूटोरियल को देखें। TensorFlow कैसे स्थापित करें.NumPy डिफ़ॉल्ट रूप से Anaconda के साथ स्थापित है।

यदि दुर्लभ स्थिति में NumPy स्थापित नहीं है, तो नीचे दिए गए विकल्पों में से किसी एक का उपयोग करें।

आप एनाकोंडा का उपयोग करके NumPy स्थापित कर सकते हैं:

conda install -c anaconda numpy

• In Jupyter स्मरण पुस्तक:

import sys
!conda install --yes --prefix {sys.prefix} numpy

Pip उपयोगकर्ता एक ही कमांड से इंस्टॉल या अपग्रेड कर सकते हैं:

pip install --upgrade numpy

NumPy आयात करें और संस्करण जांचें

Numpy को आयात करने का आदेश है:

import numpy as np

ऊपर दी गई पंक्ति NumPy नेमस्पेस का नाम बदल देती है npयह शॉर्टकट आपको NumPy फ़ंक्शंस, मेथड्स और एट्रिब्यूट्स में उपसर्ग जोड़ने की सुविधा देता है। np. ty के बजायping numpy.और यह वह मानक परंपरा है जो आपको पूरे नम्पी इकोसिस्टम में मिलेगी।

अपने सिस्टम में NumPy का जो संस्करण स्थापित है, उसे जांचने के लिए नीचे दिए गए कमांड का उपयोग करें:

print(np.__version__)

आउटपुट:

2.1.3

NumPy 2.0 जून 2024 में जारी किया गया था और यह वर्तमान में स्थिर प्रमुख श्रृंखला है। यदि आपका प्रोजेक्ट अभी भी 1.x API पर निर्भर करता है, तो इसे पिन करें। numpy<2 अपनी आवश्यकताओं की फ़ाइल में, क्योंकि कुछ पुराने उपनाम जैसे कि np.float इन्हें 2.0 में हटा दिया गया था।

क्या है एक Python NumPy सरणी?

NumPy एरे कुछ इस तरह दिखते हैं Python पहली नज़र में ndarray सूचियाँ लगती हैं, लेकिन इनका व्यवहार बहुत अलग होता है। इस विषय से अपरिचित पाठकों के लिए, आइए स्पष्ट करते हैं कि ndarray क्या है और यह क्यों महत्वपूर्ण है।

जैसा कि नाम से ही स्पष्ट है, NumPy ऐरे NumPy लाइब्रेरी की केंद्रीय डेटा संरचना है। यह नाम "न्यूमेरिक" का संक्षिप्त रूप है। Python” या “संख्यात्मक Pythonऔर ndarray एक समरूप, निश्चित आकार का मेमोरी ब्लॉक है जिसका आकार और डेटा प्रकार ज्ञात होता है।

एक NumPy सारणी बनाना

NumPy में ऐरे बनाने का सबसे सरल तरीका एक ऐरे से शुरू करना है। Python सूची.

myPythonList = [1,9,8,3]

बदलना Python सूची को NumPy सरणी में परिवर्तित करना np.array.

numpy_array_from_list = np.array(myPythonList)

ऐरे की सामग्री प्रदर्शित करें।

numpy_array_from_list

आउटपुट:

array([1, 9, 8, 3])

व्यवहार में, किसी भी प्रकार की घोषणा करने की आवश्यकता नहीं होती है। Python पहले सूची बनाएं। इन दोनों चरणों को एक साथ किया जा सकता है।

a = np.array([1,9,8,3])

नोट: NumPy के दस्तावेज़ में भी इसका उल्लेख है। np.ndarray, परंतु np.array यह रोजमर्रा के उपयोग के लिए अनुशंसित फ़ैक्टरी फ़ंक्शन है।

आप इसी तरह से टपल से नम्पी ऐरे भी बना सकते हैं।

गणितीय Operaएक सरणी पर tions

आप जोड़, घटाव जैसी गणितीय क्रियाएं कर सकते हैं।tracकिसी ऐरे पर भाग, विभाजन और गुणा करने की विधि। इसका सिंटैक्स ऐरे का नाम है, जिसके बाद ऑपरेटर (+, -, *, /), इसके बाद ऑपरेंड आता है। ये ऑपरेशन वेक्टरयुक्त होते हैं, जिसका अर्थ है कि NumPy इन्हें बिना किसी स्पष्ट निर्देश के प्रत्येक तत्व पर लागू करता है। Python पाश।

उदाहरण:

numpy_array_from_list + 10

आउटपुट:

array([11, 19, 18, 13])

यह ऑपरेशन NumPy ऐरे के प्रत्येक तत्व में 10 जोड़ता है।

सरणी का आकार

आप ऐरे के आकार की जाँच निम्न विधि से कर सकते हैं: shape एट्रिब्यूट को एरे नाम में जोड़कर एक्सेस किया जाता है। इसी तरह, आप टाइप की जांच कर सकते हैं। dtype.

import numpy as np
a = np.array([1,2,3])
print(a.shape)
print(a.dtype)

(3,)
int64

पूर्णांक एक ऐसा मान है जिसमें दशमलव बिंदु नहीं होता है। यदि आप दशमलव वाले मानों के साथ एक ऐरे बनाते हैं, तो उसका डेटाटाइप फ्लोट में बदल जाता है।

#### Different type
b = np.array([1.1,2.0,3.2])
print(b.dtype)

float64

2 आयाम सरणी

आप कोष्ठकों के अंदर अल्पविराम लगाकर एक आयाम जोड़ सकते हैं।

ध्यान दें कि आंतरिक टुपल्स को बाहरी कोष्ठकों के अंदर होना चाहिए। [].

### 2 dimension
c = np.array([(1,2,3),
              (4,5,6)])
print(c.shape)
(2, 3)

3 आयाम सरणी

उच्च आयामों का निर्माण भी इसी प्रकार किया जा सकता है।

### 3 dimension
d = np.array([
    [[1, 2,3],
        [4, 5, 6]],
    [[7, 8,9],
        [10, 11, 12]]
])
print(d.shape)
(2, 2, 3)

उद्देश्य	Code
सरणी बनाएं	सरणी([1,2,3])
आकृति प्रिंट करें	सरणी([.]).आकार

numpy.zeros() क्या है?

numpy.zeros () or np.zeros एक Python एक ऐसा फ़ंक्शन जिसका उपयोग शून्य से भरी मैट्रिक्स बनाने के लिए किया जाता है। numpy.zeros() यह तब उपयोगी होता है जब आपको TensorFlow में पहले पुनरावृति के दौरान भार को आरंभ करने या अन्य सांख्यिकीय कार्यों के लिए प्लेसहोल्डर बफर सेट करने की आवश्यकता होती है।

numpy.zeros() फ़ंक्शन सिंटैक्स

numpy.zeros(shape, dtype=float, order='C')

Python numpy.zeros() पैरामीटर

यहाँ,

• आकार: NumPy शून्य सरणी का आकार।
• प्रतिरूप: तत्वों का डेटा प्रकार। यह वैकल्पिक है, और डिफ़ॉल्ट मान है float64.
• व्यवस्था: डिफ़ॉल्ट है Cजो पंक्ति-प्रमुख लेआउट है जिसका उपयोग किया जाता है numpy.zeros() in Python.

Python numpy.zeros() उदाहरण

import numpy as np
np.zeros((2,2))

आउटपुट:

array([[0., 0.],
          [0., 0.]])

डेटाटाइप के साथ numpy zero का उदाहरण

import numpy as np
np.zeros((2,2), dtype=np.int16)

आउटपुट:

array([[0, 0],
         [0, 0]], dtype=int16)

numpy.ones() क्या है?

np.ones() फ़ंक्शन यह एक ऐसा मैट्रिक्स बनाता है जो सभी 1 से भरा होता है। numpy.ones() in Python यह तब उपयोगी होता है जब आप TensorFlow में पहले पुनरावृति के दौरान भार को आरंभ करते हैं और अन्य सांख्यिकीय कार्यों के लिए भी।

Python numpy.ones() सिंटैक्स

numpy.ones(shape, dtype=float, order='C')

Python numpy.ones() पैरामीटर

यहाँ,

• आकार: np.ones का आकार Python ऐरे.
• प्रतिरूप: तत्वों का डेटा प्रकार। यह वैकल्पिक है, और डिफ़ॉल्ट मान है float64.
• व्यवस्था: डिफ़ॉल्ट है Cजो कि रो-मेजर लेआउट है।

Python numpy.ones() डेटाटाइप उदाहरण के साथ 2D सरणी

import numpy as np
np.ones((1,2,3), dtype=np.int16)

आउटपुट:

array([[[1, 1, 1],
       [1, 1, 1]]], dtype=int16)

numpy.reshape() फ़ंक्शन Python

Python NumPy पुनःआकार यह ऐरे के डेटा को बदले बिना उसके आकार को बदलता है। मॉडल में डेटा फीड करने से पहले आपको डेटा को वाइड फॉर्मेट से लॉन्ग फॉर्मेट में रीशेप करने या 1D वेक्टर से 2D मैट्रिक्स में बदलने की आवश्यकता हो सकती है। np.reshape यह फ़ंक्शन एक ही कॉल में इसे संभाल लेता है।

np.reshape() का सिंटैक्स

numpy.reshape(a, newShape, order='C')

यहाँ,

a: वह ऐरे जिसे आप रीशेप करना चाहते हैं।

नया आकार: नया वांछित आकार।

व्यवस्था: डिफ़ॉल्ट है Cपंक्ति-प्रमुख लेआउट।

NumPy रीशेप का उदाहरण

import numpy as np
e = np.array([(1,2,3), (4,5,6)])
print(e)
e.reshape(3,2)

आउटपुट:

 // Before reshape
[[1 2 3]
 [4 5 6]]

//After Reshape
array([[1, 2],
	[3, 4],
	[5, 6]])

numpy.flatten() में Python

Python NumPy समतल यह एक आयाम में संकुचित सरणी की एक प्रति लौटाता है। जब आप कन्वनेट जैसे न्यूरल नेटवर्क के साथ काम करते हैं, तो आपको अक्सर एक इमेज टेंसर को डेंस लेयर में पास करने से पहले उसे समतल करने की आवश्यकता होती है। np.flatten() यह फ़ंक्शन एक ही कॉल में इसे संभाल लेता है।

np.flatten() का सिंटैक्स

numpy.flatten(order='C')

यहाँ,
व्यवस्था: डिफ़ॉल्ट है Cपंक्ति-प्रमुख लेआउट।

NumPy फ़्लैटन का उदाहरण

e.flatten()

आउटपुट:

array([1, 2, 3, 4, 5, 6])

numpy.hstack() क्या है? Python?

numpy.hstack एक Python इनपुट एरे के अनुक्रमों को क्षैतिज रूप से एक ही एरे में व्यवस्थित करने के लिए उपयोग किया जाने वाला फ़ंक्शन। hstack()इसमें आप कॉलम अक्ष के साथ डेटा जोड़ते हैं। फीचर वैक्टर को साथ-साथ मर्ज करने की आवश्यकता होने पर यह NumPy में एक बहुत ही सुविधाजनक सहायक टूल है।

आइए अध्ययन करें hstack in Python एक उदाहरण के साथ।

उदाहरण:

## Horizontal Stack
import numpy as np
f = np.array([1,2,3])
g = np.array([4,5,6])
print('Horizontal Append:', np.hstack((f, g)))

आउटपुट:

Horizontal Append: [1 2 3 4 5 6]

numpy.vstack() क्या है? Python?

numpy.vstack एक Python इनपुट एरे के अनुक्रमों को एक ही एरे में लंबवत रूप से व्यवस्थित करने के लिए उपयोग किया जाने वाला फ़ंक्शन। vstack()इसमें आप पंक्ति अक्ष के साथ डेटा जोड़ते हैं, जो नमूनों के बैचों को संयोजित करना चाहते समय उपयोगी होता है।

आइए इसे एक उदाहरण के साथ समझते हैं।

उदाहरण:

## Vertical Stack
import numpy as np
f = np.array([1,2,3])
g = np.array([4,5,6])
print('Vertical Append:', np.vstack((f, g)))

आउटपुट:

Vertical Append: [[1 2 3]
 [4 5 6]]

NumPy का अध्ययन करने के बाद vstack और hstackआइए, NumPy में यादृच्छिक संख्याएँ उत्पन्न करने वाले एक उदाहरण को देखें।

यादृच्छिक उत्पन्न करें Numbers NumPy का उपयोग करके

गॉसियन वितरण से यादृच्छिक संख्याएँ उत्पन्न करने के लिए, निम्न का उपयोग करें:

numpy.random.normal(loc, scale, size)

यहाँ,

• नियंत्रण रेखा: माध्य। वितरण का केंद्र।
• स्केलमानक विचलन।
• आकार: लौटाए गए नमूनों की संख्या।

उदाहरण:

## Generate random numbers from a normal distribution
normal_array = np.random.normal(5, 0.5, 10)
print(normal_array)
[5.56171852 4.84233558 4.65392767 4.946659   4.85165567 5.61211317 4.46704244 5.22675736 4.49888936 4.68731125]

यदि इसे प्लॉट पर दर्शाया जाए, तो वितरण निम्नलिखित प्लॉट के समान होगा।

ध्यान दें कि नए कोड में आधुनिक जनरेटर एपीआई का उपयोग तेजी से बढ़ रहा है। np.random.default_rng()जो पुराने संस्करण के लिए अनुशंसित प्रतिस्थापन है। np.random.normal NumPy 2.x में कॉल।

NumPy Asarray फ़ंक्शन

RSI asarray() यह फ़ंक्शन इनपुट को ऐरे में परिवर्तित करता है। इनपुट एक सूची, टपल, एन-ऐरे या इसी तरह का अनुक्रम हो सकता है।

सिंटेक्स:

numpy.asarray(data, dtype=None, order=None)

यहाँ,

तिथि: वह डेटा जिसे आप ऐरे में बदलना चाहते हैं।

डीटाइप: वैकल्पिक। यदि निर्दिष्ट नहीं किया गया है, तो इनपुट डेटा से डेटा प्रकार का अनुमान लगाया जाता है।

व्यवस्था: डिफ़ॉल्ट है Cरो-मेजर लेआउट। दूसरा विकल्प है F (Fortraएन-शैली कॉलम-प्रमुख)।

उदाहरण:

निम्नलिखित 2D मैट्रिक्स पर विचार करें जिसमें चार पंक्तियाँ और चार स्तंभ हैं, और जो 1 से भरे हुए हैं।

import numpy as np
A = np.matrix(np.ones((4,4)))

यदि आप मैट्रिक्स में किसी मान को बदलने का प्रयास करते हैं np.arrayमूल पाठ में कोई बदलाव नहीं किया गया है। इसका कारण यह है कि np.array मैट्रिक्स की एक प्रति बनाता है।

np.array(A)[2]=2
print(A)
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

मैट्रिक्स अपरिवर्तित है। उपयोग करें asarray जब आप मूल ऐरे को उसी स्थान पर संशोधित करना चाहते हैं। आइए देखें कि जब आप तीसरी पंक्ति का मान 2 सेट करते हैं तो क्या होता है।

np.asarray(A)[2]=2
print(A)

Code स्पष्टीकरण:

np.asarray(A) मैट्रिक्स को परिवर्तित करता है A एक ऐरे व्यू में।

[2] तीसरी पंक्ति का चयन करता है।

आउटपुट:

[[1. 1. 1. 1.]
      [1. 1. 1. 1.]
      [2. 2. 2. 2.] # new value
      [1. 1. 1. 1.]]

numpy.arange() क्या है?

numpy.arange () यह NumPy का एक अंतर्निर्मित फ़ंक्शन है जो एक परिभाषित अंतराल के भीतर समान रूप से व्यवस्थित मानों वाला एक ndarray लौटाता है। उदाहरण के लिए, 1 से 10 तक के मान बनाने के लिए, आप इसे कॉल कर सकते हैं। np.arange() in Python.

सिंटेक्स:

numpy.arange(start, stop, step, dtype)

Python NumPy व्यवस्था पैरामीटर:

• प्रारंभ: अंतराल की शुरुआत np.arange in Python.
• रुकेंअंतराल का अंत।
• स्‍टेप: मानों के बीच का अंतराल। डिफ़ॉल्ट अंतराल 1 है।
• प्रतिरूप: NumPy के लिए आउटपुट ऐरे का प्रकार arange.

उदाहरण:

import numpy as np
np.arange(1, 11)

आउटपुट:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])

उदाहरण:

इस NumPy में चरण बदलने के लिए arange उदाहरण के लिए, कोष्ठक में एक तीसरी संख्या जोड़ें। इससे चरण का आकार बदल जाता है।

import numpy as np
np.arange(1, 14, 4)

आउटपुट:

array([ 1,  5,  9, 13])

NumPy लिनस्पेस फ़ंक्शन

linspace यह दो अंतिम बिंदुओं के बीच समान दूरी पर स्थित नमूने लौटाता है।

सिंटेक्स:

numpy.linspace(start, stop, num, endpoint)

यहाँ,

• प्रारंभ: अनुक्रम का प्रारंभिक मान।
• रुकें: अनुक्रम का अंतिम मान।
• में: उत्पन्न किए जाने वाले नमूनों की संख्या। डिफ़ॉल्ट मान 50 है।
• endpoint: अगर True (डिफ़ॉल्ट), stop यह अंतिम मान है। यदि False, stop शामिल नहीं है।

उदाहरण:

उदाहरण के लिए, इसका उपयोग 1 से 5 तक के 10 समान रूप से व्यवस्थित मान बनाने के लिए किया जा सकता है।

import numpy as np
np.linspace(1.0, 5.0, num=10)

आउटपुट:

array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,       3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])

यदि आप अंतराल में अंतिम अंक को शामिल नहीं करना चाहते हैं, तो सेट करें endpoint सेवा मेरे False.

np.linspace(1.0, 5.0, num=5, endpoint=False)

आउटपुट:

array([1. , 1.8, 2.6, 3.4, 4.2])

लॉगस्पेस NumPy फ़ंक्शन Python

logspace यह लघुगणकीय पैमाने पर समान दूरी पर स्थित संख्याएँ लौटाता है। logspace समान मापदंडों को साझा करता है np.linspace.

सिंटेक्स:

numpy.logspace(start, stop, num, endpoint)

उदाहरण:

np.logspace(3.0, 4.0, num=4)

आउटपुट:

array([ 1000. ,  2154.43469003,  4641.58883361, 10000.        ])

अंत में, यदि आप किसी ऐरे में किसी एक तत्व के मेमोरी आकार की जांच करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं। itemsize.

x = np.array([1,2,3], dtype=np.complex128)
x.itemsize

आउटपुट:

16

प्रत्येक तत्व 16 बाइट्स लेता है।

इंडेक्सिंग और स्लाइसिंग Python

NumPy में डेटा को स्लाइस करना आसान है। हम मैट्रिक्स को स्लाइस करेंगे। e. में Pythonपंक्तियों या स्तंभों को लौटाने के लिए आप वर्गाकार कोष्ठकों का उपयोग करते हैं।
उदाहरण:

## Slice
import numpy as np
e = np.array([(1,2,3), (4,5,6)])
print(e)
[[1 2 3]
 [4 5 6]]

ध्यान रखें कि NumPy में पहला ऐरे इंडेक्स 0 से शुरू होता है।

## First row
print('First row:', e[0])

## Second row
print('Second row:', e[1])

आउटपुट:

First row: [1 2 3]
Second row: [4 5 6]

In Pythonअन्य कई भाषाओं की तरह,

• अल्पविराम से पहले का मान पंक्तियों को दर्शाता है।
• अल्पविराम के बाद का मान स्तंभों को दर्शाता है।
• यदि आप कोई कॉलम चुनना चाहते हैं, तो जोड़ें : कॉलम इंडेक्स से पहले।
• : इसका मतलब है कि आप चयनित कॉलम से सभी पंक्तियाँ चाहते हैं।

print('Second column:', e[:,1])

Second column: [2 5]

दूसरी पंक्ति के पहले दो मान लौटाने के लिए, इसका उपयोग करें : दूसरे इंडेक्स तक के सभी कॉलम का चयन करने के लिए।

## Second Row, two values
print(e[1, :2])
[4 5]

सांख्यिकीय कार्य Python

NumPy किसी दिए गए ऐरे से न्यूनतम, अधिकतम, पर्सेंटाइल, मानक विचलन, विचरण आदि ज्ञात करने के लिए उपयोगी सांख्यिकीय कार्यों का एक समूह प्रदान करता है। सबसे आम कार्यों की सूची नीचे दी गई है।

NumPy में कई मजबूत सांख्यिकीय सहायक उपकरण मौजूद हैं, जिनका सारांश तालिका में दिया गया है।

समारोह	ऊँचा होना
मिन	एनपी.मिन()
मैक्स	एनपी.मैक्स()
मतलब	एनपी.मीन()
मंझला	एनपी.मीडियन()
मानक विचलन	एनपी.एसटीडी()

निम्नलिखित ऐरे पर विचार करें:

उदाहरण:

import numpy as np
normal_array = np.random.normal(5, 0.5, 10)
print(normal_array)

आउटपुट:

[5.56171852 4.84233558 4.65392767 4.946659   4.85165567 5.61211317 4.46704244 5.22675736 4.49888936 4.68731125]

NumPy सांख्यिकीय कार्यों का उदाहरण

### Min
print(np.min(normal_array))

### Max
print(np.max(normal_array))

### Mean
print(np.mean(normal_array))

### Median
print(np.median(normal_array))

### Sd
print(np.std(normal_array))

आउटपुट:

4.467042435266913
5.612113171990201
4.934841002270593
4.846995625786663
0.3875019367395316

नम्पी डॉट उत्पाद क्या है?

numpy.dot मैट्रिक्स गणना के लिए एक शक्तिशाली फ़ंक्शन है। उदाहरण के लिए, आप डॉट प्रोडक्ट की गणना इससे कर सकते हैं। np.dot. numpy.dot यह डॉट प्रोडक्ट लौटाता है a और bयह 1D और 2D दोनों प्रकार के एरे को हैंडल करता है। 2D इनपुट के लिए यह मैट्रिक्स गुणन करता है।

सिंटेक्स:

numpy.dot(x, y, out=None)

पैरामीटर्स

यहाँ,

एक्स, वाई: इनपुट सरणियाँ। x और y दोनों 1D या 2D होने चाहिए np.dot() डॉट प्रोडक्ट या मैट्रिक्स मल्टीप्लाई के रूप में काम करने के लिए।

आउट: परिणाम को कैप्चर करने के लिए उपयोग किया जाने वाला वैकल्पिक आउटपुट तर्क। अन्यथा, एक ndarray लौटाया जाता है।

रिटर्न

समारोह numpy.dot() दो एरे का डॉट प्रोडक्ट लौटाता है x और yयह एक स्केलर लौटाता है जब दोनों 1D होते हैं, अन्यथा यह एक ऐरे लौटाता है। out यदि इनपुट दिया जाता है, तो वह ऐरे वापस कर दिया जाता है।

उठाता

डॉट उत्पाद में Python उठाता है ValueError यदि अंतिम आयाम x अंतिम से दूसरे आयाम से मेल नहीं खाता y.

उदाहरण:

## Linear algebra
### Dot product: product of two arrays
f = np.array([1,2])
g = np.array([4,5])
### 1*4+2*5
np.dot(f, g)

आउटपुट:

14

मैट्रिक्स गुणन Python

नम्पी matmul() यह फ़ंक्शन दो एरे के गुणनफल का मैट्रिक्स लौटाता है। यह इस प्रकार काम करता है।

1) 2D सरणियों के लिए, यह सामान्य मैट्रिक्स गुणनफल लौटाता है।

2) 2 से अधिक आयामों के लिए, गुणनफल को मैट्रिक्स के स्टैक के रूप में माना जाता है।

3) एक 1डी सरणी को पहले मैट्रिक्स में परिवर्तित किया जाता है, फिर गुणनफल की गणना की जाती है।

अंतःसर्ग @ ऑपरेटर, उपलब्ध है Python 3.5, का संक्षिप्त रूप है matmul और इसका व्यापक रूप से आधुनिक कोड में उपयोग किया जाता है।

सिंटेक्स:

numpy.matmul(x, y, out=None)

यहाँ,

एक्स, वाईइनपुट एरे। स्केलर की अनुमति नहीं है।

आउट: वैकल्पिक पैरामीटर। आमतौर पर आउटपुट को ndarray में संग्रहीत किया जाता है।

उदाहरण:

इसी प्रकार, आप मैट्रिक्स गुणन की गणना कर सकते हैं। np.matmul.

### Matmul: matrix product of two arrays
h = [[1,2],[3,4]]
i = [[5,6],[7,8]]
### 1*5+2*7 = 19
np.matmul(h, i)

आउटपुट:

array([[19, 22],
            [43, 50]])

सिद्ध

यदि आपको किसी मैट्रिक्स का निर्धारक ज्ञात करना है, तो इसका उपयोग करें np.linalg.det()NumPy आपके लिए आयामों का ध्यान रखता है।

उदाहरण:

## Determinant 2*2 matrix
### 5*8-7*6
np.linalg.det(i)

आउटपुट:

-2.000000000000005

NumPy ब्रॉडकास्टिंग की व्याख्या

ब्रॉडकास्टिंग वह नियम है जो NumPy को डेटा कॉपी किए बिना अलग-अलग आकार के एरे पर अंकगणित करने की अनुमति देता है। जब आप किसी स्केलर को 1D वेक्टर में जोड़ते हैं, या किसी 1D वेक्टर को 2D मैट्रिक्स में जोड़ते हैं, तो NumPy छोटे ऑपरेंड को गायब अक्षों के साथ फैला देता है ताकि आकार संरेखित हो जाएं। इससे स्पष्ट मापन से बचा जा सकता है। Python लूप्स का उपयोग करना ही मुख्य कारणों में से एक है जिसकी वजह से NumPy कोड तेज और संक्षिप्त लगता है।

दो आकृतियाँ प्रसारण के लिए तब संगत होती हैं जब, दाएँ से बाएँ तुलना करने पर, आयामों का प्रत्येक युग्म या तो बराबर हो या उनमें से एक 1 के बराबर हो। उदाहरण के लिए, आकृति का एक मैट्रिक्स (3, 4) आकृतियों की एक पंक्ति के विरुद्ध प्रसारण (4,) या आकार का एक स्तंभ (3, 1)मशीन लर्निंग में सामान्यीकरण के लिए भी यही तर्क लागू होता है, जहाँ आपtracएक पंक्ति में नमूनों के एक बैच से प्रति-फीचर माध्य वेक्टर। ब्रॉडकास्टिंग एक वैचारिक मॉडल भी है जिसका उपयोग Py ​​जैसी टेंसर लाइब्रेरी द्वारा किया जाता है।Torch, TensorFlow और JAX का उपयोग किया जाता है, इसलिए यहां सीखे गए नियम सीधे GPU कोड पर लागू होते हैं।

NumPy किस प्रकार कृत्रिम बुद्धिमत्ता और मशीन लर्निंग को शक्ति प्रदान करता है?

लगभग सभी आधुनिक उपकरणों के मूल में NumPy मौजूद है। Python एआई स्टैक.पीवाईTorch टेन्सर, टेन्सरफ्लो ईगर टेन्सर और JAX एरे समान ब्रॉडकास्टिंग, स्लाइसिंग और रीशेपिंग सुविधाएँ प्रदान करते हैं।ping आपने NumPy ndarrays पर जो API सीखा है, उसे ही याद रखें। कई ट्यूटोरियल अभी भी प्री-प्रोसेस्ड NumPy एरेज़ को मॉडल ट्रेनिंग लूप में फीड करते हैं, और फ्रेमवर्क उन्हें बिना किसी रूपांतरण के स्वीकार करते हैं।

तीन ठोस उदाहरण दर्शाते हैं कि NumPy आज AI के कार्यों से किस प्रकार जुड़ा हुआ है। पहला, डेटा इंजीनियर कच्चे फ़ीचर्स को NumPy एरे में ढालते हैं, फिर उन्हें scikit-learn पाइपलाइन या Hugging Face डेटासेट को सौंपते हैं। दूसरा, शोधकर्ता NumPy को CPU बेसलाइन के रूप में उपयोग करते हैं और फिर CuPy का उपयोग करते हैं, जो लगभग समान API प्रदान करता है लेकिन CUDA के माध्यम से NVIDIA GPU पर चलता है। तीसरा, JAX NumPy API पर आधारित है और इसमें स्वचालित विभेदन और जस्ट-इन-टाइम संकलन की सुविधा जोड़ता है, जिससे लैपटॉप पर चलने वाला कोड क्लाउड में TPU पर भी चल सकता है। इसका निष्कर्ष यह है कि NumPy के साथ आप जो एरे कौशल विकसित करते हैं, वह हर प्रमुख डीप लर्निंग टूलकिट में काम आता है, जो इस ट्यूटोरियल को AI विकास की दिशा में एक उपयोगी कदम बनाता है।

अक्सर पूछे जाने वाले प्रश्न