👒 ☂️ 🙅🏻 BERT 104 भाषाओं के लिए एक अत्याधुनिक भाषा मॉडल है। ट्यूटोरियल BERT को स्थानीय रूप से और Google Colab पर लॉन्च करने के लिए 😝 👨🏻‍💼 👩🏽‍🤝‍👨🏾

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

Google ने पूर्व-प्रशिक्षित BERT मॉडल पोस्ट किए हैं, लेकिन जैसा कि आमतौर पर मशीन लर्निंग के मामले में होता है, वे प्रलेखन की कमी से ग्रस्त हैं। इसलिए, इस ट्यूटोरियल में हम सीखेंगे कि स्थानीय कंप्यूटर पर BERT न्यूरल नेटवर्क को कैसे चलाना है, साथ ही Google Colab पर मुफ्त सर्वर GPU पर भी।

ऐसा क्यों जरूरी है

एक तंत्रिका नेटवर्क के इनपुट को टेक्स्ट सबमिट करने के लिए, आपको किसी तरह इसे संख्याओं के रूप में प्रस्तुत करने की आवश्यकता है। इस पत्र को पत्र द्वारा करना आसान है, प्रत्येक तंत्रिका नेटवर्क प्रवेश द्वार पर एक पत्र लागू करना। फिर प्रत्येक अक्षर को 0 से 32 की संख्या के साथ कूटबद्ध किया जाएगा (साथ ही विराम चिह्नों के लिए कुछ प्रकार का मार्जिन)। यह तथाकथित चरित्र-स्तर है।

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

लेकिन केवल एक प्राकृतिक भाषा में, "कुत्ते" शब्द के साथ, बहुत सारे संघ एक बार में एक व्यक्ति में पॉप अप करते हैं: "शराबी", "बुराई", "एक व्यक्ति का दोस्त"। क्या तंत्रिका नेटवर्क के लिए प्रस्तुति में हमारी सोच की इस विशेषता को किसी तरह से बदलना संभव है? यह आप कर सकते हैं पता चला है। ऐसा करने के लिए, यह शब्द संख्याओं को फिर से लिखने के लिए पर्याप्त है ताकि अर्थ में पास होने वाले शब्द एक साथ खड़े हों। उदाहरण के लिए, इसे "कुत्ते" के लिए नंबर 1678, और शब्द "शराबी" के लिए 1680 नंबर के लिए बताया जाए। और "चायदानी" शब्द के लिए संख्या 9000 है। जैसा कि आप देख सकते हैं, संख्या 1678 और 1680 संख्या 9000 के अलावा एक दूसरे के बहुत करीब हैं।

व्यवहार में, प्रत्येक शब्द को एक संख्या नहीं, बल्कि कई - 32 संख्याओं का एक सदिश, कहते हैं। और दूरी को उन बिंदुओं के बीच की दूरी के रूप में मापा जाता है जो ये वैक्टर संबंधित आयाम के स्थान पर इंगित करते हैं (एक वेक्टर 32 अंकों के लिए लंबे समय तक, यह 32 आयामों के साथ, या 32 अक्षों के साथ एक स्थान है)। यह आपको एक शब्द की तुलना एक साथ कई शब्दों के साथ करने की अनुमति देता है जो अर्थ में करीब हैं (जिस पर भरोसा करने के लिए अक्ष पर निर्भर करता है)। इसके अलावा, अंकगणित संचालन वैक्टर के साथ किया जा सकता है। एक क्लासिक उदाहरण: यदि आप वेक्टर "मैन" को वेक्टर से घटाते हैं, तो "किंग" शब्द को दर्शाते हैं और "महिला" शब्द के लिए वेक्टर जोड़ते हैं, तो आपको एक निश्चित परिणाम वेक्टर मिलता है। और वह चमत्कारिक रूप से "रानी" शब्द के अनुरूप होगा। और वास्तव में, "राजा पुरुष + स्त्री = रानी है।" जादू! और यह एक सार उदाहरण नहीं है, लेकिन यह वास्तव में होता है । यह देखते हुए कि तंत्रिका नेटवर्क अपने इनपुट पर गणितीय परिवर्तनों के लिए अच्छी तरह से अनुकूलित हैं, यह स्पष्ट रूप से इस पद्धति की इतनी उच्च दक्षता प्रदान करता है।

इस दृष्टिकोण को एंबेडिंग कहा जाता है। सभी मशीन लर्निंग पैकेज (TensorFlow, PyTorch) तंत्रिका नेटवर्क की पहली परत को एंबेडिंग लेयर की एक विशेष परत लगाने की अनुमति देते हैं, जो यह स्वचालित रूप से करता है। यही है, तंत्रिका नेटवर्क के इनपुट पर हम शब्दकोश में सामान्य शब्द संख्या प्रस्तुत करते हैं, और एम्बेडिंग लेयर, स्व-शिक्षण, प्रत्येक शब्द को निर्दिष्ट लंबाई के वेक्टर में अनुवाद करते हैं, कहते हैं, 32 नंबर।

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

वैक्टर के रूप में शब्दों का प्रतिनिधित्व करने के कई तरीके हैं, वे धीरे-धीरे विकसित हुए: शब्द 2vec, GloVe, एल्मो।

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

Google से BERT, OpenAI (यूनिडायरेक्शनल, आदि के बजाय द्विदिश) से एक उन्नत GPA नेटवर्क है, जो ट्रांसफार्मर वास्तुकला पर भी आधारित है। फिलहाल, बीईआरटी लगभग सभी लोकप्रिय एनएलपी बेंचमार्क पर अत्याधुनिक है।

उन्होंने यह कैसे किया

BERT के पीछे का विचार बहुत सरल है: चलो वाक्यांशों के साथ तंत्रिका नेटवर्क में फ़ीड करते हैं जिसमें हम 15% शब्दों को [MASK] से बदल देते हैं और तंत्रिका नेटवर्क को इन मुखौटे वाले शब्दों की भविष्यवाणी करने के लिए प्रशिक्षित करते हैं।

उदाहरण के लिए, यदि हम वाक्यांश "मैं आया [MASK] और खरीदा [MASK]" तंत्रिका नेटवर्क के इनपुट के लिए, इसे आउटपुट में "स्टोर" और "दूध" शब्द दिखाना चाहिए। यह आधिकारिक बीईआरटी पृष्ठ से एक सरल उदाहरण है, लंबे वाक्यों पर, संभावित विकल्पों की सीमा छोटी हो जाती है, और तंत्रिका नेटवर्क की प्रतिक्रिया अस्पष्ट है।

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

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

इस प्रकार विकिपीडिया से ग्रंथों के शरीर पर तंत्रिका नेटवर्क को प्रशिक्षित करने और पुस्तक संग्रह बुककॉर्पस को 4 दिनों के लिए 16 टीपीयू में रखने के बाद, हमें बीईआरटी मिला।

स्थापना और सेटअप

नोट : इस खंड में हम स्थानीय कंप्यूटर पर BERT के साथ लॉन्च करेंगे और खेलेंगे। एक स्थानीय GPU पर इस तंत्रिका नेटवर्क को चलाने के लिए, आपको 4 GB वीडियो मेमोरी या उच्चतर के साथ NVidia GTX 970 की आवश्यकता होगी। यदि आप किसी ब्राउज़र में BERT चलाना चाहते हैं (इसके लिए आपको अपने कंप्यूटर पर भी GPU की आवश्यकता नहीं है), तो Google Colab सेक्शन में जाएँ।

Https://www.tensorflow.org/install के निर्देशों का पालन करते हुए, पहले TensorFlow स्थापित करें । GPU का समर्थन करने के लिए, आपको पहले CUDA टूलकिट 9.0, फिर cuDNN SDK 7.2, और केवल तब GPU समर्थन के साथ TensorFlow स्थापित करना होगा:

pip install tensorflow-gpu

मूल रूप से, यह BERT को चलाने के लिए पर्याप्त है। लेकिन इस तरह कोई निर्देश नहीं है, आप इसे रन_क्लासीफोरोफ़ॉर्म फ़ाइल (मशीन लर्निंग में सामान्य स्थिति तब होती है जब आपको दस्तावेज़ों के बजाय स्रोतों में जाना होता है) के स्रोतों को छाँटकर इसे स्वयं बना सकते हैं। लेकिन हम इसे आसान करेंगे और केरस बीईआरटी शेल का उपयोग करेंगे (यह नेटवर्क को बाद में ठीक करने के लिए भी उपयोगी हो सकता है, क्योंकि यह एक सुविधाजनक केरस इंटरफ़ेस प्रदान करता है)।

ऐसा करने के लिए, केरेस को स्वयं स्थापित करें:

 pip install keras

और केरस BERT के बाद:

 pip install keras-bert

हमें मूल github BERT से भी tokenization.py फ़ाइल की आवश्यकता होगी। या तो रॉ बटन पर क्लिक करें और इसे भविष्य की स्क्रिप्ट के साथ फ़ोल्डर में सहेजें, या संपूर्ण रिपॉजिटरी डाउनलोड करें और फ़ाइल को वहां से ले जाएं, या इस कोड https://github.com/blade1780/bert के साथ रिपॉजिटरी से एक कॉपी लें।

अब पूर्व प्रशिक्षित तंत्रिका नेटवर्क को डाउनलोड करने का समय आ गया है। BERT के लिए कई विकल्प हैं, जो सभी आधिकारिक github.com/google-research/bert पृष्ठ पर सूचीबद्ध हैं। हम 104 भाषाओं के लिए सार्वभौमिक बहुभाषी "बीईआरटी-बेस, बहुभाषी कैसड" लेंगे। बहु_cased_L-12_H-768_A-12.zip फ़ाइल (632 एमबी) डाउनलोड करें और इसे भविष्य की स्क्रिप्ट के साथ फ़ोल्डर में अनज़िप करें।

सब कुछ तैयार है, BERT.py फ़ाइल बनाएं, फिर थोड़ा कोड होगा।

आवश्यक पुस्तकालयों और निर्धारित रास्तों को आयात करें

 # coding: utf-8 import sys import codecs import numpy as np from keras_bert import load_trained_model_from_checkpoint import tokenization # ,     BERT folder = 'multi_cased_L-12_H-768_A-12' config_path = folder+'/bert_config.json' checkpoint_path = folder+'/bert_model.ckpt' vocab_path = folder+'/vocab.txt'

चूँकि हमें टेक्स्ट की साधारण लाइनों को टोकन के एक विशेष प्रारूप में अनुवाद करना होगा, इसलिए हम इसके लिए एक विशेष ऑब्जेक्ट बनाएंगे। Do_lower_case = False पर ध्यान दें, क्योंकि हम कैसर्ड BERT मॉडल का उपयोग कर रहे हैं, जो कि संवेदनशील है।

 tokenizer = tokenization.FullTokenizer(vocab_file=vocab_path, do_lower_case=False)

लोड हो रहा है मॉडल

 model = load_trained_model_from_checkpoint(config_path, checkpoint_path, training=True) model.summary()

BERT दो मोड में काम कर सकता है: वाक्यांश में छूटे हुए शब्दों का अनुमान लगाना, या यह अनुमान लगाना कि क्या दूसरा वाक्यांश पहले के बाद तार्किक है। हम दोनों विकल्प करेंगे।

पहले मोड के लिए, आपको प्रारूप में एक वाक्यांश जमा करना होगा:

 [CLS]    [MASK]   [MASK]. [SEP]

तंत्रिका नेटवर्क को मास्क के स्थान पर भरे हुए शब्दों के साथ एक पूरा वाक्य वापस करना चाहिए: "मैं दुकान में आया और दूध खरीदा।"

दूसरे मोड के लिए, एक विभाजक द्वारा अलग किए गए दोनों वाक्यांशों को तंत्रिका नेटवर्क के इनपुट को खिलाया जाना चाहिए:

 [CLS]    . [SEP]   . [SEP]

तंत्रिका नेटवर्क को जवाब देना चाहिए कि क्या दूसरा वाक्यांश पहले की तार्किक निरंतरता है। या यह एक यादृच्छिक वाक्यांश है जिसका पहले से कोई लेना-देना नहीं है।

काम करने के लिए BERT के लिए, आपको तीन वैक्टर तैयार करने होंगे, जिनमें से प्रत्येक की लंबाई 512 नंबर होगी: token_input, seg_input और mask_input।

टोकन_इनपुट टोकन का उपयोग करके हमारे स्रोत कोड को टोकन में अनुवादित किया जाएगा। शब्दकोश में अनुक्रमित के रूप में वाक्यांश इस वेक्टर की शुरुआत में होगा, और बाकी शून्य से भर जाएगा।

Mask_input में, हमें उन सभी पदों के लिए 1 रखना चाहिए जहां [MASK] मुखौटा है, और बाकी को शून्य से भरें।

Seg_input में, हमें पहला वाक्यांश (आरंभिक सीएलएस और एसईपी विभाजक सहित) को 0 के रूप में निरूपित करना चाहिए, दूसरा वाक्यांश (अंतिम एसईपी सहित) 1 के रूप में है, और शेष को जीरो के साथ वेक्टर के अंत में भरें।

BERT पूरे शब्दों के शब्दकोश का उपयोग नहीं करता है, बल्कि सबसे आम शब्दांशों का उपयोग करता है। हालांकि इसमें पूरे शब्द भी हैं। आप डाउनलोड किए गए न्यूरल नेटवर्क में vocab.txt फाइल को खोल सकते हैं और देख सकते हैं कि न्यूरल नेटवर्क अपने इनपुट में किन शब्दों का उपयोग करता है। फ्रांस जैसे पूरे शब्द हैं। लेकिन अधिकांश रूसी शब्दों को शब्दांशों में विभाजित करने की आवश्यकता है। तो, "आया" शब्द को "साथ" और "## गया" में तोड़ दिया जाना चाहिए। BERT द्वारा आवश्यक प्रारूप में पाठ की नियमित लाइनों को परिवर्तित करने में मदद करने के लिए, हम tokenization.py मॉड्यूल का उपयोग करते हैं।

मोड 1: वाक्यांश में शब्द [MASK] द्वारा बंद शब्दों की भविष्यवाणी

इनपुट वाक्यांश जो तंत्रिका नेटवर्क के इनपुट को खिलाया जाता है

 sentence = '   [MASK]   [MASK].' print(sentence)

इसे टोकन में बदलें। समस्या यह है कि टोकन सेवा के निशान [CLS] और [MASK] की प्रक्रिया नहीं कर सकता है, हालांकि शब्दकोष में वो शब्द है। इसलिए, हमें अपने लाइन को मैन्युअल रूप से [MASK] मार्करों से तोड़ना होगा और टोकन से इसका उपयोग करके इसे BERT टोकन में बदलने के लिए सादे पाठ के टुकड़े निकालने होंगे। शुरुआत में [CLS] और वाक्यांश के अंत में [SEP] भी जोड़ें।

 sentence = sentence.replace(' [MASK] ','[MASK]'); sentence = sentence.replace('[MASK] ','[MASK]'); sentence = sentence.replace(' [MASK]','[MASK]') #    sentence = sentence.split('[MASK]') #     tokens = ['[CLS]'] #      [CLS] #        tokenizer.tokenize(),    [MASK] for i in range(len(sentence)): if i == 0: tokens = tokens + tokenizer.tokenize(sentence[i]) else: tokens = tokens + ['[MASK]'] + tokenizer.tokenize(sentence[i]) tokens = tokens + ['[SEP]'] #      [SEP]

टोकन में अब टोकन हैं जो शब्दकोश में अनुक्रमित में परिवर्तित होने की गारंटी है। चलो इसे करते हैं:

 token_input = tokenizer.convert_tokens_to_ids(tokens)

अब टोकन_इनपुट में संख्याओं की एक श्रृंखला होती है (शब्द संख्या। शब्दकोष में) जो तंत्रिका नेटवर्क के इनपुट को खिलाया जाना चाहिए। यह केवल 512 तत्वों की लंबाई तक इस वेक्टर का विस्तार करने के लिए बनी हुई है। अजगर का निर्माण [0] * लंबाई लंबाई की एक लंबाई बनाता है, शून्य से भर जाता है। बस इसे हमारे टोकन में जोड़ें, जो अजगर में दो सरणियों को एक में जोड़ता है।

 token_input = token_input + [0] * (512 - len(token_input))

अब हर जगह 1 लंबाई में एक मुखौटा मुखौटा 512 बनाएं, जहां 103 नंबर टोकन में दिखाई देता है (जो कि शब्दकोष में मार्कर [MASK] से मेल खाता है), और बाकी को 0 से भरना:

 mask_input = [0]*512 for i in range(len(mask_input)): if token_input[i] == 103: mask_input[i] = 1

ऑपरेशन के पहले BERT मोड के लिए, seg_input पूरी तरह से शून्य से भरा होना चाहिए:

 seg_input = [0]*512

अंतिम चरण, आपको अजगर सरणियों को आकार (1,512) के साथ अफीम सरणियों में बदलने की आवश्यकता है, जिसके लिए हम उन्हें एक उप-श्रेणी में डालते हैं:

 token_input = np.asarray([token_input]) mask_input = np.asarray([mask_input]) seg_input = np.asarray([seg_input])

ठीक है, किया। अब तंत्रिका नेटवर्क की भविष्यवाणी चलाएं!

 predicts = model.predict([token_input, seg_input, mask_input])[0] predicts = np.argmax(predicts, axis=-1) predicts = predicts[0][:len(tokens)] #   ,    ,

अब परिणाम को टोकन से रिक्त स्थान द्वारा अलग किए गए स्ट्रिंग में स्वरूपित करें

 out = [] #   out     [MASK],    1  mask_input for i in range(len(mask_input[0])): if mask_input[0][i] == 1: # [0][i], ..   batch   (1,512),       out.append(predicts[i]) out = tokenizer.convert_ids_to_tokens(out) #     out = ' '.join(out) #       out = tokenization.printable_text(out) #    out = out.replace(' ##','') #   : " ##" -> ""

और परिणाम का उत्पादन करें:

 print('Result:', out)

हमारे उदाहरण में, वाक्यांश के लिए "मैं [MASK] आया और [MASK] को खरीदा।" तंत्रिका नेटवर्क ने "घर" और "यह" परिणाम उत्पन्न किया: "मैं घर आया और इसे खरीदा।" वैसे, पहली बार इतना बुरा नहीं है। घर खरीदना निश्चित रूप से दूध से बेहतर है)।

अन्य उदाहरण (मैं असफल लोगों को नहीं देता, सफल लोगों की तुलना में बहुत अधिक हैं। ज्यादातर मामलों में, नेटवर्क एक खाली उत्तर देता है:

पृथ्वी सूर्य से तीसरी [MASK] है
परिणाम: स्टार

मक्खन के साथ सबसे अच्छा सैंडविच [मास]
परिणाम: मीट

[MASK] दोपहर के भोजन के बाद सोने के लिए माना जाता है
परिणाम: इसमें से

[MASK] से दूर हो जाओ
परिणाम: ## ओह - यह किसी प्रकार का अभिशाप है? )

[MASK] दरवाजे से
परिणाम: देखें

[MASK] के साथ हथौड़ा और नाखून कैबिनेट बना सकते हैं
परिणाम: मदद

और अगर कल नहीं है? आज, उदाहरण के लिए, यह [MASK] नहीं है!
परिणाम: होगा

[MASK] की अनदेखी करके आप कैसे थक सकते हैं?
परिणाम: उसे

हर रोज़ तर्क है, महिला तर्क है, लेकिन पुरुष के बारे में कुछ भी नहीं पता है [MASK]
परिणाम: दर्शन

महिलाओं में, तीस वर्ष की आयु तक, राजकुमार की एक छवि बनती है, जो किसी भी [MASK] पर फिट बैठती है।
परिणाम: आदमी

बहुमत के मत से, स्नो व्हाइट और सात ड्वार्फ ने एक वोट के साथ [MASK] के लिए मतदान किया।
परिणाम: गाँव - पहला अक्षर सही है

अपने थकाऊपन को 10-बिंदु पैमाने पर आंकें: [MASK] अंक
परिणाम: 10

आपका [MASK], [MASK] और [MASK]!
परिणाम: मुझे प्यार करो - नहीं, BERT, मुझे इसका मतलब बिल्कुल नहीं था

आप अंग्रेजी वाक्यांश (और 104 भाषाओं में कोई भी, जिनमें से एक सूची यहां है ) दर्ज कर सकते हैं

[मास] पर जाना चाहिए!
परिणाम: I

मोड 2: दो वाक्यांशों की स्थिरता की जाँच करना

हम दो लगातार वाक्यांश सेट करते हैं जो तंत्रिका नेटवर्क के इनपुट को खिलाया जाएगा

 sentence_1 = '   .' sentence_2 = '  .' print(sentence_1, '->', sentence_2)

हम टोकन का उपयोग कर सादे पाठ को टोकन में परिवर्तित करते हुए [CLS] वाक्यांश_1 [SEP] वाक्यांश_2 [SEP] में टोकन बनाएंगे:

 tokens_sen_1 = tokenizer.tokenize(sentence_1) tokens_sen_2 = tokenizer.tokenize(sentence_2) tokens = ['[CLS]'] + tokens_sen_1 + ['[SEP]'] + tokens_sen_2 + ['[SEP]']

हम स्ट्रिंग टोकन को संख्यात्मक सूचक में परिवर्तित करते हैं (शब्द संख्या। शब्दकोष में) और वेक्टर को 512 तक विस्तारित करें:

 token_input = tokenizer.convert_tokens_to_ids(tokens) token_input = token_input + [0] * (512 - len(token_input))

इस मामले में मुखौटा शब्द पूरी तरह से शून्य से भरा है

 mask_input = [0] * 512

लेकिन प्रस्ताव मुखौटा को दूसरे वाक्यांश (अंतिम एसईपी सहित) के तहत इकाइयों के साथ भरा जाना चाहिए, और शून्य के साथ बाकी सब कुछ:

 seg_input = [0]*512 len_1 = len(tokens_sen_1) + 2 #   , +2 -   CLS   SEP for i in range(len(tokens_sen_2)+1): # +1, ..   SEP seg_input[len_1 + i] = 1 #   ,   SEP,  #   numpy   (1,) -> (1,512) token_input = np.asarray([token_input]) mask_input = np.asarray([mask_input]) seg_input = np.asarray([seg_input])

हम तंत्रिका नेटवर्क के माध्यम से वाक्यांशों को पास करते हैं (इस समय परिणाम [1] में है, और [0] में नहीं है, क्योंकि यह ऊपर था)

 predicts = model.predict([token_input, seg_input, mask_input])[1]

और हम इस संभावना को प्राप्त करते हैं कि दूसरा वाक्यांश एक सामान्य है, और शब्दों का एक यादृच्छिक सेट नहीं है

 print('Sentence is okey:', int(round(predicts[0][0]*100)), '%')

दो वाक्यांशों में:

मैं स्टोर में आया। -> और दूध खरीदा।

तंत्रिका नेटवर्क प्रतिक्रिया:

वाक्य ठीक है: 99%

और अगर दूसरा वाक्यांश "क्रूसियन आकाश प्लूटो" है, तो इसका उत्तर होगा:

वाक्य ठीक है: 4%

गूगल कोलाब

Google 12 जीबी की वीडियो मेमोरी के साथ एक मुफ्त टेस्ला K80 सर्वर GPU प्रदान करता है (TPU अब उपलब्ध हैं, लेकिन उनका कॉन्फ़िगरेशन थोड़ा अधिक जटिल है)। कोलाब के लिए सभी कोड ज्यूपिटर नोटबुक के रूप में डिज़ाइन किए जाने चाहिए। ब्राउज़र में BERT लॉन्च करने के लिए, बस लिंक खोलें

http://colab.research.google.com/github/blade1780/bert/blob/master/BERT.ipynb

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

अगर कुछ गलत हुआ है ...

सुनिश्चित करें कि GPU और पायथन 3 को रनटाइम में चुना गया है -> रनटाइम प्रकार मेनू बदलें

यदि कनेक्ट बटन सक्रिय नहीं है, तो कनेक्टेड बनने के लिए इसे क्लिक करें।

अब इनपुट लाइनों वाक्य , वाक्य_1 और pun_2 को बदलें, और केवल वर्तमान सेल शुरू करने के लिए बाईं ओर प्ले आइकन पर क्लिक करें। संपूर्ण नोटबुक चलाना अब आवश्यक नहीं है।

आप स्मार्टफोन से भी Google Colab पर BERT चला सकते हैं, लेकिन अगर यह नहीं खुला, तो आपको अपनी ब्राउज़र सेटिंग्स में पूर्ण संस्करण चेकबॉक्स को सक्षम करना पड़ सकता है।

आगे क्या है?

किसी विशेष कार्य के लिए बीईआरटी को प्रशिक्षित करने के लिए, आपको इसके ऊपर एक साधारण फीड फॉरवर्ड नेटवर्क की एक या दो परतें जोड़ने की जरूरत है, और केवल इसे मुख्य बीईआरटी नेटवर्क को छूने के बिना प्रशिक्षित करें। यह या तो नंगे TensorFlow पर या केरस BERT शेल के माध्यम से किया जा सकता है। किसी विशिष्ट डोमेन के लिए इस तरह का अतिरिक्त प्रशिक्षण बहुत जल्दी होता है और पूरी तरह से कनवल्शन नेटवर्क में फाइन ट्यूनिंग के समान है। तो, एसक्यूएडी कार्य के लिए, आप केवल 30 मिनट में एक टीपीयू पर एक तंत्रिका नेटवर्क को प्रशिक्षित कर सकते हैं (बीईटीटी के प्रशिक्षण के लिए 16 टीपीयू पर 4 दिनों की तुलना में)।

ऐसा करने के लिए, आपको यह अध्ययन करना होगा कि BERT में अंतिम परतों का प्रतिनिधित्व कैसे किया जाता है, साथ ही साथ एक उपयुक्त डेटासेट भी है। आधिकारिक बीईआरटी पेज https://github.com/google-research/bert पर विभिन्न कार्यों के लिए कई उदाहरण हैं, साथ ही क्लाउड टीपीयू पर फिर से शुरू करने के निर्देश भी हैं। और बाकी सभी चीजों को run_classifier.py और extract_features.py में स्रोत में देखना होगा ।

पुनश्च

यहां प्रस्तुत Google Colab के कोड और जुपिटर नोटबुक को रिपॉजिटरी में होस्ट किया गया है ।

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

BERT 104 भाषाओं के लिए एक अत्याधुनिक भाषा मॉडल है। ट्यूटोरियल BERT को स्थानीय रूप से और Google Colab पर लॉन्च करने के लिए