अनुवादक से: यह रक्षित वासुदेव की सामग्री का अनुवाद है, जो लंबे समय से DataScience का अध्ययन कर रहे हैं और इसमें पायथन भाषा का उपयोग कर रहे हैं। लेखक शक्तिशाली Numpy पुस्तकालय के बारे में बात करता है, जो आपको मशीन सीखने और बड़े डेटा के साथ काम करने की कई विशेषताओं को लागू करने की अनुमति देता है।
Numpy पायथन के लिए एक गणित पुस्तकालय है। यह आपको कुशलतापूर्वक और जल्दी से सभी प्रकार की गणना करने की अनुमति देता है। यह पायथन की कार्यक्षमता को बहुत विस्तार देता है जो इसमें उपयोग किए जाने वाले विशेष समाधानों के लिए धन्यवाद। यह लेख Numpy की बुनियादी विशेषताओं के बारे में बात करता है, और यह केवल पहला भाग है; दूसरों को थोड़ी देर बाद प्रकाशित किया जाएगा। यह लेख उन लोगों के लिए है जो अभी-अभी नूपी सीखना शुरू कर रहे हैं, पायथन में गणित की बहादुर दुनिया में प्रवेश कर रहे हैं।
स्किलबॉक्स सलाह देता है: स्क्रैच हैंड-ऑन कोर्स से पायथन डेवलपर ।
हम आपको याद दिलाते हैं: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रचारक कोड का उपयोग करके किसी भी स्किलबॉक्स कोर्स के लिए पंजीकरण करते समय 10,000 रूबल की छूट।
पुस्तकालय आयात करें
import numpy as np
इस बिंदु पर, हम पायथन को बताते हैं कि एनपीपी नेम्पी के लिए संदर्भ है, जिसका उपयोग जारी रहेगा।
अब एक अजगर सरणी और एक एनपी सरणी बनाएं।
निकासी में बहुत अंतर नहीं है।
print(a) print(A) ==================================================================== [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
खैर, सामान्य के बजाय एक सुव्यवस्थित सरणी का उपयोग करना बेहतर क्यों है? इसका उत्तर यह है क्योंकि एनपी हमें गणना को तेज करने और आवेदन की समग्र वास्तुकला को संशोधित करने की अनुमति देगा।
np.arange ()
np.arange(0,10,2) ==================================================================== array([0, 2, 4, 6, 8])
([शुरू], रोक, [कदम]) संख्याओं का आदेश देता है। यह एक कार के लिए इसका मतलब है।
हम एक np-list बनाते हैं, जिसकी शुरुआत 0 से 10 तक है, लेकिन इसमें 10 शामिल नहीं हैं, साथ ही हर बार संख्या में 2 की वृद्धि करते हैं।
इस प्रकार, हम इसे प्राप्त करते हैं:
सरणी ([0, 2, 4, 6, 8])
यह याद रखना महत्वपूर्ण है कि अंतिम अंक सूची में शामिल नहीं है।
एक और उदाहरण:
np.arange(2,29,5) ==================================================================== array([2, 7, 12, 17, 22, 27])
इस सरणी को एक मैट्रिक्स या वेक्टर भी कहा जा सकता है। इसलिए, जब मैं कहता हूं, तो चिंता न करें: "मैट्रिक्स का आकार 2 * 3. है।" इसका मतलब यह है कि हमारा सरणी अंततः कुछ इस तरह दिखाई देगा:
array([2, 7, 12], [17, 22, 27])
अब चलो एक पैरामीटर के बारे में बात करते हैं जैसे कि डिफ़ॉल्ट एनपी सरणी के लिए आकार। यहाँ आकार एक विशेषता है। इसके उपयोग का एक उदाहरण नीचे है।
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
यह संख्याओं का एक मैट्रिक्स है, जहां एक पंक्ति में केवल 9 तत्व होते हैं। सिद्धांत रूप में, एक 1 * 9 मैट्रिक्स आदर्श है, है ना?
असल में, हाँ, और इसके लिए, रिशेप () खेल में आता है। यह एक ऐसी विधि है जो मूल मैट्रिक्स का आकार बदल देती है जैसा हम चाहते हैं।
यहाँ व्यवहार में रिशेप () का उपयोग करने का एक उदाहरण है।
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
ध्यान दें कि reshape एक बहुआयामी मैट्रिक्स देता है। यह शुरुआत में दो वर्ग कोष्ठक द्वारा इंगित किया गया है। [[1, 2, 3, 4, 5, 6, 7, 8, 9]] [1, 2, 3, 4, 5, 6, 7, 8, 9] के विपरीत एक संभावित बहुआयामी मैट्रिक्स है।
एक और उदाहरण:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9] B.reshape(3,3) ==================================================================== array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
यदि हम B के लिए आकार पैरामीटर लेते हैं, तो यह (3.3) होगा:
B.shape ==================================================================== (3,3)
चलो np.zeros () पर चलते हैं
इस कोड में क्या लिखा गया है?
np.zeros((4,3)) ==================================================================== ???????????
अर्थात्: यहां शून्य से भरा एक 3 * 4 प्रारूप का मैट्रिक्स दिया गया है। यहाँ निष्कर्ष है:
np.zeros((4,3)) ==================================================================== array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])
np.zeros ((n, m)) एक n * m स्वरूप का मैट्रिक्स है जो शून्य से भरा है। सब कुछ सरल है।
Np.eye () क्या करता है?
कुछ विशेषताओं के साथ हमें एक इकाई मैट्रिक्स देता है।
np.eye(5) ==================================================================== array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])
दो मैट्रिक्स कैसे गुणा करें?
कोई समस्या नहीं है: np.dot () का उपयोग इसके लिए किया जाता है। यह फ़ंक्शन स्केलर उत्पाद है यदि वैक्टर और मैट्रिक्स उत्पाद (सबसे साधारण) इसे पास कर दिए जाते हैं।
उदाहरण: A = (2,3) और B = (3,2)। यहाँ A में स्तंभों की संख्या 3 है। B में पंक्तियों की संख्या 3. है क्योंकि विशेषताओं के संयोग से गुणन संभव है।
हमने गुणा करने के लिए मैट्रिसेस तैयार किए हैं। अगला - हम अभिनय करते हैं।
अब चलो मैट्रिक्स में अलग-अलग तत्वों को जोड़ते हैं।
np.sum () मैट्रिक्स में तत्व जोड़ता है।
हालांकि, हमारे पास दो विकल्प हैं।
1. पंक्तियों में मोड़ो
6 - पहली पंक्ति (1, 2, 3) का योग।
15 - दूसरा (4, 5, 6)।
24 - तीसरा (7, 8, 9)।
2. स्तंभों में मोड़ो
12 - पहले कॉलम का योग (1, 4, 7)।
15 - दूसरे (2, 5, 7) के अनुसार।
18 - तीसरे (3, 6, 9) के अनुसार।
नीचे लेखक द्वारा बनाया गया एक वीडियो है, जहां ऊपर वर्णित सब कुछ फिर से समझाया गया है, अधिक स्पष्ट रूप से।
स्किलबॉक्स अनुशंसा करता है: