Python में AI के लिए हिल क्लाइम्बिंग एल्गोरिथ्म लागू करना

हिल क्लाइम्बिंग एल्गोरिथ्म कृत्रिम बुद्धिमत्ता और कंप्यूटर विज्ञान में सबसे शुरुआती और सरल अनुकूलन एल्गोरिथ्म में से एक है। यह स्थानीय खोज (local search) एल्गोरिथ्म की श्रेणी में आता है, जो क्रमिक सुधार करके समाधान खोजते हैं।

एल्गोरिथ्म का नाम एक सहायक उपमा से आता है: कल्पना करें कि एक आंखों पर पट्टी बांधे हाइकर को पहाड़ी की चोटी तक पहुँचना है। पूरा परिदृश्य दिख नहीं रहा, तो वह केवल अपने आस-पास की जमीन को महसूस कर सकता है। हर कदम पर, वह उसी दिशा में बढ़ता है जो ऊपर की ओर ले जाती है। एल्गोरिथ्म भी इसी तरह काम करता है — यह आस-पास के समाधानों का मूल्यांकन करता है और क्रमिक रूप से बेहतर की ओर बढ़ता है, ताकि सर्वश्रेष्ठ समाधान (पहाड़ी की चोटी) मिल सके।

इस लेख में, हम हिल क्लाइम्बिंग एल्गोरिथ्म, उसके रूपांतरों, और इसे Python में लागू करने के तरीकों को गहराई से समझेंगे। यदि आप AI में नए हैं, तो हमारे AI Fundamentals स्किल ट्रैक ज़रूर देखें ताकि बुनियादी बातें कवर हो सकें। 

AI में हिल क्लाइम्बिंग एल्गोरिथ्म क्या है?

हिल क्लाइम्बिंग कंप्यूटर के लिए समस्याएँ सुलझाने का एक सरल तरीका है, जैसे कोई हाइकर पहाड़ की चोटी तक पहुँचने की कोशिश करता है। कृत्रिम बुद्धिमत्ता (AI) में हमें अक्सर कई संभावनाओं में से सर्वश्रेष्ठ समाधान खोजना होता है। इसे अनुकूलन (optimization) कहते हैं।

“हॉट एंड कोल्ड” खेल में सबसे ऊँचा बिंदु खोजने की कोशिश करने के बारे में सोचें। इस खेल में आप बस इतना जान पाते हैं कि आप “वार्मर” (बेहतर) हो रहे हैं या “कोल्डर” (खराब) जैसे-जैसे आप आगे बढ़ते हैं। हिल क्लाइम्बिंग भी इसी तरह काम करता है — यह आस-पास के समाधानों को देखता है और बेहतर की ओर बढ़ता है।

यह सरल चरणों में ऐसे काम करता है:

1. किसी भी संभावित समाधान से शुरू करें
2. आस-पास के समाधानों को देखें
3. यदि कोई नज़दीकी समाधान बेहतर है, तो उस पर जाएँ
4. चरण 2–3 दोहराएँ जब तक कोई बेहतर समाधान न मिले

उदाहरण के लिए, यदि आप किसी रोबोट को चलना सिखा रहे हैं, तो हिल क्लाइम्बिंग संभवतः:

• यादृच्छिक पैर-गतियों से शुरू करेगा
• थोड़ी-थोड़ी भिन्न गतियाँ आज़माएगा
• उन्हें बनाए रखेगा जो रोबोट को बेहतर चलने में मदद करें
• ऐसा दोहराएगा जब तक सबसे अच्छा चलने का पैटर्न न मिल जाए

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

हिल क्लाइम्बिंग एल्गोरिथ्म के प्रकार

हिल क्लाइम्बिंग एल्गोरिथ्म के तीन प्रमुख प्रकार हैं, जिनमें से प्रत्येक सर्वश्रेष्ठ समाधान खोजने का अपना तरीका अपनाता है:

1. सिंपल हिल क्लाइम्बिंग

सिंपल हिल क्लाइम्बिंग ऐसा है जैसे आपको पहला अच्छा कदम मिलते ही उठा लेना। इस संस्करण में:

• एल्गोरिथ्म नज़दीकी समाधानों को एक-एक करके देखता है
• जैसे ही कोई बेहतर समाधान मिलता है, वह उसे ले लेता है
• बाकी विकल्प नहीं देखे जाते
• यह तेज़ है पर थोड़ा दूर के बेहतर समाधानों को चूक सकता है

2. स्टिपेस्ट-असेंट हिल क्लाइम्बिंग

यह संस्करण सिंपल हिल क्लाइम्बिंग से अधिक गहन है:

• कदम लेने से पहले यह सभी नज़दीकी समाधानों को देखता है
• जो मिला उनमें से सबसे अच्छा विकल्प चुनता है
• ज़्यादा समय लेता है, पर आमतौर पर बेहतर समाधान देता है
• यह ऐसा है जैसे कदम रखने से पहले हर रास्ते को ध्यान से जाँचना

3. स्टोकेस्टिक हिल क्लाइम्बिंग

यह प्रकार खोज में कुछ यादृच्छिकता जोड़ता है:

• हमेशा सर्वश्रेष्ठ चुनने के बजाय, यह बेहतर विकल्पों में से यादृच्छिक रूप से चुनता है
• बेहतर समाधानों के चुने जाने की संभावना अधिक होती है
• यह यादृच्छिकता बुरे स्थानों में फँसने से बचाती है
• यह कभी-कभी अलग रास्ता लेकर देखने जैसा है कि वह कहाँ ले जाता है

हर प्रकार की अपनी ताकतें हैं और वे अलग तरह की समस्याओं के लिए बेहतर काम करते हैं। सिंपल तेज़ है पर बुनियादी, स्टिपेस्ट-असेंट गहन है पर धीमा, और स्टोकेस्टिक फँसने से बचाने के लिए उपयोगी यादृच्छिकता जोड़ता है।

हिल क्लाइम्बिंग एल्गोरिथ्म कैसे काम करता है

हिल क्लाइम्बिंग छोटे-छोटे सुधारों के जरिए कदम-दर-कदम आगे बढ़ता है, जब तक कि यह अपने अनुसार सर्वश्रेष्ठ समाधान न ढूँढ ले। आइए इसके मुख्य भागों में इसे बाँटकर समझें।

1. शुरुआत करना

हर हिल क्लाइम्बिंग एल्गोरिथ्म को एक शुरुआती बिंदु चाहिए। इसे पहाड़ पर हाइक शुरू करने की जगह चुनने जैसा समझें। आप यादृच्छिक रूप से शुरू कर सकते हैं, या समस्या के बारे में पता होने पर कोई अच्छा शुरुआती बिंदु चुन सकते हैं। 

आप कहाँ से शुरू करते हैं, यह बहुत मायने रखता है — अच्छी जगह चुनी तो जल्दी सर्वश्रेष्ठ मिल सकता है; खराब जगह चुनी तो आप किसी छोटे टीले पर फँस सकते हैं और असली चोटी छूट सकती है।

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

अच्छी initialization नेटवर्क को तेज़ी से सीखने और बेहतर समाधान पाने में मदद करती है, जबकि खराब initialization नेटवर्क को कम सटीकता पर अटका सकती है।

2. नज़दीकी समाधानों को देखना

एक बार खोज शुरू होने पर, एल्गोरिथ्म वर्तमान स्थिति से मिलते-जुलते पड़ोसी (neighbor) समाधानों का मूल्यांकन करता है। इसे छोटे-छोटे कदमों से आस-पास की पड़ताल जैसा समझें। उदाहरण के लिए, यदि आप शहरों के बीच डिलीवरी रूट को अनुकूलित कर रहे हैं और आपका वर्तमान रूट [A -> B -> C -> D] है, तो एल्गोरिथ्म [A -> B -> D -> C] या [A -> C -> B -> D] जैसे मिलते-जुलते रूट देखेगा कि क्या वे कुल दूरी कम करते हैं। रूट में हर छोटा बदलाव एक “पड़ोसी” समाधान है जो वर्तमान से बेहतर हो सकता है।

इन तुलना के लिए, एल्गोरिथ्म एक objective function पर निर्भर करता है — एक गणितीय सूत्र जो हर संभावित समाधान को एक स्कोर देता है।

यह फ़ंक्शन एक कंपास जैसा काम करता है, जो बताता है कि कौन सी दिशा “ऊपर” बेहतर समाधानों की ओर ले जाती है और कौन सी “नीचे” बदतर की ओर। डिलीवरी रूट के लिए, objective function कुल दूरी निकालता है — कम दूरी का अर्थ बेहतर समाधान। 

तो यदि रूट X में 100 मील लगते हैं और रूट Z में 90 मील, तो रूट B का स्कोर बेहतर (कम) होगा। तब एल्गोरिथ्म रूट B जैसे समाधानों की दिशा में बढ़ेगा। Objective function मूलतः जटिल रूट-अनुकूलन समस्या को एक सरल संख्या में बदल देता है, जिसे तुलना कर न्यूनतम किया जा सकता है।

3. अगला कदम चुनना

आस-पास के समाधानों को देखने के बाद, एल्गोरिथ्म को तय करना होता है कि आगे कहाँ बढ़ना है। यह नज़दीकी समाधानों के स्कोर की तुलना वर्तमान से करता है। यदि कोई बेहतर समाधान मिलता है, तो वहीं चला जाता है। हिल क्लाइम्बिंग के अलग-अलग संस्करण यह चुनाव अलग तरीकों से करते हैं:

• सिंपल संस्करण पहला बेहतर समाधान मिलते ही ले लेता है
• सावधान (careful) संस्करण सबसे अच्छा चुनने से पहले सभी पड़ोसियों को जाँचता है
• यादृच्छिक (random) संस्करण कभी-कभी सर्वश्रेष्ठ से कमतर को भी चुनता है, जिससे फँसने से बचाव होता है

4. कब रुकना है, जानना

एल्गोरिथ्म को पता होना चाहिए कि बेहतर समाधानों की तलाश कब रोकनी है। आमतौर पर यह तब रुकता है जब इनमें से कोई बात होती है:

1. आस-पास कोई बेहतर समाधान नहीं मिलता
2. यह बहुत देर तक चल चुका है
3. कोई पर्याप्त रूप से अच्छा समाधान मिल गया है

काम करते हुए एल्गोरिथ्म आमतौर पर एक पैटर्न अपनाता है। शुरुआत में यह तेज़ी से बेहतर समाधान पाता है, जैसे किसी खड़ी ढलान पर बड़े कदम लेना। फिर जैसे-जैसे ऊपर आता है, रफ़्तार धीमी होती जाती है और छोटे-छोटे सुधार होते हैं, जब तक अंततः रुक न जाए। 

कभी रास्ता सीधा-सादा होता है, तो कभी बहुत उतार-चढ़ाव भरा।

AI में हिल क्लाइम्बिंग के लाभ और सीमाएँ

आइए देखें कि हिल क्लाइम्बिंग किन बातों में उपयोगी है और इसे इस्तेमाल करते समय किन समस्याओं का सामना करना पड़ सकता है।

लाभ

हिल क्लाइम्बिंग समझने और प्रोग्राम करने के लिए सबसे सरल अनुकूलन एल्गोरिथ्म में से एक है। यह एक बुनियादी नियम का पालन करता है: “यदि कुछ बेहतर है, तो वहीं जाओ।” यह कई समस्याओं के समाधान की अच्छी शुरुआत बनाता है।

जब समस्या सरल हो, हिल क्लाइम्बिंग जल्दी अच्छे समाधान दे सकता है। यह हर संभावित समाधान पर समय नहीं गंवाता — बस ऊपर की ओर बढ़ता रहता है।

एल्गोरिथ्म को अधिक मेमोरी या प्रोसेसिंग पावर नहीं चाहिए। इसे बस अपनी वर्तमान स्थिति और नज़दीकी समाधानों को याद रखना होता है, जिससे यह कई वास्तविक-जीवन समस्याओं के लिए व्यावहारिक बनता है।

सीमाएँ

बेशक, हर विधि की तरह, इसमें कुछ संभावित कमियाँ हैं: 

1. छोटे टीलों में फँस जाना

सबसे बड़ी समस्या यह है कि हिल क्लाइम्बिंग “लोकल मैक्सिमा” पर फँस सकता है — ये छोटे-छोटे टीले जैसे होते हैं, जबकि पास में एक बड़ा पहाड़ भी हो सकता है। एक बार जब एल्गोरिथ्म किसी छोटे टीले की चोटी पर पहुँच जाता है, तो वह रुक जाता है क्योंकि आस-पास सब नीचे हैं, भले ही कहीं और बहुत बेहतर समाधान मौजूद हों।

2. समतल ज़मीन की समस्या

कभी-कभी एल्गोरिथ्म समतल ज़मीन (plateau) पर पहुँच जाता है, जहाँ आस-पास के सभी समाधान समान रूप से अच्छे होते हैं। सोचिए कि फुटबॉल के सपाट मैदान पर सबसे ऊँचा बिंदु खोजने की कोशिश करें — किधर जाएँ, समझना मुश्किल हो जाता है!

3. रिज (ridge) की समस्या

एक सँकरे पहाड़ी रिज पर शीर्ष के साथ चलने की कोशिश करने जैसा समझें। एल्गोरिथ्म आगे बढ़ने के बजाय इधर-उधर डगमगाता रह सकता है। ऐसा इसलिए होता है क्योंकि बगल का हर कदम आगे बढ़ने जितना ही अच्छा दिखता है।

4. शुरुआती बिंदु का बहुत असर

आप कहाँ से शुरू करते हैं, इससे एल्गोरिथ्म का नतीजा बहुत प्रभावित होता है। हाइक की तरह — गलत जगह से शुरू किया तो सबसे ऊँची चोटी कभी मिल ही नहीं सकती।

इन सीमाओं का अर्थ यह नहीं कि हिल क्लाइम्बिंग खराब विकल्प है — बस यह कि हमें इसे कब और कैसे इस्तेमाल करना है, इस पर सतर्क रहना चाहिए। कभी-कभी हम इसे अन्य तकनीकों के साथ मिलाकर इन समस्याओं को दूर कर सकते हैं, जिसकी चर्चा अगले खंड में है।

सीमाओं से निपटने की रणनीतियाँ

हिल क्लाइम्बिंग का उपयोग करते समय, हम पहले बताई समस्याओं को सुलझाने के लिए कई चतुर रणनीतियाँ अपना सकते हैं। आइए दो मुख्य तरीकों पर नज़र डालें जो इसे बेहतर बनाते हैं।

रैंडम-रीस्टार्ट हिल क्लाइम्बिंग

छोटे टीलों में फँसने से बचने का सबसे अच्छा तरीका अलग-अलग शुरुआती बिंदुओं से चढ़ाई शुरू करना है। इसे रैंडम-रीस्टार्ट हिल क्लाइम्बिंग कहते हैं, और यह वैसा ही है जैसा सुनाई देता है — अगर आप फँस जाएँ, तो किसी नई जगह से फिर शुरू करें।

सोचिए कि आप धुँधले पर्वतमाला में सबसे ऊँचा पहाड़ ढूँढ रहे हैं। अगर आप पहली दिखी पहाड़ी पर चढ़कर उसकी चोटी तक पहुँच गए, तो आप पास के कहीं ज्यादा ऊँचे पहाड़ को चूक सकते हैं। लेकिन अगर आप अलग-अलग जगहों पर टेलीपोर्ट होकर फिर से चढ़ना शुरू कर सकें, तो अंततः सबसे ऊँची चोटी मिलने की संभावना बहुत बढ़ जाएगी।

यह ऐसे काम करता है: पहले, आप सामान्य हिल क्लाइम्बिंग एल्गोरिथ्म चलाते हैं जब तक कि वह फँस न जाए। हार मानने के बजाय, अब तक मिला सबसे अच्छा समाधान सहेज लेते हैं और फिर किसी यादृच्छिक नई जगह से शुरू करते हैं। आप यह कई बार करते हैं और अंत में सभी प्रयासों में से सर्वोत्तम समाधान चुनते हैं।

रैंडम-रीस्टार्ट की खूबी इसकी सरलता और प्रभावशीलता है। हर रीस्टार्ट आपको सबसे ऊँची चोटी पाने का नया मौका देता है। यह सामान्य हिल क्लाइम्बिंग से अधिक समय लेता है, पर सर्वश्रेष्ठ समाधान मिलने की संभावना कहीं अधिक होती है।

सिम्युलेटेड एनीलिंग

तकनीकी रूप से हिल क्लाइम्बिंग न होते हुए भी, सिम्युलेटेड एनीलिंग एक चतुर रूपांतर है जो हिल क्लाइम्बिंग की कई समस्याएँ सुलझाने में मदद करता है। यह धातु-कार्य में धातुओं के ठंडा होने और सख्त होने की प्रक्रिया से प्रेरित है। जब धातु धीरे-धीरे ठंडी होती है, तो उसके परमाणु बेहतर स्थितियाँ खोज लेते हैं, जिससे धातु मजबूत होती है।

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

यह ऐसे काम करता है: शुरुआत में, एल्गोरिथ्म एक हद तक बदतर समाधान को भी उच्च संभावना के साथ स्वीकार कर सकता है। यह संभावना दो बातों पर निर्भर करती है: नया समाधान कितना बदतर है और एल्गोरिथ्म कितना समय से चल रहा है। समय के साथ, बदतर समाधान स्वीकार करने की संभावना घटती जाती है और अंततः यह सामान्य हिल क्लाइम्बिंग जैसा व्यवहार करने लगता है।

सिम्युलेटेड एनीलिंग की असली ताकत यह है कि यह खासकर खोज की शुरुआत में छोटे टीलों और समतल क्षेत्रों से बाहर निकल सकता है। बदतर समाधानों को कभी-कभी स्वीकार कर यह:

• लोकल मैक्सिमा (छोटे टीले) से बाहर कूद सकता है
• प्लेटो (समतल क्षेत्र) पार कर सकता है
• रिज (संकीर्ण चोटियाँ) पर रास्ता बना सकता है
• समाधान-स्थान का अधिक भाग खोज सकता है

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

ये रणनीतियाँ दिखाती हैं कि कभी-कभी समस्या सुलझाने का सबसे अच्छा तरीका हमेशा सीधा कदम उठाना नहीं होता। यादृच्छिकता और नियंत्रित अव्यवस्था जोड़कर हम अक्सर सीधे रास्ते से बेहतर समाधान पा सकते हैं।

Python में एक सरल हिल क्लाइम्बिंग एल्गोरिथ्म लागू करना

अब जबकि हमने रैंडम-रीस्टार्ट और सिम्युलेटेड एनीलिंग जैसी रणनीतियों से हिल क्लाइम्बिंग को बेहतर बनाना समझ लिया है, इसे एक वास्तविक वित्तीय समस्या पर लागू करें: पोर्टफोलियो ऑप्टिमाइज़ेशन।

पोर्टफोलियो ऑप्टिमाइज़ेशन निवेशकों को अलग-अलग निवेशों में पैसा कैसे बाँटना है, यह तय करने में मदद करता है। निवेशक ऐसा पोर्टफोलियो बनाना चाहते हैं जो अधिकतम रिटर्न दे और जोखिम कम रखे। यह संतुलन खोजना कठिन है — यह कई अवयवों वाली परफेक्ट रेसिपी खोजने जैसा है।

1952 में अर्थशास्त्री हैरी मार्कोविट्ज़ ने इस समस्या का चतुर हल दिखाया। उन्होंने बताया कि जो निवेश साथ-साथ नहीं चलते, उन्हें मिलाकर जोखिम घटाया जा सकता है। इसे विविधीकरण (diversification) कहते हैं — यह “सारे अंडे एक ही टोकरी में न रखना” जैसा है।

पोर्टफोलियो बनाते समय हमें तीन मुख्य बातों का निर्धारण करना होता है:

• हम कितना कमाने की उम्मीद करते हैं (Expected Return)
• निवेश कितना जोखिमपूर्ण है (Portfolio Risk)
• क्या संभावित मुनाफ़ा जोखिम के लायक है (Risk-Adjusted Return)

यह समस्या हिल क्लाइम्बिंग के लिए उपयुक्त है क्योंकि पैसों के बँटवारे में छोटे-छोटे बदलाव आमतौर पर प्रदर्शन में छोटे बदलाव ही लाते हैं। इसे एक चिकनी पहाड़ी की तरह समझें, जहाँ हर बिंदु आपके निवेश के अलग-अलग बँटवारे का प्रतिनिधित्व करता है। जितना ऊँचा बिंदु, उतना बेहतर विकल्प।

हिल क्लाइम्बिंग से अच्छा पोर्टफोलियो खोजने के लिए हम यह करेंगे:

1. निवेशों के किसी यादृच्छिक मिश्रण से शुरुआत
2. थोड़े-थोड़े अलग मिश्रण आज़माना कि क्या वे बेहतर हैं
3. छोटे-छोटे सुधार करते रहना जब तक बेहतर विकल्प न मिलें
4. मिला हुआ सबसे अच्छा मिश्रण उपयोग करना

इस तरह हिल क्लाइम्बिंग से हम निवेशकों को लाखों संभावित संयोजनों में से बेहतर पोर्टफोलियो ढूँढने में मदद कर सकते हैं। यह एक स्मार्ट सहायक की तरह है जो तेज़ी से कई निवेश-मिश्रण परखकर जोखिम और रिटर्न का अच्छा संतुलन ढूँढ लेता है।

पहले, अपना objective function परिभाषित करें, जो अपेक्षित रिटर्न और जोखिम के बीच संतुलन बनाकर पोर्टफोलियो प्रदर्शन को मापता है। यह पोर्टफोलियो वेट्स की सूची इनपुट लेकर एक स्कोर लौटाता है, जहाँ उच्च स्कोर बेहतर पोर्टफोलियो को दर्शाता है।

def objective_function(state):
   """
   Portfolio optimization objective function that maximizes expected returns while minimizing risk.
   The state represents portfolio weights for different assets.

   Args:
       state (list): List of portfolio weights for different assets (should sum to 1)

   Returns:
       float: Portfolio score combining returns and risk
   """
   # Expected annual returns for assets (example values)
   expected_returns = [0.1, 0.12, 0.18, 0.1, 0.15]  # 8%, 12%, etc.

   # Risk (volatility) for each asset
   volatilities = [0.1, 0.2, 0.3, 0.2, 0.2]  # 10%, 20%, etc.

   # Validate input length matches expected returns/volatilities
   if len(state) != len(expected_returns):
       return float("-inf")  # Return worst possible score for invalid states

   # Calculate expected portfolio return
   portfolio_return = sum(w * r for w, r in zip(state, expected_returns))

   # Calculate portfolio risk (simplified, not using covariance matrix)
   portfolio_risk = sum(w * v for w, v in zip(state, volatilities))

   # Penalize if weights don't sum to 1 (invalid portfolio)
   weight_sum_penalty = abs(sum(state) - 1) * 100

   # Penalize negative weights (no short selling)
   negative_weight_penalty = sum(abs(min(0, w)) for w in state) * 100

   # Combine return and risk with risk aversion factor of 2
   # Higher score is better: maximize return, minimize risk and penalties
   score = (
       portfolio_return
       - 2 * portfolio_risk
       - weight_sum_penalty
       - negative_weight_penalty
   )

   return score

ऊपर दिया गया objective_function हमें यह आकलन करने में मदद करता है कि कोई निवेश पोर्टफोलियो कितना अच्छा है। आइए समझें यह कैसे काम करता है:

सबसे पहले, यह संख्याओं की एक सूची लेता है, जो बताती है कि अलग-अलग एसेट्स (जैसे स्टॉक्स या बॉन्ड्स) में हम पैसे का कितना प्रतिशत निवेश करना चाहते हैं। उदाहरण के लिए, यदि पाँच एसेट हैं, तो हम प्रत्येक में 20% निवेश कर सकते हैं।

यह फ़ंक्शन दो अहम जानकारियाँ इस्तेमाल करता है:

1. Expected returns: हर एसेट से हम कितनी कमाई की उम्मीद करते हैं (जैसे प्रति वर्ष 8% या 12%)
2. Volatilities: हर एसेट का जोखिम — ऊँची संख्या का मतलब कीमत में ज्यादा अनिश्चित उतार-चढ़ाव (जैसे क्रिप्टो)

इसके बाद फ़ंक्शन:

• हर एसेट के expected return को उसमें लगाए गए हिस्से से गुणा कर कुल अपेक्षित रिटर्न निकालता है
• हर एसेट की अस्थिरता देखकर कुल जोखिम का अनुमान लगाता है
• जाँचता है कि हमारे निवेश प्रतिशत 100% बनते हैं या नहीं (ऐसा होना चाहिए!)
• यह सुनिश्चित करता है कि हम ऐसी चीज़ न बेच रहे हों जो हमारे पास है ही नहीं (नकारात्मक प्रतिशत नहीं)

अंत में, यह सारी जानकारी एक स्कोर में समाहित कर देता है। ऊँचा स्कोर बेहतर पोर्टफोलियो दर्शाता है। रिटर्न बढ़ने से स्कोर बढ़ता है, पर जोखिम बढ़ने से घटता है। यदि प्रतिशत 100% नहीं बनते या नकारात्मक होते हैं, तो स्कोर बहुत खराब हो जाता है।

यही फ़ंक्शन हमें नीचे दिए हिल क्लाइम्बिंग एल्गोरिथ्म से सर्वश्रेष्ठ निवेश-मिश्रण ढूँढने में मदद करेगा। यदि आप objective function को पूरी तरह नहीं भी समझते, तो चिंता न करें — मुख्य बात यह है कि यह बताता है कोई निवेश-मिश्रण कितना अच्छा है और हम इससे बेहतर से बेहतर संयोजन ढूँढते जाएँगे।

अब, वेट्स में छोटे समायोजन करके नज़दीकी पोर्टफोलियो राज्यों को बनाने के लिए एक नया फ़ंक्शन परिभाषित करें।

def get_neighbors(state):
   """
   Generates neighboring states by making small adjustments to portfolio weights

   Args:
       state (list): Current portfolio weights

   Returns:
       list: List of neighboring portfolio weight configurations
   """
   neighbors = []
   step_size = 0.01  # Small adjustment to weights (1%)

   for i in range(len(state)):
       for j in range(len(state)):
           if i != j:
               # Transfer weight from asset i to asset j
               neighbor = state.copy()
               if neighbor[i] >= step_size:  # Only transfer if enough weight available
                   neighbor[i] -= step_size
                   neighbor[j] += step_size
                   neighbors.append(neighbor)

   return neighbors

get_neighbors फ़ंक्शन हमारा हिल क्लाइम्बिंग एल्गोरिथ्म का अहम हिस्सा है, जो वर्तमान पोर्टफोलियो वेट्स में छोटे समायोजन कर मिलते-जुलते आवंटन बनाता है। यह ऐसे काम करता है:

हमारे पोर्टफोलियो में हर एसेट-जोड़ी के लिए, यह एक नया आवंटन बनाता है जिसमें 1% वेट एक एसेट से दूसरे में स्थानांतरित किया जाता है। उदाहरण के लिए, यदि पाँच एसेट हैं, तो यह कोशिश करेगा:

• एसेट 1 से एसेट 2 में 1% ले जाना
• एसेट 1 से एसेट 3 में 1% ले जाना
• एसेट 1 से एसेट 4 में 1% ले जाना
• एसेट 1 से एसेट 5 में 1% ले जाना
• एसेट 2 से एसेट 1 में 1% ले जाना, और इसी तरह सभी संभावित जोड़ियों के लिए।

फंक्शन में एक सुरक्षा जाँच भी है कि तभी वेट ट्रांसफर हो जब स्रोत एसेट में पर्याप्त आवंटन (कम-से-कम 1%) हो। यह नकारात्मक वेट्स से बचाता है, जो वास्तविक पोर्टफोलियो में उचित नहीं।

इन छोटे-छोटे समायोजनों में से हर एक एक “पड़ोसी” बनाता है — एक ऐसा आवंटन जो वर्तमान से बहुत मिलता-जुलता पर थोड़ा अलग है। हिल क्लाइम्बिंग एल्गोरिथ्म फिर इन पड़ोसियों का मूल्यांकन कर बेहतर आवंटन ढूँढेगा।

1% का स्टेप साइज अलग-अलग आवंटनों का अन्वेषण और नियंत्रित बदलावों के बीच अच्छा संतुलन देता है। बड़ा स्टेप साइज इष्टतम समाधानों को चूक सकता है, जबकि छोटा खोज को बहुत धीमा बना देगा।

अब, एक सरल हिल क्लाइम्बिंग एल्गोरिथ्म लागू करें:

def simple_hill_climbing(initial_state, max_iterations=1000):
   """
   Implements Simple Hill Climbing algorithm
  
   Args:
       initial_state (list): Starting point for the algorithm
       max_iterations (int): Maximum number of iterations to prevent infinite loops
  
   Returns:
       tuple: (best_state, best_value) found by the algorithm
   """
   current_state = initial_state
   current_value = objective_function(current_state)
  
   for _ in range(max_iterations):
       # Get neighboring states
       neighbors = get_neighbors(current_state)
      
       # Flag to check if we found a better neighbor
       found_better = False
      
       # Check neighbors one by one (Simple Hill Climbing)
       for neighbor in neighbors:
           neighbor_value = objective_function(neighbor)
          
           # If we find a better neighbor, move to it immediately
           if neighbor_value > current_value:
               current_state = neighbor
               current_value = neighbor_value
               found_better = True
               break
      
       # If no better neighbor was found, we've reached a peak
       if not found_better:
           break
  
   return current_state, current_value

यह फ़ंक्शन शुरुआती स्थिति से शुरू करता है और क्रमिक रूप से बेहतर पड़ोसी स्थितियों की ओर बढ़ता है, जब तक कि लोकल मैक्सिमम या अधिकतम iterations तक न पहुँच जाए।

यह फ़ंक्शन दो पैरामीटर लेता है:

• initial_state: अनुकूलन का शुरुआती बिंदु, मानों की सूची के रूप में
• max_iterations: अनंत लूप से बचने के लिए सुरक्षा पैरामीटर, डिफ़ॉल्ट 1000

एल्गोरिथ्म इस तरह काम करता है:

1. यह initial_state से शुरू कर उसका objective value निकालता है
2. हर iteration में यह:

• get_neighbors() से पड़ोसी स्थितियाँ बनाता है
• हर पड़ोसी का एक-एक करके मूल्यांकन करता है
• जैसे ही बेहतर पड़ोसी (ऊँचे objective value वाला) मिलता है, उसी पर चला जाता है
• यदि कोई बेहतर पड़ोसी नहीं मिला, तो लोकल मैक्सिमम पर पहुँचकर समाप्त हो जाता है

फ़ंक्शन एक ट्यूपल लौटाता है, जिसमें शामिल है:

• मिली हुई सर्वश्रेष्ठ स्थिति (मानों की सूची)
• उस स्थिति का objective function मान

हिल क्लाइम्बिंग का यह “सिंपल” रूप लोभी (greedy) है — यह सभी पड़ोसियों का सर्वश्रेष्ठ ढूँढने के बजाय पहला बेहतर मिलते ही उस पर चला जाता है। इससे यह तेज़ होता है, पर अधिक गहन होने से मिल सकने वाले बेहतर समाधानों को चूक भी सकता है।

एल्गोरिथ्म स्थानीय optimum ढूँढने में उपयोगी है, पर स्थानीय मैक्सिमा पर फँस सकता है और वैश्विक मैक्सिमम छूट सकता है। इसके बावजूद, सादगी और दक्षता के कारण यह लोकप्रिय है।

आइए इसे एक नमूना पोर्टफोलियो पर परखें:

# Example usage
initial_state = [0.15, 0.25, 0.1, 0.3, 0.2]
best_state, best_value = simple_hill_climbing(initial_state)
print(f"Initial State: {initial_state}")
print(f"Best State Found: {best_state}")
print(f"Best Value: {best_value}")

[OUT]:

Initial State: [0.15, 0.25, 0.1, 0.3, 0.2]
Best State Found: [0.9700000000000006, 0.009999999999999913, 1.0408340855860843e-17, 0.009999999999999858, 0.009999999999999969]
Best Value: -0.1053000000000444

आउटपुट दिखाता है कि पोर्टफोलियो को अनुकूलित करते समय हमारे हिल क्लाइम्बिंग एल्गोरिथ्म ने क्या परिणाम दिए। पाँच एसेट्स के यादृच्छिक वेट्स से शुरू करके, इसे एक नया वेट सेट मिला जिसने objective function का मान सुधारा। हालाँकि यह समाधान शुरुआती पोर्टफोलियो से बेहतर है, यह संभव है कि यह केवल एक स्थानीय optimum हो, क्योंकि एल्गोरिथ्म पहली मिली चोटी पर रुक जाता है।

AI में हिल क्लाइम्बिंग के उपयोग

हिल क्लाइम्बिंग एल्गोरिथ्म का उपयोग कृत्रिम बुद्धिमत्ता और मशीन लर्निंग के कई क्षेत्रों में होता है। आइए कुछ प्रमुख उपयोग देखें:

1. मशीन लर्निंग मॉडल अनुकूलन

हिल क्लाइम्बिंग कई तरीकों से ML मॉडलों को ट्यून करने में मदद करता है:

• फ़ीचर चयन: मॉडल के लिए सर्वोत्तम फीचर्स का उपसमुच्चय ढूँढना
• हाइपरपैरामीटर ट्यूनिंग: लर्निंग रेट या ट्री डेप्थ जैसे पैरामीटर अनुकूलित करना
• न्यूरल नेटवर्क प्रशिक्षण: नेटवर्क वेट्स और आर्किटेक्चर का फाइन-ट्यूनिंग
• मॉडल कंप्रेशन: प्रदर्शन बनाए रखते हुए मॉडल आकार घटाना

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

2. रोबोटिक्स और पाथ प्लानिंग

रोबोटिक्स में, हिल क्लाइम्बिंग मदद करता है:

• मोशन प्लानिंग: भौतिक स्पेस में कुशल रास्ते ढूँढना
• जॉइंट एंगल ऑप्टिमाइज़ेशन: रोबोटिक आर्म्स के इष्टतम पोज़िशन तय करना
• सेंसर प्लेसमेंट: अधिकतम कवरेज के लिए सेंसरों का स्थान अनुकूलित करना
• बैटरी मैनेजमेंट: पावर खपत पैटर्न का अनुकूलन

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

3. नेचुरल लैंग्वेज प्रोसेसिंग

NLP में उपयोग शामिल हैं:

• टेक्स्ट समरीकरण: सार-सामग्री के चयन का अनुकूलन
• वर्ड एम्बेडिंग: शब्द-वेक्टर निरूपण का फाइन-ट्यूनिंग
• डॉक्युमेंट क्लस्टरिंग: दस्तावेज़ों को इष्टतम समूहों में संगठित करना
• सर्च इंजन ऑप्टिमाइज़ेशन: खोज परिणाम रैंकिंग में सुधार

उदाहरण के लिए, टेक्स्ट समरीकरण में, हिल क्लाइम्बिंग सूचनात्मकता को अधिकतम और पुनरावृत्ति को न्यूनतम करने वाली वाक्यों का चयन करने में मदद कर सकता है।

4. कंप्यूटर विज़न छवि प्रसंस्करण और कंप्यूटर विज़न में

• इमेज सेगमेंटेशन: वस्तुओं के बीच सर्वोत्तम सीमाएँ ढूँढना
• कैमरा कैलिब्रेशन: बेहतर इमेज क्वालिटी के लिए कैमरा पैरामीटर समायोजित करना
• ऑब्जेक्ट डिटेक्शन: बाउंडिंग बॉक्स पोज़िशन अनुकूलित करना
• फ़ीचर मै칭: छवियों के बीच समकक्ष बिंदु ढूँढना

एक फेशियल रिकग्निशन सिस्टम प्रीप्रोसेसिंग के दौरान चेहरे की विशेषताओं के एलाइनमेंट को अनुकूलित करने के लिए हिल क्लाइम्बिंग का उपयोग कर सकता है।

5. गेम AI और निर्णय-निर्माण

हिल क्लाइम्बिंग इन कार्यों में मदद करता है:

• गेम रणनीति अनुकूलन: बोर्ड गेम्स में जीत दिलाने वाली चालें ढूँढना
• संसाधन आवंटन: रणनीति खेलों में संसाधनों का वितरण अनुकूलित करना
• NPC व्यवहार: नॉन-प्लेयर कैरेक्टर के निर्णयों में सुधार
• लेवल जनरेशन: संतुलित और रोचक गेम लेवल बनाना

शतरंज इंजन अक्सर गेमप्ले के दौरान चाल अनुक्रमों का मूल्यांकन और अनुकूलन करने के लिए हिल क्लाइम्बिंग के रूपांतरों का उपयोग करते हैं।

6. व्यवसाय और संचालन

व्यावहारिक व्यावसायिक उपयोगों में शामिल हैं:

• सप्लाई चेन ऑप्टिमाइज़ेशन: कुशल डिलीवरी रूट्स ढूँढना
• रिसोर्स शेड्यूलिंग: स्टाफ शेड्यूल या मशीन उपयोग का अनुकूलन
• पोर्टफोलियो मैनेजमेंट: निवेश पोर्टफोलियो का संतुलन
• इन्वेंटरी मैनेजमेंट: स्टॉक स्तरों का अनुकूलन

एक डिलीवरी कंपनी ट्रैफ़िक पैटर्न और पैकेज प्राथमिकताओं के आधार पर डिलीवरी रूट्स को लगातार अनुकूलित करने के लिए हिल क्लाइम्बिंग का उपयोग कर सकती है।

हालाँकि हिल क्लाइम्बिंग हमेशा पूर्णतम समाधान न भी ढूँढे, इसकी सादगी और दक्षता इसे इन वास्तविक-जीवन उपयोगों के लिए मूल्यवान बनाती है। यह विशेष रूप से तब उपयोगी है जब:

• त्वरित समाधान चाहिए
• समस्या-स्थान व्यापक है और संपूर्ण खोज संभव नहीं
• अनुमानित समाधान स्वीकार्य हैं
• समाधान-स्थान अपेक्षाकृत चिकना है
• बेहतर परिणामों के लिए एल्गोरिथ्म को अन्य तकनीकों से मिलाया जा सकता है

निष्कर्ष

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

हमने देखा कि कैसे क्रमशः बेहतर समाधानों की ओर बढ़ने की यह सरल अवधारणा, मशीन लर्निंग, रोबोटिक्स, नेचुरल लैंग्वेज प्रोसेसिंग और बिज़नेस ऑपरेशंस जैसी जटिल चुनौतियों पर लागू की जा सकती है। 

हालाँकि एल्गोरिथ्म में लोकल ऑप्टिमा में फँसने जैसी सीमाएँ हैं, रैंडम-रीस्टार्ट और सिम्युलेटेड एनीलिंग जैसी रणनीतियाँ इन चुनौतियों का प्रभावी समाधान पेश करती हैं।

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

चाहे आप न्यूरल नेटवर्क वेट्स अनुकूलित कर रहे हों, रोबोट के मार्ग की योजना बना रहे हों, या निवेश पोर्टफोलियो प्रबंधित कर रहे हों, हिल क्लाइम्बिंग के सिद्धांत यह समझने में मूल्यवान अंतर्दृष्टि देते हैं कि कंप्यूटर कैसे व्यवस्थित रूप से बेहतर समाधान ढूँढते हैं।

यदि आप AI और उसके पीछे के एल्गोरिथ्म के बारे में और सीखना चाहते हैं, तो हमारे संसाधन देखें:

• A* सर्च एल्गोरिथ्म को समझना
• Python में AI के लिए मिनिमैक्स एल्गोरिथ्म लागू करना
• मशीन लर्निंग के उपयोग के मामले और एल्गोरिथ्म
• ग्रेडिएंट बूस्टिंग एल्गोरिथ्म गाइड
• Developing AI Applications ट्रैक
• AI Fundamentals ट्रैक