न्यूरल नेटवर्क्स का उपयोग करके वाटर मेलन का परीक्षण: पूर्ण देव। प्रोटोटाइप से ऐप तक साइकिल। गूगल प्ले पर

शुरुआत है

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

चयन उपकरण

हमारे पास समस्या को हल करने के कुछ तरीके हैं, और मुझे एक आसान से बचने के लिए कुछ प्रयासों को लागू करना था। जो है, फूरियर ट्रांसफॉर्म, वेवलेट्स और सिग्नल एडिटर। मैं आखिरकार तंत्रिका नेटवर्क सीखना चाहता था।

मैंने केरस को एक एनएन लाइब्रेरी के रूप में चुना, जो Google का एक अद्भुत उपकरण है, जो TensorFlow और Theano के आसपास एक आवरण है। यदि आप एक शुरुआती हैं, तो यह निश्चित रूप से सबसे अच्छा उपकरण है। एक तरफ, केर एक शक्तिशाली उपकरण है, जिसे गति, मेमोरी और हार्डवेयर (और हाँ, यह GPU के साथ काम करता है) द्वारा अनुकूलित किया गया है। दूसरे पर - यह उपयोगकर्ता से सभी उबाऊ कर्मचारियों को छुपाता है, जिससे कार्य पर ध्यान केंद्रित करने की अनुमति मिलती है। बहुत सुविधाजनक है।

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

अजगर के अलावा आपको कुछ अतिरिक्त पुस्तकालयों की आवश्यकता होगी, लेकिन उन्हें माहिर करना आसान है - यहां तक ​​कि अजगर की तुलना में भी। आपको NumPy, PyPlot और संभवतः कुछ अन्य पुस्तकालयों के साथ एक (उथले) अनुभव की आवश्यकता होगी।

अंत में यह ध्यान देने योग्य है कि हमें GPU क्लस्टर्स की जरूरत नहीं है: हमारी समस्या को एक सीपीयू पर हल किया जा सकता है, धीमा, लेकिन गंभीर रूप से धीमा नहीं।

काम की योजना

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

अगला कदम एक प्रोग्राम लिखना है। मैं इसे एंड्रॉइड के लिए जावा पर करने की योजना बना रहा हूं। यह एक प्रोटोटाइप होने जा रहा है, जिसका अर्थ है कि इसमें यूआई होगा, लेकिन कोई एनएन - अभी तक नहीं।

हमें एक डमी कार्यक्रम क्यों लिखना है? यहाँ यह चाल है: किसी भी गहरी सीखने के लिए डेटा की जरूरत है, ठीक है, सीखो। एनएन को पर्याप्त मात्रा में डेटा> ए सौ के साथ प्रदान करने के लिए मुझे (इस शब्द के दोनों अर्थों में) कितने जल मेलों का परीक्षण करना चाहिए? अधिक?

यहां हम डमी प्रोग्राम का उपयोग करने जा रहे हैं: मैं इसे Google Play पर डालूंगा, इसे दूर कर दूंगा (ठीक है, अपने सभी दोस्तों को इसे स्थापित करने के लिए मजबूर कर दूं) और इससे डेटा एकत्र करूं ... कहां?

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

अंत में, जब हमारे पास पर्याप्त डेटा होता है, तो हम एनएन को सिखा सकते हैं।

फिर हमें परिणामी एनएन को जावा में पोर्ट करने और "डमी" को बदलने के लिए हमारे कार्यक्रम का एक नया संस्करण जारी करने की आवश्यकता है।

लाभ। नहीं, रुको। कार्यक्रम निशुल्क है। सिर्फ अनुभव है।

Nn बनाना

ऑडियो सिग्नल के साथ काम करना, जो निश्चित रूप से वॉटर मेलन को दस्तक दे रहा है, का अर्थ है या तो आवर्तक तंत्रिका नेटवर्क या तथाकथित एक dimentional CNN। चूंकि सीएनएन का उपयोग करना आसान है और - छोटे संकेतों के लिए - बेहतर, हम उनका उपयोग करने जा रहे हैं। एक दृढ़ एनएन का विचार हमारे डेटा की एक सरणी (जो एक ऑडियो सिग्नल है) के ऊपर एक "सेंसर विंडो" स्लाइडिंग में है। परिणामस्वरूप, सभी डेटा का एक साथ विश्लेषण करने के बजाय, हम स्थानीय उप-पैटर्न की तलाश करते हैं। एनएन की प्रत्येक निम्न परत पिछले एक द्वारा प्राप्त पैटर्न के साथ काम करती है, जो उच्च स्तर के पैटर्न की तलाश में है।

इसे आसान बनाने के लिए, कल्पना करें कि हमें समुद्र की तस्वीर में सीगल ढूंढना है। हम तस्वीर के पार एक छोटी "विंडो" स्लाइड करते हैं, एक सफेद "चेकमार्क-जैसे" पैटर्न की तलाश करते हैं। अब, यह एक 2D आयामी तंत्रिका नेटवर्क था, जो एक आयामी संकेत के लिए एक जैसा था, 1D CNN एक तार्किक विकल्प है।

एनएन की निम्नलिखित संरचना थी:

model = Sequential() model.add(Conv1D(filters=32, kernel_size=512, strides=3, padding='valid', use_bias=False, input_shape=(nSampleSize, 1), name='c1d', activation='relu')) model.add(Activation('relu', input_shape=(nSampleSize, 1))) model.add(MaxPooling1D(pool_size=(2))) model.add(Conv1D(32, (3))) model.add(Activation('relu')) model.add(MaxPooling1D(pool_size=(2))) model.add(Conv1D(64, (3))) model.add(Activation('relu')) model.add(MaxPooling1D(pool_size=(2))) model.add(Flatten()) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nNumOfOutputs)) #1)) model.add(Activation('sigmoid')) model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy']) 

इस एनएन के दो आउटपुट हैं (यह दो मूल्यों की भविष्यवाणी करता है: मिठास और परिपक्वता। मिठास 0 (मिठाई नहीं), 1 (सामान्य) और 2 (उत्कृष्ट) हो सकती है। परिपक्वता के लिए, यह 0 (बहुत कठोर), 1 (अच्छा) हो सकता है। ) और 2 - बहुत नरम, रेत के साथ कपास की तरह।

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

प्रोग्राम लिखना

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

यहाँ एक कार्यक्रम के अंतिम संस्करण का एक पृष्ठ है, यह मुफ़्त है।

यह क्या करता है:

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



2. हमारे द्वारा की गई रिकॉर्डिंग को एक अस्थायी फ़ाइल के रूप में सहेजा गया है। अस्थायी रूप से मेरा मतलब है कि यह अगली रिकॉर्डिंग द्वारा अधिलेखित हो जाएगा। यह दस्तक देने की अनुमति देता है यदि कोई कमरे में बात करता है (आपको विश्वास नहीं होगा कि लोगों को पांच सेकंड के लिए शांत करना कितना मुश्किल है!), या पानी चलता है, या किसी अन्य शोर ने जगह बनाई है।

ठीक है, कहते हैं कि पानी का मेलन खरीदा जाता है और आप इसे घर ले आए हैं। आपने एक रिकॉर्डिंग बनाई है, और फिर आपने इसे काट दिया है। अब आप इसके स्वाद का अनुमान लगाने के लिए तैयार हैं।

"सहेजें" टैब चुनें।

इस टैब पर हमारे पास दो कॉम्बो बॉक्स हैं: मिठास और परिपक्वता। मानों का चयन करें, और सहेजें पर क्लिक करें।

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



3. अंत में, जब आप पानी के मेलों के बारे में अनुमान लगाते हैं, तब आप उस गाँव से वापस आ गए हैं जहाँ आपको पानी के मेलों की असीमित सुविधा थी, लेकिन इंटरनेट नहीं। अब आप ऑनलाइन हैं। सबमिट टैब खोलें और बटन दबाएं। आपके द्वारा अभी तक सबमिट नहीं किए गए सभी तरबूजों की जानकारी वाला एक पैकेज हमारे सर्वर पर भेजा जाएगा।

सर्वर साइड प्रोग्राम लिखना

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

 <?php if (is_uploaded_file($_FILES['file']['tmp_name'])) { $uploads_dir = './melonaire/'; $tmp_name = $_FILES['file']['tmp_name']; $pic_name = $_FILES['file']['name']; $filename = md5(date('Ymd H:i:s:u')); move_uploaded_file($tmp_name, $uploads_dir.$filename); } else { echo "File not uploaded successfully."; } ?> 

Nn प्रशिक्षण

हम प्रशिक्षण (70%) और परीक्षण (30%) के लिए डेटा को विभाजित करते हैं। न्यूरल नेट अच्छी तरह से परिवर्तित होता है, यहां कोई आश्चर्य नहीं है। शुरुआती के लिए एक नोट: इनपुट डेटा को सामान्य करने के लिए मत भूलना, यह आपको बहुत समय और नसों को बचाएगा। कुछ इस तरह:

 for file_name in os.listdir(path): nSweetness, nRipeness, arr_loaded = loadData(file_name) arr_data.append(arr_loaded / max(abs(arr_loaded))) # 2 stands for num. of inputs of a combo box - 1 arr_labels.append([nSweetness / 2.0, nRipeness / 2.0]) 

जावा में पोर्टिंग

पायथन से जावा तक एनएन को पोर्ट करने के कुछ तरीके हैं। हाल ही में, Google ने इस प्रक्रिया को वास्तव में सुविधाजनक बना दिया है, इसलिए यदि आप पाठ्यपुस्तकों का अध्ययन करने का निर्णय लेते हैं, तो सुनिश्चित करें कि वे अप्रचलित नहीं हैं। यहाँ है कि मैं यह कैसे किया:

 from keras.models import Model from keras.models import load_model from keras.layers import * import os import sys import tensorflow as tf # ------------------- def print_graph_nodes(filename): g = tf.GraphDef() g.ParseFromString(open(filename, 'rb').read()) print() print(filename) print("=======================INPUT=========================") print([n for n in g.node if n.name.find('input') != -1]) print("=======================OUTPUT========================") print([n for n in g.node if n.name.find('output') != -1]) print("===================KERAS_LEARNING=====================") print([n for n in g.node if n.name.find('keras_learning_phase') != -1]) print("======================================================") print() # ------------------- def get_script_path(): return os.path.dirname(os.path.realpath(sys.argv[0])) # ------------------- def keras_to_tensorflow(keras_model, output_dir, model_name,out_prefix="output_", log_tensorboard=True): if os.path.exists(output_dir) == False: os.mkdir(output_dir) out_nodes = [] for i in range(len(keras_model.outputs)): out_nodes.append(out_prefix + str(i + 1)) tf.identity(keras_model.output[i], out_prefix + str(i + 1)) sess = K.get_session() from tensorflow.python.framework import graph_util, graph_io init_graph = sess.graph.as_graph_def() main_graph = graph_util.convert_variables_to_constants(sess, init_graph, out_nodes) graph_io.write_graph(main_graph, output_dir, name=model_name, as_text=False) if log_tensorboard: from tensorflow.python.tools import import_pb_to_tensorboard import_pb_to_tensorboard.import_to_tensorboard( os.path.join(output_dir, model_name), output_dir) model = load_model(get_script_path() + "/models/model.h5") #keras_to_tensorflow(model, output_dir=get_script_path() + "/models/model.h5", # model_name=get_script_path() + "/models/converted.pb") print_graph_nodes(get_script_path() + "/models/converted.pb") 

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

अगला, हम निर्यात की गई फ़ाइल को एंड्रॉइड स्टूडियो प्रोजेक्ट के "एसेट्स" फ़ोल्डर में डालते हैं (फ़ाइल का नाम निर्देशांक। Pb है, मत पूछो), लाइब्रेरी जोड़ें ( यहां , यहां या बेहतर, यहां टेंसोफ़्लोर्टिनिफेरेंसफ़र्टफेस, और ... यही है।

यह बात है। जब मैंने पहली बार ऐसा किया, तो मुझे समस्याओं की उम्मीद थी, लेकिन ... सब कुछ बस काम कर गया।

यहाँ जावा कोड से हमारे एनएन के लिए कॉल है:

  protected Void doInBackground(Void... params) { try { //Pass input into the tensorflow tf.feed(INPUT_NAME, m_arrInput, 1, // batch ? m_arrInput.length, 1); // channels ? //compute predictions tf.run(new String[]{OUTPUT_NAME}); //copy the output into the PREDICTIONS array tf.fetch(OUTPUT_NAME, m_arrPrediction); } catch (Exception e) { e.getMessage(); } return null; } 

यहाँ "m_arrInput" - एक ऐसा सरणी जिसमें दो तत्व होते हैं, हमारी भविष्यवाणी (मिठास, पकना) के साथ, 0 से 1 रेंज में।

निष्कर्ष

मेरा मानना ​​है कि मैं अपने दर्शकों को ध्यान देने के लिए और आशा व्यक्त करने के लिए धन्यवाद देना चाहता हूं कि यह दिलचस्प था। इसके बजाय, मैं आपको और अधिक मीठे पानी के मेलन्स की कामना करता हूं, और मुझे आशा है कि आप मुझे नए ऑडियो नमूने भेजेंगे, जैसा कि आप उन्हें खाते हैं (मेलॉन, नमूने नहीं, हुह!)

कार्यक्रम नि: शुल्क है, निश्चित रूप से।