🏔️ 🤲 🚴🏿 भाग्य तंत्रिका नेटवर्क पर बता रहा है: क्या लेखक ने खुद पोस्ट पर टिप्पणियों में उल्लेख किया है 🍠 👩🏿‍🤝‍👨🏽 👩🏼‍🍳

मैं एक छोटी सी परियोजना के बारे में एक कहानी साझा करूँगा: बिना लेखक के उत्तरों को कैसे पता चलेगा कि पोस्ट का लेखक कौन है।

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

मेरा प्रारंभिक डेटा निम्नानुसार था: एक डेटाबेस जिसमें 2.5M मीडिया सामग्री और उन पर 39.5M टिप्पणियां थीं। 1M पदों के लिए, एक तरह से या किसी अन्य, सामग्री के लेखक को ज्ञात था (यह जानकारी या तो डेटाबेस में मौजूद थी या अप्रत्यक्ष आधार पर डेटा का विश्लेषण करके प्राप्त की गई थी)। इस आधार पर, 215K रिकॉर्ड से एक डेटासेट बनाया गया था।

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

टिप्पणियों का एक विशिष्ट अनुक्रम, उनमें से कौन लेखक है?

जवाब है

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

इंटरनेट पर पाए जाने वाले नेटवर्क के उदाहरण:

embed_dim = 128 model = Sequential() model.add(Embedding(max_fatures, embed_dim,input_length = X_train.shape[1])) model.add(SpatialDropout1D(0.2)) model.add(LSTM(196, dropout=0.5, recurrent_dropout=0.2)) model.add(Dense(1,activation='softmax')) model.compile(loss = 'binary_crossentropy', optimizer='adam',metrics = ['accuracy'])

HTML टैग और विशेष वर्णों की तर्ज पर, उन्होंने लगभग 65-74% सटीकता प्रदान की, जो एक सिक्का उछालने से बहुत अलग नहीं थी।

एक दिलचस्प बिंदु यह है कि pad_sequences(x_train, maxlen=max_len, padding='pre') माध्यम से इनपुट अनुक्रमों के संरेखण ने परिणामों में एक महत्वपूर्ण अंतर दिया। मेरे मामले में, सबसे अच्छा परिणाम पैडिंग = 'पोस्ट' के साथ था।

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

 re16 = re.compile(ur"(?:\b:(?:1|c(?:|)|(?:|)|(?:(?:|(?:(?:(?:|(?:)?|))?|(?:)?))|)|(?:(?:(?:|)|)||||(?:(?:||(?:|)|(?:|(?:(?:(?:||(?:(?:||(?:[]|)|[]))?|[і]))?|||1)||)|)|||[]|(?:|)|(?:(?:(?:[]|)|?|(?:(?:(?:|(?:)?))?|)|(?:|)))?)||)|(?:|x))\b)", re.UNICODE)

यहाँ, मैं विशेष रूप से विनम्र लोगों को विशेष धन्यवाद व्यक्त करना चाहूंगा जो इस शब्द को उनके प्रत्येक वाक्य में जोड़ना आवश्यक मानते हैं।

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

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

वेक्टर स्पेस में शब्द और उनके रिश्ते।

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

इन सभी परिवर्तनों ने स्थिर 84-85 प्रतिशत सटीकता लाई।

मॉडल उदाहरण

 def model_conv_core(model_input, embd_size = 128): num_filters = 128 X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input) X = Conv1D(num_filters, 3, activation='relu', padding='same')(X) X = Dropout(0.3)(X) X = MaxPooling1D(2)(X) X = Conv1D(num_filters, 5, activation='relu', padding='same')(X) return X def model_conv1d(model_input, embd_size = 128, num_filters = 64, kernel_size=3): X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input) X = Conv1D(num_filters, kernel_size, padding='same', activation='relu', strides=1)(X) # X = Dropout(0.1)(X) X = MaxPooling1D(pool_size=2)(X) X = LSTM(256, kernel_regularizer=regularizers.l2(0.004))(X) X = Dropout(0.3)(X) X = Dense(128, kernel_regularizer=regularizers.l2(0.0004))(X) X = LeakyReLU()(X) X = BatchNormalization()(X) X = Dense(1, activation="sigmoid")(X) model = Model(model_input, X, name='w2v_conv1d') return model def model_gru(model_input, embd_size = 128): X = model_conv_core(model_input, embd_size) X = MaxPooling1D(2)(X) X = Dropout(0.2)(X) X = GRU(256, activation='relu', return_sequences=True, kernel_regularizer=regularizers.l2(0.004))(X) X = Dropout(0.5)(X) X = GRU(128, activation='relu', kernel_regularizer=regularizers.l2(0.0004))(X) X = Dropout(0.5)(X) X = BatchNormalization()(X) X = Dense(1, activation="sigmoid")(X) model = Model(model_input, X, name='w2v_gru') return model def model_conv2d(model_input, embd_size = 128): from keras.layers import MaxPool2D, Conv2D, Reshape num_filters = 256 filter_sizes = [3, 5, 7] X = Embedding(total_unique_words, DIM, input_length=max_words, weights=[embedding_matrix], trainable=False, name='Word2Vec')(model_input) reshape = Reshape((maxSequenceLength, embd_size, 1))(X) conv_0 = Conv2D(num_filters, kernel_size=(filter_sizes[0], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape) conv_1 = Conv2D(num_filters, kernel_size=(filter_sizes[1], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape) conv_2 = Conv2D(num_filters, kernel_size=(filter_sizes[2], embd_size), padding='valid', kernel_initializer='normal', activation='relu')(reshape) maxpool_0 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[0] + 1, 1), strides=(1,1), padding='valid')(conv_0) maxpool_1 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[1] + 1, 1), strides=(1,1), padding='valid')(conv_1) maxpool_2 = MaxPool2D(pool_size=(maxSequenceLength - filter_sizes[2] + 1, 1), strides=(1,1), padding='valid')(conv_2) X = concatenate([maxpool_0, maxpool_1, maxpool_2], axis=1) X = Dropout(0.2)(X) X = Flatten()(X) X = Dense(int(embd_size / 2.0), activation='relu', kernel_regularizer=regularizers.l2(0.004))(X) X = Dropout(0.5)(X) X = BatchNormalization()(X) X = Dense(1, activation="sigmoid")(X) model = Model(model_input, X, name='w2v_conv2d') return model

और कोड में 6 और मॉडल। कुछ मॉडल नेटवर्क से लिए गए हैं, कुछ स्वतंत्र रूप से आविष्कार किए गए हैं।

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

 def gray_code(n): def gray_code_recurse (g,n): k = len(g) if n <= 0: return else: for i in range (k-1, -1, -1): char='1' + g[i] g.append(char) for i in range (k-1, -1, -1): g[i]='0' + g[i] gray_code_recurse (g, n-1) g = ['0','1'] gray_code_recurse(g, n-1) return g def gen_list(m): out = [] g = gray_code(len(m)) for i in range (len(g)): mask_str = g[i] idx = 0 v = [] for c in list(mask_str): if c == '1': v.append(m[idx]) idx += 1 if len(v) > 1: out.append(v) return out

पहनावा के साथ "जीवन और अधिक मजेदार हो गया है" और मॉडल की सटीकता का वर्तमान प्रतिशत 86-87% के स्तर पर है, जो मुख्य रूप से डेटासेट में कुछ लेखकों के खराब-गुणवत्ता वर्गीकरण से जुड़ा हुआ है।

मुझे जो समस्याएं मिलीं:

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

समाधान के लिए, एक साइकिल को प्रशिक्षण और सत्यापन के नमूनों में अलग करने के लिए बनाया गया था। हालांकि ज्यादातर मामलों में स्केलेर लाइब्रेरी से train_test_split प्रक्रिया पर्याप्त है।

वर्तमान काम कर रहे मॉडल का ग्राफ:

नतीजतन, मुझे लघु टिप्पणियों के लेखकों की एक आश्वस्त परिभाषा के साथ एक मॉडल मिला। आगे का सुधार प्रशिक्षण डेटासेट में वास्तविक डेटा के वर्गीकरण के परिणामों को साफ करने और स्थानांतरित करने के साथ जुड़ा होगा।

अतिरिक्त स्पष्टीकरण के साथ सभी कोड रिपॉजिटरी में है ।

एक पोस्टस्क्रिप्ट के रूप में: यदि आपको पाठ के बड़े संस्करणों को वर्गीकृत करने की आवश्यकता है, तो "डीप डीप कंफ्यूज़नल न्यूरल नेटवर्क" वीडीसीएनएन मॉडल (केरस पर कार्यान्वयन ) पर एक नज़र डालें, यह टेक्स्ट के लिए रेसनेट का एक एनालॉग है।

प्रयुक्त सामग्री:

• मशीन सीखने के पाठ्यक्रमों का अवलोकन
• कनवल्शन का उपयोग करके बातचीत विश्लेषण
• एनएलपी में संवेदी नेटवर्क
• मशीन लर्निंग में मेट्रिक्स
https://ld86.imtqy.com/ml-slides/unbalanced.html
• मॉडल के अंदर एक नज़र

भाग्य तंत्रिका नेटवर्क पर बता रहा है: क्या लेखक ने खुद पोस्ट पर टिप्पणियों में उल्लेख किया है

More articles: