numpy
Np.linalg के साथ रैखिक बीजगणित

टिप्पणियों

np.random.seed(123)
A = np.random.rand(2,3,3)
b = np.random.rand(2,3)
x = np.linalg.solve(A, b)

print np.dot(A[0,:,:], x[0,:])
# array([ 0.53155137,  0.53182759,  0.63440096])

print b[0,:]
# array([ 0.53155137,  0.53182759,  0.63440096])

Np.solve के साथ रैखिक प्रणालियों को हल करें

निम्नलिखित तीन समीकरणों पर विचार करें:

x0 + 2 * x1 + x2 = 4
         x1 + x2 = 3
x0 +          x2 = 5

हम इस प्रणाली को मैट्रिक्स समीकरण A * x = b साथ व्यक्त कर सकते हैं:

A = np.array([[1, 2, 1],
              [0, 1, 1],
              [1, 0, 1]])
b = np.array([4, 3, 5])

फिर, x हल के लिए np.linalg.solve का उपयोग करें:

x = np.linalg.solve(A, b)
# Out: x = array([ 1.5, -0.5,  3.5])

A वर्ग और पूर्ण-रैंक मैट्रिक्स होना चाहिए: इसकी सभी पंक्तियाँ रैखिक रूप से स्वतंत्र होनी चाहिए। A उल्टा / गैर-एकवचन होना चाहिए (इसका निर्धारण शून्य नहीं है)। उदाहरण के लिए, यदि A की एक पंक्ति A दूसरे की कई है, तो linalg.solve कॉल करना linalg.solve LinAlgError: Singular matrix :

A = np.array([[1, 2, 1], 
              [2, 4, 2],   # Note that this row 2 * the first row
              [1, 0, 1]])
b = np.array([4,8,5])

इस तरह के सिस्टम को np.linalg.lstsq हल किया जा सकता है।

Np.linalg.lstsq के साथ एक रेखीय प्रणाली के लिए कम से कम वर्गों का समाधान खोजें

लीस्टर वर्ग अज्ञात की तुलना में अधिक समीकरणों के साथ समस्याओं के लिए एक मानक दृष्टिकोण है, जिसे अतिव्यापी सिस्टम के रूप में भी जाना जाता है।

चार समीकरणों पर विचार करें:

x0 + 2 * x1 + x2 = 4
x0 + x1 + 2 * x2 = 3
2 * x0 + x1 + x2 = 5
x0 + x1 + x2 = 4

हम इसे एक मैट्रिक्स गुणा A * x = b रूप में व्यक्त कर सकते हैं:

A = np.array([[1, 2, 1],
              [1,1,2],
              [2,1,1],
              [1,1,1]])
b = np.array([4,3,5,4])

फिर np.linalg.lstsq साथ हल करें:

x, residuals, rank, s = np.linalg.lstsq(A,b)

x , समाधान है residuals योग, rank मैट्रिक्स रैंक इनपुट के A , और s विलक्षण मूल्यों की A । यदि b में एक से अधिक आयाम हैं, तो lstsq b प्रत्येक कॉलम के अनुरूप सिस्टम को हल करेगा:

A = np.array([[1, 2, 1],
              [1,1,2],
              [2,1,1],
              [1,1,1]])
b = np.array([[4,3,5,4],[1,2,3,4]]).T # transpose to align dimensions
x, residuals, rank, s = np.linalg.lstsq(A,b)
print x # columns of x are solutions corresponding to columns of b
#[[ 2.05263158  1.63157895]
# [ 1.05263158 -0.36842105]
# [ 0.05263158  0.63157895]]
print residuals # also one for each column in b
#[ 0.84210526  5.26315789]

rank और s केवल A पर निर्भर करते हैं, और इस प्रकार ऊपर के समान हैं।