कॉन्ट्रास्टिव लर्निंग: मॉडल तुलना करके कैसे सीखते हैं

बिना लेबल वाले डेटा से मॉडल को सीखाना असंभव लगता है, लेकिन यही विचार कॉन्ट्रास्टिव लर्निंग के पीछे है।

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

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

इस लेख में, मैं आपको कॉन्ट्रास्टिव लर्निंग के पीछे की सहज समझ, यह अंदर से कैसे काम करती है, इसे व्यवहार में कहाँ उपयोग किया जाता है—इमेज रिकग्निशन से लेकर NLP एम्बेडिंग्स तक—और इसे PyTorch में कैसे लागू करें, सब समझाऊँगा।

कंप्यूटर विज़न वास्तव में क्या है? हमारा इमेज विश्लेषण के लिए शुरुआती मार्गदर्शक पढ़ें।

कॉन्ट्रास्टिव लर्निंग क्या है?

कॉन्ट्रास्टिव लर्निंग एक ऐसा प्रशिक्षण दृष्टिकोण है जिसमें मॉडल वर्गीकरण के बजाय तुलना करके सीखता है।

मॉडल को "यह बिल्ली है" या "यह कुत्ता है" बताने के बजाय, आप उसे उदाहरणों के जोड़े दिखाते हैं और उसे समझने देते हैं कि क्या साथ में आता है और क्या नहीं। मॉडल यह जानकर सीखता है कि ये दो चीज़ें आपस में मिलती-जुलती हैं या नहीं।

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

मॉडल का काम ऐसे रिप्रेजेंटेशन (संख्यात्मक वेक्टर) बनाना है जो इस संरचना का पालन करें। सकारात्मक जोड़ियाँ वेक्टर स्पेस में पास-पास आएँ। नकारात्मक जोड़ियाँ दूर-दूर रहें।

कॉन्ट्रास्टिव लर्निंग के पीछे की सहज समझ

कॉन्ट्रास्टिव लर्निंग को समझने का सबसे आसान तरीका तस्वीरों के माध्यम से है।

किसी कुत्ते की एक फोटो लें। अब उसकी दो संस्करण बनाएँ—एक क्रॉप्ड, एक में ब्राइटनेस बदली हुई। आप जो सामग्री देखते हैं वह समान है, लेकिन पिक्सेल अलग हैं। एक कॉन्ट्रास्टिव लर्निंग मॉडल इन दोनों संस्करणों को सकारात्मक जोड़ी मानता है और इन्हें वेक्टर स्पेस में मिलते-जुलते स्थानों पर मैप करना सीखता है।

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

आपको मैन्युअल रूप से हस्तक्षेप करके यह बताने की जरूरत नहीं कि "यह कुत्ता है" या "यह कार है"। मॉडल समानता और भिन्नता की संरचना से अपनी समझ बनाता है।

यही बात कॉन्ट्रास्टिव लर्निंग को शक्तिशाली बनाती है।

संकेत तुलना से आता है। पर्याप्त जोड़ियों के साथ, मॉडल ऐसे रिप्रेजेंटेशन विकसित कर सकता है जो समझें कि चीज़ें आपस में क्यों मिलती-जुलती हैं और क्या उन्हें अलग करता है।

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

कॉन्ट्रास्टिव लर्निंग के उपयोग

कॉन्ट्रास्टिव लर्निंग कई क्षेत्रों में दिखती है—सबसे अधिक आप इसे यहाँ देखेंगे।

कंप्यूटर व���ज़न

यहीं कॉन्ट्रास्टिव लर्निंग ने पहली बार अपनी क्षमता साबित की।

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

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

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

NLP में, कॉन्ट्रास्टिव लर्निंग का उपयोग सेंटेंस एम्बेडिंग्स को ट्रेन करने के लिए होता है—ऐसे वेक्टर रिप्रेजेंटेशन जो वाक्य के समग्र अर्थ को समझें।

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

रिकमेंडेशन सिस्टम

रिकमेंडेशन सिस्टम उपयोगकर्ता-आइटम समानता को मॉडल करने के लिए कॉन्ट्रास्टिव लर्निंग का उपयोग करते हैं।

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

मल्टीमॉडल मॉडल

यहीं कॉन्ट्रास्टिव लर्निंग वास्तव में दिलचस्प हो जाती है।

CLIP जैसे मॉडल इसे टेक्स्ट और इमेज को एक साझा वेक्टर स्पेस में संरेखित करने के लिए इस्तेमाल करते हैं। एक कुत्ते की फोटो और वाक्य "a dog playing in the park" पास-पास होने चाहिए। एक कुत्ते की फोटो और वाक्य "a red sports car" पास नहीं होने चाहिए। इससे मल्टीमॉडल मॉडल छवियों को पाठ विवरणों से मिलाते हैं और कैप्शन जनरेट करते हैं।

कॉन्ट्रास्टिव लर्निंग कैसे काम करती है

कॉन्ट्रास्टिव लर्निंग हमेशा चार चरणों का ही अनुसरण करती है, चाहे आप इमेज, टेक्स्ट या ऑडियो के साथ काम कर रहे हों।

चरण 1: जोड़ियाँ बनाना

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

चरण 2: एम्बेडिंग्स में एनकोड करना

दोनों डेटा पॉइंट्स एक एनकोडर से गुजरते हैं जो उन्हें वेक्टर में बदल देता है। ये वेक्टर, जिन्हें एम्बेडिंग्स कहा जाता है, साझा वेक्टर स्पेस में रहने वाले संख्यात्मक रिप्रेजेंटेशन हैं। लक्ष्य यह है कि यह स्पेस कच्चे पिक्सेल या टोकन मानों के बजाय अर्थगत मतलब को दर्शाए।

चरण 3: समानता की गणना

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

चरण 4: मॉडल को अपडेट करना

मॉडल अपनी समानता स्कोरों की तुलना इस बात से करता है कि उन्हें क्या होना चाहिए। सकारात्मक जोड़ियों के लिए स्कोर ऊँचा होना चाहिए। नकारात्मक जोड़ियों के लिए, यह कम होना चाहिए। एक लॉस फ़ंक्शन मापता है कि मॉडल कितनी गलती कर रहा है, और बैकप्रोपेगेशन अगली बार बेहतर करने के लिए एनकोडर के वज़न समायोजित करता है।

अगर आप इन चरणों को पर्याप्त जोड़ियों पर दोहराते हैं, तो एनकोडर ऐसी एम्बेडिंग्स बनाना सीख लेगा जो समान चीज़ों को साथ में क्लस्टर करें और अलग चीज़ों को दूर धकेलें।

सकारात्मक और नकारात्मक सैंपल

आपके कॉन्ट्रास्टिव मॉडल की गुणवत्ता इस बात पर निर्भर करती है कि आप अपनी जोड़ियाँ कैसे बनाते हैं।

सकारात्मक जोड़ियाँ दो डेटा पॉइंट्स हैं जिन्हें समान माना जाना चाहिए। ��ंप्यूटर विज़न में, आमतौर पर इसका मतलब एक ही इमेज के दो ऑगमेंटेड संस्करण होते हैं। NLP में, यह एक ही वाक्य के दो पैराफ्रेज़ या एक वाक्य और उसका अनुवाद हो सकते हैं। मॉडल सीखता है कि जो चीज़ें उनके बीच बदलती हैं, वे मायने नहीं रखतीं। केवल साझा हिस्सा मायने रखता है।

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

अब मुश्किल यहीं आती है।

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

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

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

कॉन्ट्रास्टिव लॉस फ़ंक्शन

लॉस फ़ंक्शन जोड़ी तुलना को सीखने के संकेत में बदलता है।

हर लॉस फ़ंक्शन अलग तरह से काम करता है, लेकिन सबका लक्ष्य एक ही है—जब समान चीज़ें वेक्टर स्पेस में पास हों तो मॉडल को पुरस्कृत करना, और जब न हों तो दंडित करना।

कॉन्ट्रास्टिव लॉस

कॉन्ट्रास्टिव लॉस की शुरुआत शुरुआती कॉन्ट्रास्टिव लर्निंग कार्यों के साथ हुई थी।

यह जोड़ियों पर काम करता है। किसी सकारात्मक जोड़ी के लिए, अगर उनकी एम्बेडिंग्स दूर हैं तो यह मॉडल को दंडित करता है। किसी नकारात्मक जोड़ी के लिए, अगर उनकी एम्बेडिंग्स बहुत पास हैं—खासकर अगर वे परिभाषित मार्जिन के अंदर आती हैं—तो यह दंडित करता है। जो नकारात्मक पहले से ही पर्याप्त दूर हैं, वे लॉस में योगदान नहीं देते।

कॉन्ट्रास्टिव लॉस का सूत्र

जहाँ d दो एम्बेडिंग्स के बीच की दूरी है, y नकारात्मक जोड़ियों के लिए 1 और सकारात्मक जोड़ियों के लिए 0 है, और m मार्जिन है। मार्जिन एक हाइपरपैरामीटर है जिसे आप मैन्युअल रूप से सेट करते हैं, जिससे यह लॉस ट्यूनिंग के प्रति संवेदनशील हो जाती है।

ट्रिपलेट लॉस

ट्रिपलेट लॉस एक साथ तीन डेटा पॉइंट्स के साथ काम करती है: एंकर, पॉज़िटिव और नेगेटिव।

ट्रिपलेट लॉस का सूत्र

जब भी एंकर-टू-पॉज़िटिव दूरी d(a, p) एंकर-टू-नेगेटिव दूरी d(a, n) से कम से कम मार्जिन m जितनी छोटी नहीं होती, मॉडल को दंडित किया जाता है। अगर यह शर्त पहले से पूरी है, तो लॉस शून्य होता है।

यह विधि कॉन्ट्रास्टिव लॉस की तुलना में प्रति अपडेट मॉडल को अधिक संदर्भ देती है, क्योंकि यह एक समय में एक के बजाय दोनों संबंधों की साथ में तुलना करती है।

InfoNCE लॉस

InfoNCE अधिकांश आधुनिक कॉन्ट्रास्टिव लर्निंग विधियों—जैसे SimCLR और CLIP—के पीछे का लॉस है।

InfoNCE लॉस का सूत्र

प्रत्येक एंकर z_i के लिए, मॉडल को उसके पॉज़िटिव z_j को बैच में मौजूद बाकी N उदाहरणों में से पहचानना होता है। टेम्परेचर पैरामीटर τ वितरण की शार्पनेस नियंत्रित करता है—कम मान मॉडल को अधिक भरोसेमंद बनाते हैं, अधिक मान जोड़ियों के बीच कंट्रास्ट को नरम करते हैं।

आपको प्रति अपडेट अधिक नकारात्मक मिलते हैं, जिससे मॉडल को अधिक सीखने का संकेत मिलता है। इसका मतलब यह भी है कि बड़े बैच मॉडल को कठिन नकारात्मकों से रूबरू कराते हैं और सामान्यतः बेहतर रिप्रेजेंटेशन देते हैं।

सेल्फ-सुपरवाइज्ड लर्निंग में कॉन्ट्रास्टिव लर्निंग

कॉन्ट्रास्टिव लर्निंग और सेल्फ-सुपरवाइज्ड लर्निंग साथ में अच्छी तरह काम करते हैं, और यह समझकर कि क्यों, आप समझेंगे कि आधुनिक ML किस दिशा में जा रहा है।

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

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

य��� इसलिए मायने रखता है क्योंकि अधिकतर ML पाइपलाइनों में लेबल वाला डेटा ही बाधा होता है। इसे इकट्ठा करना धीमा है, एनोटेशन महँगा है, और कुछ क्षेत्रों—जैसे मेडिकल इमेजिंग—में यह पर्याप्त मात्रा में होता ही नहीं।

अब तक के नतीजे उत्साहजनक रहे हैं। बड़े अनलेबल्ड डेटासेट्स पर कॉन्ट्रास्टिव सेल्फ-सुपरवाइज्ड उद्देश्यों के साथ प्री-ट्रेंड मॉडल्स ने, केवल थोड़े लेबल वाले डेटा पर फाइन-ट्यूनिंग के बाद, कई डाउनस्ट्रीम कार्यों पर सुपरवाइज्ड बेंचमार्क्स की बराबरी की है या क़रीब पहुँचे हैं।

सामान्य रुझान कार्य-विशिष्ट सुपरवाइज्ड प्रशिक्षण से हटकर कच्चे डेटा से पैमाने पर सीखे गए सामान्य-उद्देश्य रिप्रेजेंटेशन की ओर जा रहा है। SimCLR, MoCo और BYOL जैसी विधियाँ इसी रुझान का अनुसरण करती हैं, और मैं इन्हें आगे चर्चा करूँगा।

लोकप्रिय कॉन्ट्रास्टिव लर्निंग विधियाँ

2026 में कॉन्ट्रास्टिव लर्निंग के पीछे की तीन सबसे प्रभावशाली फ्रेमवर्क यहाँ हैं।

SimCLR

Google Research द्वारा प्रस्तुत SimCLR कॉन्ट्रास्टिव लर्निंग विचार की सबसे स्पष्ट इम्प्लीमेंटेशनों में से एक है।

बैच में हर इमेज के लिए, यह दो ऑगमेंटेड व्यू बनाता है और उन्हें सकारात्मक जोड़ी मानता है। बैच की बाकी हर इमेज नकारात्मक बन जाती है। मॉडल, जो एक CNN है और उसके बाद एक छोटा प्रोजेक्शन हेड, InfoNCE लॉस का उपयोग करते हुए सकारात्मक जोड़ियों को पास-पास मैप करना सीखता है।

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

MoCo

MoCo (Momentum Contrast), Meta AI Research से, को इसी समस्या को हल करने के लिए डिज़ाइन किया गया था।

बड़े बैच पर नकारात्मकों के लिए निर्भर रहने के बजाय, MoCo एक क्यू बनाए रखता है—पिछले बैचों से एन्कोडेड रिप्रेजेंटेशनों का रनिंग बफ़र। यह नकारात्मकों की संख्या को बैच आकार से अलग कर देता है, ताकि आप बहुत कम मेमोरी में भी ट्रेन कर सकें और फिर भी मॉडल को नकारात्मकों के बड़े पूल से रूबरू करा सकें।

यह एक मोमेंटम एनकोडर भी उपयोग करता है, जो मुख्य एनकोडर की धीरे-धीरे अपडेट होने वाली प्रति होती है, ताकि समय के साथ क्यू में मौजूद रिप्रेजेंटेशन लगातार बने रहें।

BYOL

BYOL (Bootstrap Your Own Latent) यहाँ उल्लेख के योग्य है, भले ही यह नकारात्मक जोड़ियों का उपयोग बिल्कुल नहीं करता।

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

BYOL कुछ हद तक कॉन्ट्रास्टिव लर्निंग की सीमा पर है, लेकिन एक बार जब आप मुख्य विधियों को समझ लेते हैं, तो यह अगला अच्छा कदम है।

कॉन्ट्रास्टिव लर्निंग बनाम सुपरवाइज्ड लर्निंग

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

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

कॉन्ट्रास्टिव लर्निंग डेटा की संरचना—समानता और भिन्नता—से अपना सुपरविजन खुद जनरेट करती है और बिना किसी लेबल के रिप्रेजेंटेशन सीखती है।

यहाँ उनका ��ुलना का अधिक दृश्यात्मक रूप देखें:

सुपरवाइज्ड लर्निंग की तुलना में कॉन्ट्रास्टिव लर्निंग

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

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

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

व्यवहार में कॉन्ट्रास्टिव लर्निंग (Python उदाहरण)

अब मैं एक न्यूनतम PyTorch इम्प्लीमेंटेशन दिखाता हूँ। नीचे का उदाहरण पहले चर्चा किए गए तीन मुख्य विचारों को कवर करता है: एक एम्बेडिंग मॉडल, कॉसाइन सिमिलैरिटी, और NT-Xent लॉस—SimCLR में उपयोग किया जाने वाला InfoNCE-आधारित लॉस।

एम्बेडिंग मॉडल

एनकोडर एक साधारण फीडफ़ॉर्वर्ड नेटवर्क है जो इनपुट वेक्टरों को कम-आयामी एम्बेडिंग स्पेस में मैप करता है।

import torch
import torch.nn as nn
import torch.nn.functional as F

class Encoder(nn.Module):
    def __init__(self, input_dim, embedding_dim):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Linear(128, embedding_dim)
        )

    def forward(self, x):
        return self.network(x)

व्यवहार में, आप इसे इमेज के लिए CNN या टेक्स्ट के लिए ट्रांसफॉर्मर से बदलेंगे। आर्किटेक्चर से ज्यादा महत्व इसके बाद क्या आता है, उसे है।

समानता की गणना

एक बार जब आपके पास दो एम्बेडिंग्स हों, तो आप कॉसाइन सिमिलैरिटी का उपयोग करके उनकी निकटता मापते हैं। पहले वेक्टरों को सामान्यीकृत करना समानता स्कोरों को -1 और 1 के बीच सीमित रखता है।

def cosine_similarity(z1, z2):
    z1 = F.normalize(z1, dim=-1)
    z2 = F.normalize(z2, dim=-1)
    return torch.matmul(z1, z2.T)

परिणाम एक मैट्रिक्स होता है, जहाँ प्रत्येक प्रविष्टि [i, j] बैच में एम्बेडिंग i और एम्बेडिंग j के बीच समानता दर्शाती है।

NT-Xent लॉस

NT-Xent (Normalized Temperature-scaled Cross Entropy) InfoNCE-आधारित लॉस है। प्रत्येक एंकर के लिए, यह उसक�� युग्मित व्यू को पॉज़िटिव और बैच की बाकी सभी उदाहरणों को नेगेटिव मानता है।

def nt_xent_loss(z1, z2, temperature=0.5):
    batch_size = z1.shape[0]

    z = torch.cat([z1, z2], dim=0)
    z = F.normalize(z, dim=-1)
    sim_matrix = torch.matmul(z, z.T) / temperature

    mask = torch.eye(2 * batch_size, dtype=torch.bool)
    sim_matrix = sim_matrix.masked_fill(mask, float("-inf"))

    labels = torch.arange(batch_size)
    labels = torch.cat([labels + batch_size, labels])

    return F.cross_entropy(sim_matrix, labels)

temperature पैरामीटर वितरण की शार्पनेस नियंत्रित करता है। कम मान मॉडल को यह तय करने में अधिक आत्मविश्वास देते हैं कि कौन-सी जोड़ी पॉज़िटिव है; अधिक मान कंट्रास्ट को नरम करते हैं।

एक साथ जोड़ना

encoder = Encoder(input_dim=64, embedding_dim=32)
optimizer = torch.optim.Adam(encoder.parameters(), lr=1e-3)

# Simulate a batch of positive pairs
x1 = torch.randn(32, 64)
x2 = torch.randn(32, 64)

# Training
optimizer.zero_grad()
z1, z2 = encoder(x1), encoder(x2)
loss = nt_xent_loss(z1, z2)
loss.backward()
optimizer.step()

print(f("Loss: {loss.item():.4f}"))

कॉन्ट्रास्टिव लूप आउटपुट

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

निष्कर्ष

कॉन्ट्रास्टिव लर्निंग एक सरल विचार है, लेकिन इसकी पहुँच बहुत दूर तक है।

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

क्षेत्र एनोटेशन-भारी पाइपलाइनों से दूर जा रहा है, और इसकी बड़ी वजह कॉन्ट्रास्टिव लर्निंग है। SimCLR, MoCo और CLIP जैसे एल्गोरिद्म वास्तविक प्रोडक्ट्स में पहुँचे हैं—जो बताता है कि यह दृष्टिकोण वास्तव में कितना कारगर है।

अगर आप और गहराई में जाना चाहते हैं, तो अगला अच्छा कदम किसी वास्तविक इम्प्लीमेंटेशन पर हाथ आजमाना है। इस लेख का PyTorch उदाहरण एक शुरुआती बिंदु है, लेकिन किसी वास्तविक इमेज डेटासेट—चाहे छोटा ही क्यों न हो—पर SimCLR चलाना आपको किसी भी व्याख्या से अधिक सिखाएगा।

और अगर आपको उन्नत मशीन लर्निंग विषयों के लिए सर्वोत्तम संसाधन चाहिए, तो हमारे Machine Learning Scientist in Python ट्रैक में नामांकन करें।