ऑब्जेक्टिव फ़ंक्शन समझाया गया: परिभाषा, उदाहरण, और ऑप्टिमाइज़ेशन

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

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

इस लेख में, मैं बताऊँगा कि ऑब्जेक्टिव फ़ंक्शन क्या हैं, वे लॉस और कॉस्ट फ़ंक्शनों से कैसे भिन्न हैं, और मशीन लर्निंग व ऑप्टिमाइज़ेशन में उनका उपयोग कैसे होता है।

2026 में भी प्रासंगिक डीप लर्निंग पर गहराई से जाना चाहते हैं? हमारे Deep Learning in Python कोर्स में नामांकन करें और PyTorch पोर्टफोलियो बनाइए।

ऑब्जेक्टिव फ़ंक्शन क्या है?

ऑब्जेक्टिव फ़ंक्शन एक गणितीय फ़ंक्शन है जो यह आकलन करता है कि कोई समाधान कितना अच्छा है।

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

इसी विषय पर रहते हुए, आइए सामान्य रूप से ऑप्टिमाइज़ेशन पर बात करें।

यह उन इनपुट्स को खोजने की प्रक्रिया है जो उस संख्या को सही दिशा में धकेलें। यदि आप मिनिमाइज़ कर रहे हैं, तो आप सबसे छोटा संभावित मान चाहते हैं। यदि आप मैक्सिमाइज़ कर रहे हैं, तो सबसे बड़ा। किसी भी तरह, ऑब्जेक्टिव फ़ंक्शन वही है जिसके विरुद्ध आप माप रहे होते हैं।

सरल शब्दों में, इसे एक स्कोरिंग सिस्टम के रूप में सोचें। हर संभावित समाधान को एक स्कोर मिलता है, और आपका काम उस समाधान को खोजना है जिसका स्कोर सबसे अच्छा हो।

ऑब्जेक्टिव फ़ंक्शन बनाम लॉस फ़ंक्शन बनाम कॉस्ट फ़ंक्शन

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

सबसे व्यापक शब्द ऑब्जेक्टिव फ़ंक्शन है। यह कोई भी फ़ंक्शन है जिसे आप अधिकतम या न्यूनतम करना चाहते हैं। इसमें त्रुटि या पूर्वानुमान शामिल होना ज़रूरी नहीं है - यह केवल यह परिभाषित करता है कि आपकी समस्या के लिए "बेहतर" का क्या अर्थ है।

एक लॉस फ़ंक्शन एकल प्रशिक्षण उदाहरण के लिए त्रुटि को मापता है - आपके मॉडल का पूर्वानुमान वास्तविक मान से कितना दूर है। उदाहरण के लिए, एक डेटा बिंदु के लिए मीन स्क्वायर्ड एरर एक लॉस फ़ंक्शन है।

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

व्यवहार में, अधिकांश ML फ्रेमवर्क और शोध-पत्र इन शब्दों का ढीले रूप में उपयोग करते हैं। आप "लॉस" का उपयोग वहाँ भी देखेंगे जहाँ "कॉस्ट" अधिक सटीक होगा, और "ऑब्जेक्टिव" का उपयोग तीनों के अर्थ में होता है।

जब आप शोध-पत्र पढ़ते हैं तो ये भेद मायने रखते हैं। प्रसंग बताता है कि लेखक वास्तव में किसकी ओर इशारा कर रहा है।

और ठोस तुलना के लिए नीचे दी गई तालिका देखें:

ऑब्जेक्टिव/लॉस/कॉस्ट फ़ंक्शन तुलना तालिका

ऑप्टिमाइज़ेशन में ऑब्जेक्टिव फ़ंक्शंस

हर ऑप्टिमाइज़ेशन समस्या का एक लक्ष्य और कुछ सीमाएँ होती हैं।

ऑब्जेक्टिव फ़ंक्शन लक्ष्य परिभाषित करता है - आप क्या अधिकतम या न्यूनतम करना चाहते हैं। कंस्ट्रेंट्स सीमाएँ परिभाषित करते हैं - वे हदें जिनके भीतर आपके समाधान को रहना है। साथ मिलकर ये समस्या का ढांचा बनाते हैं।

एक सरल संसाधन आवंटन उदाहरण लें।

मान लीजिए आप दो उत्पाद बनाती फैक्टरी चला रहे हैं, और आप लाभ को अधिकतम करना चाहते हैं। आपका ऑब्जेक्टिव फ़ंक्शन कुल लाभ को दर्शाता है, जो इस पर निर्भर है कि आप प्रत्येक उत्पाद के कितने यूनिट बनाते हैं। आपके कंस्ट्रेंट्स सीमाएँ दर्शाते हैं - उपलब्ध कच्चा माल, मशीन घंटों, श्रम क्षमता। ऑब्जेक्टिव फ़ंक्शन बताता है कि क्या ऑप्टिमाइज़ करना है और कंस्ट्रेंट्स बताते हैं कि आपके पास क्या उपलब्ध है।

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

यह ध्यान देना महत्वपूर्ण है कि ऑब्जेक्टिव फ़ंक्शन कंस्ट्रेंट्स को बदलता नहीं है - यह सिर्फ सॉल्वर को बताता है कि किसके पीछे जाना है। यदि आप ऑब्जेक्टिव फ़ंक्शन बदलते हैं, तो समान कंस्ट्रेंट्स के साथ भी आपको बिल्कुल अलग समाधान मिलेगा।

मशीन लर्निंग में ऑब्जेक्टिव फ़ंक्शंस

मशीन लर्निंग में, ऑब्जेक्टिव फ़ंक्शन यह परिभाषित करता है कि आपका मॉडल वास्तव में क्या सीख रहा है।

जब भी आप कोई मॉडल ट्रेन करते हैं, आप एक ऑप्टिमाइज़ेशन एल्गोरिद्म (जैसे ग्रेडिएंट डीसेंट, Adam, RMSProp) चलाते हैं जो मॉडल पैरामीटर्स को समायोजित करता है ताकि ऑब्जेक्टिव फ़ंक्शन को मिनिमाइज़ या मैक्सिमाइज़ किया जा सके। मॉडल आपकी समस्या के बारे में कुछ नहीं जानता। वह केवल ऑब्जेक्टिव फ़ंक्शन द्वारा दिए गए स्कोर को जानता है, और हर अपडेट के साथ उस स्कोर को बेहतर बनाने की कोशिश करता है।

इसका मतलब है कि ऑब्जेक्टिव फ़ंक्शन का चुनाव परिणाम को आकार देता है। अपने मामले में कौन सा सबसे अच्छा काम करता है, यह देखने के लिए कुछ विकल्प आज़माना अच्छा विचार है।

मीन स्क्वायर्ड एरर (रिग्रेशन)

Mean Squared Error (MSE) रिग्रेशन समस्याओं के लिए डिफ़ॉल्ट ऑब्जेक्टिव फ़ंक्शन है। यह आपके मॉडल की भविष्यवाणियों और वास्तविक लक्षित मानों के बीच औसत वर्ग अंतर को मापता है।

MSE सूत्र

अंतर का वर्ग लेने से सभी त्रुटियाँ धनात्मक हो जाती हैं और बड़ी त्रुटियों को छोटी त्रुटियों की तुलना में अधिक दंड मिलता है। 10 की गलती 10 नहीं, बल्कि 100 का योगदान देती है। यह MSE को आउटलाईयर्स के प्रति संवेदनशील बनाता है, जो वास्तविक दुनिया के गंदे डेटा में ध्यान देने योग्य बात है।

import numpy as np

y_true = np.array([3.0, 5.0, 2.5, 7.0])
y_pred = np.array([2.8, 5.2, 2.0, 6.5])

mse = np.mean((y_true - y_pred) ** 2)
print(f"MSE: {mse:.4f}")

MSE आउटपुट

क्रॉस-एंट्रॉपी लॉस (क्लासिफिकेशन)

Cross-Entropy Loss क्लासिफिकेशन समस्याओं के लिए मानक ऑब्जेक्टिव फ़ंक्शन है। यह मापता है कि आपके मॉडल का प्रत्याशित प्रायिकता वितरण वास्तविक क्लास वितरण से कितना दूर है।

क्रॉस-एंट्रॉपी लॉस फ़ंक्शन

यदि आपका मॉडल सही क्लास को उच्च प्रायिकता देता है, तो लॉस कम होता है। यदि वह आश्वस्त है लेकिन गलत है, तो लॉस अधिक होता है, और यह उसे दंडित करता है। यही मॉडल को सही क्लास का पूर्वानुमान लगाने और उस पर आत्मविश्वासी होने के लिए प्रेरित करता है।

import numpy as np

# True labels (one-hot encoded)
y_true = np.array([1, 0, 0])

# Model's predicted probabilities
y_pred = np.array([0.7, 0.2, 0.1])

cross_entropy = -np.sum(y_true * np.log(y_pred))
print(f"Cross-Entropy Loss: {cross_entropy:.4f}")

क्रॉस-एंट्रॉपी आउटपुट

लॉग-लाइकलीहुड

लॉग-लाइकलीहुड प्रायिकतामूलक और सांख्यिकीय मॉडलों में सामान्य है। यह फ़ंक्शन उस प्रायिकता को अधिकतम करता है कि आपके मॉडल के पैरामीटर्स ने अवलोकित डेटा उत्पन्न किया।

लॉग-लाइकलीहुड सूत्र

आप लाइकलीहुड के बजाय उसके लॉग के साथ काम करते हैं क्योंकि यह प्रायिकताओं के गुणन को जोड़ में बदल देता है, जिसे गणना और ऑप्टिमाइज़ करना अधिक आसान होता है।

व्यवहार में, अधिकांश फ्रेमवर्क लॉग-लाइकलीहुड को अधिकतम करने के बजाय नेगेटिव लॉग-लाइकलीहुड (NLL) को मिनिमाइज़ करते हैं। यह वही बात है - बस उलट दी जाती है ताकि ग्रेडिएंट डीसेंट उस पर काम कर सके।

import numpy as np
from scipy.stats import norm

# Observed data
data = np.array([1.2, 2.3, 1.8, 2.1, 1.9])

# Assumed model parameters
mu, sigma = 2.0, 0.5

# Compute negative log-likelihood
nll = -np.sum(norm.logpdf(data, loc=mu, scale=sigma))
print(f"Negative Log-Likelihood: {nll:.4f}")

लॉग-लाइकलीहुड आउटपुट

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

कॉन्वेक्स बनाम नॉन-कॉन्वेक्स ऑब्जेक्टिव फ़ंक्शंस

सभी ऑब्जेक्टिव फ़ंक्शंस समान नहीं बनाए जाते। उनका आकार तय करता है कि उन्हें ऑप्टिमाइज़ करना कितना कठिन है और क्या आप पाए गए समाधान पर भरोसा कर सकते हैं।

लिनियर ऑब्जेक्टिव फ़ंक्शंस

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

लिनियर फ़ंक्शंस का उपयोग लिनियर प्रोग्रामिंग में होता है, जहाँ ऑब्जेक्टिव और कंस्ट्रेंट्स दोनों रैखिक होते हैं। ये ऑब्जेक्टिव फ़ंक्शंस का सबसे आसान वर्ग है जिसे ऑप्टिमाइज़ किया जा सकता है, क्योंकि सॉल्वर बड़े समस्याओं में भी विश्वसनीय रूप से ग्लोबल ऑप्टिमम खोज सकते हैं।

नॉनलाइनियर ऑब्जेक्टिव फ़ंक्शंस

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

MSE नॉनलाइनियर है। क्रॉस-एंट्रॉपी नॉनलाइनियर है। न्यूरल नेटवर्क के लॉस सरफेस नॉनलाइनियर हैं। यह अतिरिक्त जटिलता इन फ़ंक्शनों को डेटा में जटिल संबंधों को कैप्चर करने देती है, लेकिन ऑप्टिमाइज़ेशन को भी कठिन बनाती है।

कॉन्वेक्स बनाम नॉन-कॉन्वेक्स फ़ंक्शंस

यही वह जगह है जहाँ चीजें रोचक हो जाती हैं।

कॉन्वेक्स फ़ंक्शन का आकार कटोरे जैसा होता है। वक्र पर किसी भी दो बिंदुओं को मिलाने वाली रेखा खंड वक्र के ऊपर या उस पर ही रहती है। यह सुनिश्चित करता है कि कोई भी लोकल मिनिमम ग्लोबल मिनिमम भी होता है - यानी यदि आपका ऑप्टिमाइज़र किसी तलहटी को पाता है, तो वही वास्तविक तलहटी है।

नॉन-कॉन्वेक्स फ़ंक्शन का आकार अधिक अनियमित होता है - कई घाटियाँ, पठार, और सैडल पॉइंट्स। ऑप्टिमाइज़र लोकल मिनिमम में फँस सकते हैं, ऐसी घाटी जो तलहटी जैसी दिखती है लेकिन है नहीं। डीप न्यूरल नेटवर्क्स के लॉस सरफेस अत्यधिक नॉन-कॉन्वेक्स होते हैं, इसलिए उन्हें ट्रेन करना लर्निंग रेट, ऑप्टिमाइज़र और इनिशियलाइज़ेशन की सावधानीपूर्वक ट्यूनिंग माँगता है।

कॉन्वेक्स समस्याएँ सटीक रूप से हल होती हैं, और नॉन-कॉन्वेक्स समस्याएँ अनुमानित रूप से। आपके समाधान की गुणवत्ता आपके ऑप्टिमाइज़ेशन स्ट्रैटजी पर निर्भर करती है।

दृश्य-उन्मुख पाठकों के लिए, यहाँ लिनियर, नॉनलाइनियर, कॉन्वेक्स, और नॉन-कॉन्वेक्स ऑब्जेक्टिव फ़ंक्शंस की तुलना है:

ऑब्जेक्टिव फ़ंक्शन प्रकार तुलना

ऑब्जेक्टिव फ़ंक्शंस को कैसे ऑप्टिमाइज़ किया जाता है

एक बार जब आपके पास ऑब्जेक्टिव फ़ंक्शन होता है, तो आपको इसे मिनिमाइज़ या मैक्सिमाइज़ करने का तरीका चाहिए। यहीं ऑप्टिमाइज़ेशन एल्गोरिद्म काम आते हैं।

सबसे सामान्य तरीका है ग्रेडिएंट डीसेंट। विचार यह है कि ऑब्जेक्टिव फ़ंक्शन का आपके मॉडल के पैरामीटर्स के सापेक्ष ग्रेडिएंट निकालें, फिर उस दिशा में एक छोटा कदम लें जो मान को घटाती है। वहाँ से, तब तक दोहराएँ जब तक मान में सुधार रुक न जाए।

ग्रेडिएंट बस ऑब्जेक्टिव फ़ंक्शन का डेरिवेटिव है।

यह आपकी वर्तमान स्थिति पर ढलान और कौन-सी दिशा "ऊपर की ओर" है, बताता है। फ़ंक्शन को मिनिमाइज़ करने के लिए, आप विपरीत दिशा में चलते हैं। मैक्सिमाइज़ करने के लिए, उसी दिशा में।

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

व्यवहार में, अधिकांश ML फ्रेमवर्क ग्रेडिएंट डीसेंट के ऐसे वेरिएंट्स का उपयोग करते हैं जो बुनियादी संस्करण से तेज़ और अधिक स्थिर होते हैं:

• Stochastic Gradient Descent (SGD) पूरे डेटासेट के बजाय प्रति स्टेप एक रैंडम उदाहरण पर ग्रेडिएंट गणना करता है
• मिनी-बैच ग्रेडिएंट डीसेंट प्रति स्टेप उदाहरणों का एक छोटा बैच उपयोग करता है - SGD और फुल-बैच के बीच का मध्यम मार्ग
• Adam प्रत्येक पैरामीटर के लिए लर्निंग रेट को अनुकूलित करता है, जिससे इसे ट्यून करना अधिक सहनशील हो जाता है

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

ऑब्जेक्टिव फ़ंक्शन का उदाहरण

आइए इसे एक सरल लिनियर रिग्रेशन समस्या से ठोस बनाते हैं।

मान लीजिए आप स्क्वायर फ़ुटेज के आधार पर घरों की कीमत का पूर्वानुमान लगा रहे हैं। आपके पास ज्ञात कीमतों के साथ घरों का डेटासेट है, और आप डेटा के माध्यम से ऐसी रेखा फिट करना चाहते हैं जो पूर्वानुमान त्रुटि को न्यूनतम करे। आपका ऑब्जेक्टिव फ़ंक्शन Mean Squared Error (MSE) है, जिसका सूत्र आपको पहले से मालूम है।

इनपुट्स आपके मॉडल के पैरामीटर्स हैं - रेखा का स्लोप और इंटरसेप्ट। आउटपुट एक एकल संख्या है - सभी प्रेडिक्शंस में औसत वर्ग त्रुटि। इस स्थिति में, कम होना बेहतर है।

संभावित Python इम्प्लीमेंटेशन कुछ इस प्रकार दिख सकता है:

import numpy as np

np.random.seed(42)

# Generate some fake housing data
square_footage = np.random.uniform(500, 3000, 100)
true_price = 150 * square_footage + 50000 + np.random.normal(0, 15000, 100)

def predict(x, slope, intercept):
    return slope * x + intercept

def mse(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)

# Try two different parameter sets
slope_a, intercept_a = 150, 50000  # good fit
slope_b, intercept_b = 80, 100000  # bad fit

pred_a = predict(square_footage, slope_a, intercept_a)
pred_b = predict(square_footage, slope_b, intercept_b)

print(f"MSE (good fit):  {mse(true_price, pred_a):,.2f}")
print(f"MSE (poor fit):  {mse(true_price, pred_b):,.2f}")

MSE अच्छा बनाम खराब फिट

पहला पैरामीटर सेट बहुत कम MSE देता है, जिसका मतलब है कि वह डेटा को बेहतर फिट करता है। यही बात ऑप्टिमाइज़र तय करने में उपयोग करता है कि किस दिशा में आगे बढ़ना है।

दृश्य-उन्मुख पाठकों के लिए, निम्न छवि पर विचार करें:

MSE उदाहरण

आप दोनों फिट्स को डेटा के विरुद्ध देख सकते हैं, और स्लोप मानों की एक श्रेणी में MSE सरफेस भी देख सकते हैं ताकि स्वयं ऑब्जेक्टिव फ़ंक्शन को समझ सकें।

बायाँ प्लॉट दिखाता है कि दोनों पैरामीटर सेट डेटा में कैसे फिट होते हैं। दायाँ प्लॉट स्लोप मानों पर MSE सरफेस दिखाता है - एक वक्र के रूप में ऑब्जेक्टिव फ़ंक्शन, जिसमें एक स्पष्ट न्यूनतम है जिसे ऑप्टिमाइज़र खोजने की कोशिश कर रहा है। ग्रेडिएंट डीसेंट का हर कदम इस वक्र के साथ उस न्यूनतम की ओर बढ़ता है।

कंस्ट्रेंट्स और ऑब्जेक्टिव फ़ंक्शंस

ऑब्जेक्टिव फ़ंक्शन बताता है कि क्या ऑप्टिमाइज़ करना है। कंस्ट्रेंट्स बताते हैं कि आप क्या करने की अनुमति रखते हैं।

अधिकांश वास्तविक समस्याओं में, आप मनचाहा अधिकतम या न्यूनतम नहीं कर सकते। आप सीमाओं के भीतर काम करते हैं, जैसे बजट, समय-सीमा, या भौतिक क्षमता। इन सीमाओं को कंस्ट्रेंट्स कहा जाता है, और ये वैध समाधानों के उस सेट को परिभाषित करते हैं जिनमें से आपका ऑप्टिमाइज़र चुन सकता है।

एक मैन्युफैक्चरिंग उदाहरण लें।

मान लीजिए आप दो प्रोडक्ट लाइनों में लाभ को अधिकतम करना चाहते हैं। बिना कंस्ट्रेंट्स के, उत्तर है जितना संभव हो उतना उत्पादन करना। लेकिन आपके पास 500 मशीन घंटे और 1,000 यूनिट कच्चा माल उपलब्ध हैं। ये आपके कंस्ट्रेंट्स हैं। ऑब्जेक्टिव फ़ंक्शन वही रहता है (लाभ अधिकतम करें), लेकिन ऑप्टिमाइज़र केवल उन सीमाओं द्वारा अनुमत क्षेत्र के भीतर ही खोज कर सकता है।

जब आप कंस्ट्रेंट्स बदलते हैं, तो इष्टतम समाधान भी बदल जाता है, भले ही ऑब्जेक्टिव फ़ंक्शन न बदले।

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

निष्कर्ष

हर ऑप्टिमाइज़ेशन समस्या - चाहे आप न्यूरल नेटवर्क ट्रेन कर रहे हों, संसाधन आवंटित कर रहे हों, या रिग्रेशन मॉडल फिट कर रहे हों - अंततः एक बात पर आकर ठहरती है: एक फ़ंक्शन जिसे आप मिनिमाइज़ या मैक्सिमाइज़ करना चाहते हैं।

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

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

समझ नहीं आ रहा कहाँ से शुरू करें? हमारे Model Validation in Python और Hyperparameter Tuning in Python कोर्स शुरुआती से मध्यवर्ती डेटा वैज्ञानिकों के लिए शुरू करने के बेहतरीन स्थान हैं।