गॉसियन एलिमिनेशन: समीकरणों के तंत्र हल करने की एक विधि

गॉसियन एलिमिनेशन रैखिक बीजगणित में रैखिक समीकरणों के तंत्र को हल करने के लिए सबसे बुनियादी एल्गोरिदमों में से एक है। जर्मन गणितज्ञ कार्ल फ्रेडरिक गॉस के नाम पर, यह विधि किसी तंत्र के मैट्रिक्स निरूपण पर क्रमबद्ध संक्रियाएँ करके उसे तुल्य, लेकिन सरल रूप में बदल देती है।

यह लेख बताएगा कि गॉसियन एलिमिनेशन कैसे काम करता है, इसे Python में कैसे लागू करें, और डेटा साइंस तथा संख्यात्मक संगणना में इसके उपयोग क्या हैं। इस एल्गोरिदम को समझकर, हम डेटा विश्लेषण में प्रयुक्त अनेक संगणकीय विधियों की आधारभूत तकनीक का दृष्टिगत समझ हासिल करेंगे।

गॉसियन एलिमिनेशन क्या है?

गॉसियन एलिमिनेशन रैखिक समीकरणों के तंत्र को हल करने का एल्गोरिदम है, जिसमें तंत्र के विस्तारित मैट्रिक्स (augmented matrix) को क्रमबद्ध रूप से पंक्ति संकेन्द्र रूप (REF) में बदला जाता है। यह रूपांतरण हलों के समुच्चय को जस का तस रखता है, पर चर मान निकालना आसान बना देता है।

किसी मैट्रिक्स को पंक्ति संकेन्द्र रूप में कहा जाता है जब:

• पूरी तरह शून्यों से बनी सभी पंक्तियाँ मैट्रिक्स के सबसे नीचे हों
• हर अशून्य पंक्ति का अग्र प्रविष्टि (पहला अशून्य तत्व) ऊपर वाली पंक्ति की अग्र प्रविष्टि के दाहिने हो
• अग्र प्रविष्टि के नीचे के सभी तत्व शून्य हों

पंक्ति संकेन्द्र रूप पाने के लिए, हम तीन प्रकार की प्राथमिक पंक्ति संक्रियाएँ उपयोग करते हैं:

• पंक्ति अदला-बदली: दो पंक्तियों का परस्पर विनिमय
• पंक्ति स्केलिंग: किसी पंक्ति के सभी तत्वों को किसी अशून्य नियतांक से गुणा करना
• पंक्ति योग: एक पंक्ति को स्वयं और दूसरी पंक्ति के किसी गुणज के योग से प्रतिस्थापित करना

इसके अलावा, गॉसियन एलिमिनेशन और गॉस-जॉर्डन एलिमिनेशन में भेद समझना महत्वपूर्ण है:

• गॉसियन एलिमिनेशन मैट्रिक्स को पंक्ति संकेन्द्र रूप में बदलता है और चर मान पाने के लिए बैक-सब्स्टीट्यूशन की आवश्यकता होती है
• गॉस-जॉर्डन एलिमिनेशन प्रक्रिया को आगे बढ़ाकर नियंत्रावृत्त पंक्ति संकेन्द्र रूप (RREF) तक ले जाता है, जहाँ सभी अग्र प्रविष्टियाँ 1 होती हैं और प्रत्येक अग्र प्रविष्टि के स्तंभ में अन्य सभी प्रविष्टियाँ 0 होती हैं

जहाँ गॉस–जॉर्डन एलिमिनेशन अधिक प्रत्यक्ष समाधान देता है, वहीं बड़े तंत्रों के लिए गॉसियन एलिमिनेशन सामान्यतः अधिक कुशल होता है, विशेषकर बैक-सब्स्टीट्यूशन और LU विघटन जैसी तकनीकों के साथ।

गॉसियन एलिमिनेशन एल्गोरिदम का चरण-दर-चरण विश्लेषण

आइए एक सरल उदाहरण से गॉसियन एलिमिनेशन की प्रक्रिया समझते हैं। निम्नलिखित रैखिक समीकरणों के तंत्र पर विचार करें:

रैखिक समीकरणों का तंत्र। चित्र: लेखक।

चरण 1: विस्तारित मैट्रिक्स बनाएँ

सबसे पहले, गुणांक मैट्रिक्स को नियतांकों के साथ जोड़कर तंत्र को विस्तारित मैट्रिक्स के रूप में निरूपित करें:

विस्तारित मैट्रिक्स। चित्र: लेखक।

चरण 2: फॉरवर्ड एलिमिनेशन

अब हम प्राथमिक पंक्ति संक्रियाएँ करके मैट्रिक्स को पंक्ति संकेन्द्र रूप में बदलेंगे।

पहले स्तंभ के पहले तत्व को पिवट बनाकर उसके नीचे के सभी तत्वों को शून्य करें:

• पंक्ति 2 में 3/2 × पंक्ति 1 जोड़ें:

पंक्ति 2 में 3/2 × पंक्ति 1 जोड़ें। चित्र: लेखक।

• पंक्ति 3 में पंक्ति 1 जोड़ें:

पंक्ति 3 में पंक्ति 1 जोड़ें। चित्र: लेखक।

दूसरे स्तंभ पर जाएँ और पिवट के नीचे के सभी तत्वों को शून्य करें:

• पिवट 1 बनाने के लिए पंक्ति 2 को 2 से गुणा करें:

पंक्ति 2 को 2 से गुणा करें। चित्र: लेखक।

• पंक्ति 3 में से 2 × पंक्ति 2 घटाएँ:

2 × पंक्ति 2 घटाएँ। चित्र: लेखक।

तीसरी पंक्ति के पिवट को धनात्मक बनाएँ:

• पंक्ति 3 को -1 से गुणा करें:

पंक्ति 3 को -1 से गुणा करें। चित्र: लेखक।

अब मैट्रिक्स पंक्ति संकेन्द्र रूप में है।

चरण 3: बैक-सब्स्टीट्यूशन

अब हम बैक-सब्स्टीट्यूशन के जरिए अपने चरों के मान निकाल सकते हैं:

पंक्ति 3 से: 

          z = -1

पंक्ति 2 से: 

          y + z = 2,

          अतः y + (-1) = 2,

          जिससे y = 3

पंक्ति 1 से: 

          2x + y - z = 8,

          अतः 2x + 3 - (-1) = 8,

          जिससे 2x = 4,

          अतः x = 2

अतः समाधान है x = 2, y = 3, z = -1.

हमने इस उदाहरण पर गॉसियन एलिमिनेशन लागू किया है; किसी और रैखिक समीकरणों के तंत्र के लिए भी चरण वही रहते हैं।

Python में गॉसियन एलिमिनेशन का कार्यान्वयन

यद्यपि हम यह एल्गोरिदम साधारण Python से लिख सकते हैं, NumPy की वेक्टरकृत संक्रियाएँ कार्यान्वयन को अधिक साफ-सुथरा और काफी तेज़ बना देती हैं। 

शैक्षणिक दृष्टि से आधारभूत एल्गोरिदम समझना मूल्यवान है, पर उत्पादन-स्तर पर अनुकूलित लाइब्रेरी का उपयोग करना ही अनुशंसित है। पिछला खंड पढ़कर आप एल्गोरिदम की बुनियाद समझ चुके हैं, अब हम Python में अनुकूलित लाइब्रेरी के साथ इसका कार्यान्वयन देखेंगे।

NumPy-आधारित कार्यान्वयन

NumPy numpy.linalg.solve() फ़ंक्शन देता है, जो रैखिक समीकरणों के तंत्र के लिए अत्यधिक अनुकूलित समाधान लागू करता है:

import numpy as np

# Define the coefficient matrix A and constant vector b
A = np.array([[2, 1, -1],
             [-3, -1, 2],
             [-2, 1, 2]], dtype=float)
b = np.array([8, -11, -3], dtype=float)

# Solve the system Ax = b
x = np.linalg.solve(A, b)

print("Solution:", x)संचालित द्वारा

ऊपर दिए कोड में, हम गुणांक मैट्रिक्स A और नियतांक सदिश b को परिभाषित करते हैं; ये उसी विस्तारित मैट्रिक्स के अनुरूप हैं जिसे हमने ऊपर गॉसियन एलिमिनेशन के चरण 1 में बनाया था। 

हम numpy.linalg.solve() फ़ंक्शन प्रयोग करके समाधान पर पहुँचते हैं और आउटपुट को नीचे दिखाए अनुसार प्रिंट करते हैं:

कोड कार्यान्वयन से प्राप्त समाधान। चित्र: लेखक।

यह कार्यान्वयन अंदरूनी तौर पर LAPACK का उपयोग करता है, जो LU विघटन (गॉसियन एलिमिनेशन का एक रूपांतर) को संख्यात्मक स्थिरता और प्रदर्शन के लिए अनुकूलित रूप में लागू करता है।

विशेष मामलों का प्रबंधन

गॉसियन एलिमिनेशन लागू करते समय, आपको कुछ विशेष मामले मिलेंगे जिनका सावधानी से प्रबंधन आवश्यक है:

• सिंगुलर मैट्रिक्स: यदि आपके गुणांक मैट्रिक्स का डिटरमिनेंट शून्य या शून्य के बहुत निकट है, तो तंत्र का या तो कोई हल नहीं होता या अनंत अनेक हल होते हैं। ऐसे में NumPy का linalg.solve() फ़ंक्शन LinAlgError उठाता है।

• संख्यात्मक स्थिरता: फ्लोटिंग-पॉइंट गणना में राउंडिंग त्रुटियाँ जुड़कर परिणाम को गलत कर सकती हैं। आंशिक पिवोटिंग, जिसमें स्तंभ के सबसे बड़े तत्व को पिवट चुना जाता है, इस समस्या को कम करती है।

• अधिकनिर्धारित या अल्पनिर्धारित तंत्र: जब समीकरणों की संख्या चरों की संख्या से मेल नहीं खाती, तो आप numpy.linalg.lstsq() का उपयोग कर सकते हैं, जो लीस्ट-स्क्वेयर्स समाधान देता है।

बहुत बड़े और विरल (sparse) तंत्रों के लिए, SciPy के sparse मैट्रिक्स सॉल्वर घने सॉल्वर की तुलना में कई गुणा तेज़ हो सकते हैं:

from scipy.sparse import csr_matrix
from scipy.sparse.linalg import spsolve

# For large sparse matrices
A_sparse = csr_matrix(A)
x = spsolve(A_sparse, b)संचालित द्वारा

यद्यपि एल्गोरिदम की यांत्रिकी समझना महत्वपूर्ण है, व्यवहार में NumPy और SciPy के अनुकूलित कार्यान्वयन का सहारा लेने से आप बिना पहिया पुनः आविष्कार किए रैखिक तंत्रों को कुशलतापूर्वक और भरोसेमंद तरीके से हल कर सकते हैं।

गॉसियन एलिमिनेशन कहाँ उपयोग होता है

गॉसियन एलिमिनेशन सैद्धांतिक गणित से कहीं आगे बढ़कर विज्ञान, अभियांत्रिकी और डेटा विश्लेषण के विभिन्न क्षेत्रों में अनेक व्यावहारिक अनुप्रयोग पाता है। 

इस आधारभूत एल्गोरिदम के कुछ सबसे महत्वपूर्ण वास्तविक दुनिया के उपयोग निम्नलिखित हैं:

• रैखिक प्रतिगमन: डेटा विज्ञान में, सर्वश्रेष्ठ-फिट मानदंड पाने हेतु बनने वाले सामान्य समीकरणों को हल करने के लिए गॉसियन एलिमिनेशन का प्रयोग होता है। इससे विश्लेषक ऐतिहासिक डेटा के आधार पर भविष्यवाणियाँ कर पाते हैं।
• नेटवर्क विश्लेषण: अभियंता विद्युत परिपथों में अज्ञात धारा या वोल्टेज निकालने हेतु किर्चहॉफ के नियमों को लागू करके बनने वाले रैखिक समीकरणों के तंत्र को गॉसियन एलिमिनेशन से साथ-साथ हल करते हैं।
• मैट्रिक्स इनवर्ज़न: मैट्रिक्स के व्युत्क्रम निकालने के लिए गॉसियन एलिमिनेशन आधार का काम करता है, जो रूपांतरणों, सांख्यिकीय विश्लेषणों और मशीन लर्निंग एल्गोरिदम में जटिल गणितीय समस्याओं को हल करने में आवश्यक है।
• संख्यात्मक समाकलन: निहित Euler या रुँगे–कुट्टा समाकलन जैसी उन्नत संख्यात्मक विधियाँ लागू करते समय उत्पन्न होने वाले समीकरणों के तंत्र को हल करने के लिए गॉसियन एलिमिनेशन का उपयोग किया जाता है, जिससे गतिशील तंत्रों के सिमुलेशन में स्थिरता सुनिश्चित होती है।

इन अनुप्रयोगों को समझकर, हम देख सकते हैं कि कैसे एक ही गणितीय तकनीक डेटा वैज्ञानिकों, अभियंताओं और शोधकर्ताओं द्वारा प्रतिदिन उपयोग किए जाने वाले अनेक उपकरणों की रीढ़ बनती है।

निष्कर्ष

इस लेख में हमने रैखिक समीकरणों के तंत्र को पंक्ति संकेन्द्र रूप में बदलकर हल करने के लिए गॉसियन एलिमिनेशन के आधारभूत एल्गोरिदम का अध्ययन किया। हमने यह भी देखा कि NumPy के अनुकूलित फ़ंक्शनों से Python में इस तकनीक को कैसे लागू करें, और इसके व्यावहारिक उपयोग रैखिक प्रतिगमन, नेटवर्क विश्लेषण, मैट्रिक्स इनवर्ज़न, तथा संख्यात्मक विधियों में कैसे होते हैं। 

रैखिक बीजगणित और डेटा साइंस में इसके अनुप्रयोगों की समझ गहरी करने के लिए, हमारे Linear Algebra पाठ्यक्रम में नामांकन पर विचार करें, जहाँ आप इन आधारभूत तकनीकों की अधिक उन्नत अवधारणाएँ और कार्यान्वयन सीखेंगे।