पायथन + केरस + LSTM: आधे घंटे में एक पाठ अनुवादक करें

हाय, हैब्र।

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



जो लोग इस काम में रुचि रखते हैं, उनके लिए विवरण कटौती के अधीन है।

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

डेटा संग्रह

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

Hi. Hallo! Hi. Grüß Gott! Run! Lauf! Wow! Potzdonner! Wow! Donnerwetter! Fire! Feuer! Help! Hilfe! Help! Zu Hülf! Stop! Stopp! Wait! Warte! Go on. Mach weiter. Hello! Hallo! I ran. Ich rannte. I see. Ich verstehe. ... 

फ़ाइल में 192 हजार लाइनें हैं और इसका आकार 13 एमबी है। हम पाठ को मेमोरी में लोड करते हैं और डेटा को अंग्रेजी और जर्मन शब्दों के लिए दो ब्लॉक में तोड़ते हैं।

 def read_text(filename): with open(filename, mode='rt', encoding='utf-8') as file: text = file.read() sents = text.strip().split('\n') return [i.split('\t') for i in sents] data = read_text("deutch.txt") deu_eng = np.array(data) deu_eng = deu_eng[:30000,:] print("Dictionary size:", deu_eng.shape) # Remove punctuation deu_eng[:,0] = [s.translate(str.maketrans('', '', string.punctuation)) for s in deu_eng[:,0]] deu_eng[:,1] = [s.translate(str.maketrans('', '', string.punctuation)) for s in deu_eng[:,1]] # convert text to lowercase for i in range(len(deu_eng)): deu_eng[i,0] = deu_eng[i,0].lower() deu_eng[i,1] = deu_eng[i,1].lower() 

हमने विराम चिह्न को सभी शब्दों में बदल दिया और विराम चिह्नों को हटा दिया।

अगला कदम तंत्रिका नेटवर्क के लिए डेटा तैयार करना है। नेटवर्क को पता नहीं है कि शब्द क्या हैं, और विशेष रूप से संख्याओं के साथ काम करता है। सौभाग्य से हमारे लिए, keras के पास पहले से ही बनाया गया टोकनराइज़र वर्ग है, जो शब्दों को डिजिटल कोड के साथ बदल देता है।

इसका उपयोग बस एक उदाहरण के साथ सचित्र है:

 from keras.preprocessing.text import Tokenizer from keras.preprocessing.sequence import pad_sequences s = "To be or not to be" eng_tokenizer = Tokenizer() eng_tokenizer.fit_on_texts([s]) seq = eng_tokenizer.texts_to_sequences([s]) seq = pad_sequences(seq, maxlen=8, padding='post') print(seq) 

वाक्यांश "होने या न होने" को सरणी [1 2 3 4 1 2 0 0] से बदल दिया जाएगा, जहां अनुमान लगाना मुश्किल नहीं है, 1 = से, 2 = होना, 3 = या, 4 = नहीं। हम इन आंकड़ों को पहले ही तंत्रिका नेटवर्क में जमा कर सकते हैं।

तंत्रिका नेटवर्क प्रशिक्षण

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

 # split data into train and test set train, test = train_test_split(deu_eng, test_size=0.2, random_state=12) # prepare training data trainX = encode_sequences(eng_tokenizer, eng_length, train[:, 0]) trainY = encode_sequences(deu_tokenizer, deu_length, train[:, 1]) # prepare validation data testX = encode_sequences(eng_tokenizer, eng_length, test[:, 0]) testY = encode_sequences(deu_tokenizer, deu_length, test[:, 1]) 

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

 def make_model(in_vocab, out_vocab, in_timesteps, out_timesteps, n): model = Sequential() model.add(Embedding(in_vocab, n, input_length=in_timesteps, mask_zero=True)) model.add(LSTM(n)) model.add(Dropout(0.3)) model.add(RepeatVector(out_timesteps)) model.add(LSTM(n, return_sequences=True)) model.add(Dropout(0.3)) model.add(Dense(out_vocab, activation='softmax')) model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss='sparse_categorical_crossentropy') return model eng_vocab_size = len(eng_tokenizer.word_index) + 1 deu_vocab_size = len(deu_tokenizer.word_index) + 1 eng_length, deu_length = 8, 8 model = make_model(eng_vocab_size, deu_vocab_size, eng_length, deu_length, 512) num_epochs = 40 model.fit(trainX, trainY.reshape(trainY.shape[0], trainY.shape[1], 1), epochs=num_epochs, batch_size=512, validation_split=0.2, callbacks=None, verbose=1) model.save('en-de-model.h5') 

प्रशिक्षण ही कुछ इस तरह दिखता है:



प्रक्रिया, जैसा कि आप देख सकते हैं, तेज नहीं है, और कोर i7 + GeForce 1060 पर 30 हजार लाइनों के सेट के लिए लगभग आधे घंटे लगते हैं। प्रशिक्षण के अंत में (इसे केवल एक बार किए जाने की आवश्यकता है), मॉडल को एक फ़ाइल में सहेजा जाता है, और फिर इसका पुन: उपयोग किया जा सकता है।

अनुवाद प्राप्त करने के लिए, हम predict_classes फ़ंक्शन का उपयोग करते हैं, जिसका इनपुट हम कुछ सरल वाक्यांश प्रस्तुत करते हैं। Get_word फ़ंक्शन का उपयोग शब्दों को संख्याओं में बदलने के लिए किया जाता है।

 model = load_model('en-de-model.h5') def get_word(n, tokenizer): if n == 0: return "" for word, index in tokenizer.word_index.items(): if index == n: return word return "" phrs_enc = encode_sequences(eng_tokenizer, eng_length, ["the weather is nice today", "my name is tom", "how old are you", "where is the nearest shop"]) preds = model.predict_classes(phrs_enc) print("Preds:", preds.shape) print(preds[0]) print(get_word(preds[0][0], deu_tokenizer), get_word(preds[0][1], deu_tokenizer), get_word(preds[0][2], deu_tokenizer), get_word(preds[0][3], deu_tokenizer)) print(preds[1]) print(get_word(preds[1][0], deu_tokenizer), get_word(preds[1][1], deu_tokenizer), get_word(preds[1][2], deu_tokenizer), get_word(preds[1][3], deu_tokenizer)) print(preds[2]) print(get_word(preds[2][0], deu_tokenizer), get_word(preds[2][1], deu_tokenizer), get_word(preds[2][2], deu_tokenizer), get_word(preds[2][3], deu_tokenizer)) print(preds[3]) print(get_word(preds[3][0], deu_tokenizer), get_word(preds[3][1], deu_tokenizer), get_word(preds[3][2], deu_tokenizer), get_word(preds[3][3], deu_tokenizer)) 

परिणाम

अब, वास्तव में, सबसे उत्सुक चीज परिणाम है। यह देखना दिलचस्प है कि तंत्रिका नेटवर्क कैसे सीखता है और अंग्रेजी और जर्मन वाक्यांशों के बीच के पत्राचार को "याद" करता है। मैंने विशेष रूप से 2 वाक्यांशों को आसान और 2 कठिन अंतर को देखने के लिए लिया।

5 मिनट का प्रशिक्षण

"आज मौसम अच्छा है" - "दास ist टॉम"
"मेरा नाम टॉम है" - "वाई फर टॉम टॉम"
"आपकी उम्र कितनी है" - "wie geht ist es"
"सबसे नज़दीकी दुकान कहाँ है" - "wo ist der"

जैसा कि आप देख सकते हैं, अब तक कुछ "हिट" हैं। वाक्यांश "आप कितने साल के हैं" का एक टुकड़ा "कैसे आप हैं" वाक्यांश के साथ तंत्रिका नेटवर्क को भ्रमित किया और अनुवाद "wie geht ist es" (आप कैसे हैं?) का उत्पादन किया। वाक्यांश में "कहां है ..." तंत्रिका नेटवर्क ने केवल क्रिया की पहचान की है, जहां अनुवाद "wo ist der" (जहां यह है?) का उत्पादन किया, जो, सिद्धांत रूप में, अर्थ के बिना नहीं है। सामान्य तौर पर, यह समूह A1 में जर्मन नवागंतुक में भी अनुवाद करता है;)

10 मिनट का प्रशिक्षण

"आज मौसम अच्छा है" - "दास हैस बेरेट"
"मेरा नाम टॉम है" - "mei hee hei tome tom"
"आप कितने साल के हैं" - "wie alt sind sie"
"सबसे नज़दीकी दुकान कहाँ है" - "wo ist paris"

कुछ प्रगति दिखाई दे रही है। पहला वाक्यांश पूरी तरह से जगह से बाहर है। दूसरे वाक्यांश में, तंत्रिका नेटवर्क "सीखा" क्रिया hei (en (कहा जाता है), लेकिन "mein heiße heiße टॉम" अभी भी गलत है, हालांकि आप पहले से ही अर्थ का अनुमान लगा सकते हैं। तीसरा वाक्यांश पहले से ही सही है। चौथे में, पहला भाग "wo ist" है, लेकिन निकटतम दुकान किसी कारण से पेरिस द्वारा प्रतिस्थापित की गई थी।

30 मिनट का प्रशिक्षण

"आज मौसम अच्छा है" - "दास इस् ट इज़ गुदा"
"मेरा नाम टॉम है" - "टॉम" ist mein नाम "
"आप कितने साल के हैं" - "wie alt sind sie"
"सबसे नज़दीकी दुकान कहाँ है" - "wo ist der"

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

निष्कर्ष

जैसा कि आप देख सकते हैं, सिद्धांत रूप में, यह काम करता है। मैं इस तरह की गति के साथ एक नई भाषा को याद करना चाहूंगा :) बेशक, परिणाम अभी तक सही नहीं है, लेकिन 190 हजार लाइनों के पूर्ण सेट पर प्रशिक्षण में एक घंटे से अधिक समय लगेगा।

जो लोग अपने दम पर प्रयोग करना चाहते हैं, उनके लिए स्रोत कोड स्पॉइलर है। कार्यक्रम सैद्धांतिक रूप से भाषाओं के किसी भी जोड़े का उपयोग कर सकता है, न केवल अंग्रेजी और जर्मन (फ़ाइल UTF-8 एन्कोडिंग में होनी चाहिए)। अनुवाद की गुणवत्ता का मुद्दा भी खुला है, परीक्षण करने के लिए कुछ है।


शब्दकोश ही लेख के साथ संलग्न करने के लिए बहुत बड़ा है, लिंक टिप्पणियों में है।

हमेशा की तरह, सभी सफल प्रयोग।