Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन में N-आयामी सरणी का ग्रेडिएंट अक्ष 1 पर लौटाना

ग्रेडिएंट की गणना आंतरिक बिंदुओं में दूसरी क्रम की सटीक केंद्रीय अंतरों का उपयोग करके की जाती है और सीमाओं पर पहली या दूसरी क्रम की सटीक एक-पक्षीय (आगे या पीछे) अंतरों का उपयोग किया जाता है। लौटाया गया ग्रेडिएंट इसलिए इनपुट सरणी के समान आकार का होता है। पहला पैरामीटर f एक N-आयामी सरणी है जिसमें एक अदिश फ़ंक्शन के नमूने होते हैं। दूसरा पैरामीटर varargs है यानी f मानों के बीच का अंतर। सभी आयामों के लिए डिफ़ॉल्ट एकात्मक अंतर।

तीसरा पैरामीटर edge_order{1, 2} है यानी ग्रेडिएंट की गणना सीमाओं पर N-वें क्रम के सटीक अंतरों का उपयोग करके की जाती है। डिफ़ॉल्ट: 1। चौथा पैरामीटर ग्रेडिएंट है, जिसकी गणना केवल दिए गए अक्ष या अक्षों के साथ की जाती है। डिफ़ॉल्ट (axis=None) इनपुट सरणी के सभी अक्षों के लिए ग्रेडिएंट की गणना करना है। अक्ष नकारात्मक हो सकता है, जिस स्थिति में यह अंतिम से पहले अक्ष तक गिनता है। यह विधि f के प्रत्येक आयाम के सापेक्ष अवकलजों के अनुरूप ndarrays की एक सूची लौटाती है। प्रत्येक अवकलज का आकार f के समान होता है।

चरण

सबसे पहले, आवश्यक लाइब्रेरी आयात करें:

import numpy as np

array() विधि का उपयोग करके एक numpy सरणी बनाएं। हमने float प्रकार के तत्व जोड़े हैं:

arr = np.array([[20, 35, 57], [70, 85, 120]], dtype=float)

सरणी प्रदर्शित करें:

print("हमारी सरणी...\n", arr)

आयाम जांचें:

print("\nहमारी सरणी के आयाम...\n", arr.ndim)

डेटा प्रकार प्राप्त करें:

print("\nहमारी सरणी ऑब्जेक्ट का डेटा प्रकार...\n", arr.dtype)

ग्रेडिएंट की गणना दूसरी क्रम की सटीक केंद्रीय अंतरों का उपयोग करके आंतरिक बिंदुओं में की जाती है और सीमाओं पर पहली या दूसरी क्रम की सटीक एक-पक्षीय अंतरों का उपयोग किया जाता है। लौटाया गया ग्रेडिएंट इसलिए इनपुट सरणी के समान आकार का होता है:

print("\nपरिणाम (ग्रेडिएंट)...\n", np.gradient(arr, axis=1))

उदाहरण

import numpy as np
# array() विधि का उपयोग करके एक numpy सरणी बनाएं
# हमने float प्रकार के तत्व जोड़े हैं
arr = np.array([[20, 35, 57], [70, 85, 120]], dtype=float)
# सरणी प्रदर्शित करें
print("हमारी सरणी...\n", arr)
# आयाम जांचें
print("\nहमारी सरणी के आयाम...\n", arr.ndim)
# डेटा प्रकार प्राप्त करें
print("\nहमारी सरणी ऑब्जेक्ट का डेटा प्रकार...\n", arr.dtype)
# ग्रेडिएंट की गणना करें
print("\nपरिणाम (ग्रेडिएंट)...\n", np.gradient(arr, axis=1))

आउटपुट

हमारी सरणी... [[20. 35. 57.] [70. 85. 120.]]
हमारी सरणी के आयाम... 2
हमारी सरणी ऑब्जेक्ट का डेटा प्रकार... float64
परिणाम (ग्रेडिएंट)... [[15. 18.5 22.] [15. 25. 35.]]
  1. - पायथन में अक्ष 0 पर NaN को शून्य मानकर सरणी तत्वों का संचयी योग लौटाना

    दिए गए अक्ष पर सरणी तत्वों का संचयी योग लौटाने के लिए, NaN को शून्य मानकर nancumsum() विधि का उपयोग करें। जब NaN का सामना होता है तो संचयी योग नहीं बदलता और अग्रणी NaN को शून्य से बदल दिया जाता है। उन स्लाइस के लिए शून्य लौटाए जाते हैं जो सभी NaN हैं या खाली हैं। संचयी कार्य इस तरह करता है: 5, 5+10,

  1. - पायथन में N-डायमेंशनल ऐरे का ग्रेडिएंट एक्सिस 0 पर लौटाएं

    ग्रेडिएंट की गणना इंटीरियर पॉइंट्स में सेकंड ऑर्डर एक्यूरेट सेंट्रल डिफरेंसेस का उपयोग करके की जाती है और बाउंड्रीज पर फर्स्ट या सेकंड ऑर्डर एक्यूरेट वन-साइडेड (फॉरवर्ड या बैकवर्ड) डिफरेंसेस का उपयोग करके। लौटाया गया ग्रेडिएंट इसलिए इनपुट ऐरे के समान आकार का होता है। पहला पैरामीटर f एक N-डायमेंशनल

  1. - पायथन में एक्सिस 0 पर n-th डिस्क्रीट डिफरेंस की गणना करें

    n-th डिस्क्रीट डिफरेंस की गणना करने के लिए numpy.diff() मेथड का उपयोग करें। पहला डिफरेंस दिए गए एक्सिस के साथ out[i] = a[i+1] - a[i] द्वारा दिया जाता है, उच्च डिफरेंस की गणना diff को रिकर्सिवली उपयोग करके की जाती है। diff() मेथड n-th डिफरेंस लौटाता है। आउटपुट का आकार a के समान होता है सिवाय एक्सिस