🔰 👨‍👦‍👦 🤙🏿 Google Play पर एक कार्यक्रम के लिए एक विचार से, केरस का उपयोग करके एक तरबूज की परिपक्वता का निर्धारण करना 👨‍👨‍👧‍👦 🤳🏾 👨‍👧‍👧

यह सब कैसे शुरू हुआ

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

उपकरण चयन

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

Google, TensorFlow और Theano के लिए Google ऐड-ऑन को तंत्रिका नेटवर्क बनाने और प्रशिक्षण के लिए एक पुस्तकालय के रूप में चुना गया था। सामान्य तौर पर, यदि आप केवल गहन शिक्षण नेटवर्क के साथ शुरुआत कर रहे हैं, तो आपको बेहतर उपकरण नहीं मिलेंगे। एक ओर, केर गति, मेमोरी और हार्डवेयर के लिए अनुकूलित एक शक्तिशाली उपकरण है (हां, यह वीडियो कार्ड और उनके समूहों पर काम कर सकता है)। दूसरी ओर, उपयोगकर्ता से "छिपाया" जा सकने वाला सब कुछ वहां छिपा हुआ है, इसलिए आपको अपने दिमाग को तंत्रिका नेटवर्क की परतों के डॉकिंग पर रैक करने की आवश्यकता नहीं है, उदाहरण के लिए। बहुत सहज है।

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

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

खैर, निष्कर्ष में, मैं ध्यान देता हूं कि हमें ऊपर वर्णित वीडियो कार्ड समूहों की आवश्यकता नहीं है - हमारा कार्य सामान्य रूप से कंप्यूटर सीपीयू की सहायता से हल किया जाता है - धीरे-धीरे, लेकिन गंभीर रूप से धीरे-धीरे नहीं।

कार्य योजना

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

अगला कदम एक प्रोग्राम लिखना है। मैं Android के तहत जावा में ऐसा करने की योजना बना रहा हूं। यह कार्यक्रम का एक प्रोटोटाइप होगा, इस अर्थ में कि इसमें एक उपयोगकर्ता इंटरफ़ेस होगा, लेकिन अभी तक कोई तंत्रिका नेटवर्क नहीं है।

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

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

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

अंत में, पर्याप्त डेटा। हम एक तंत्रिका नेटवर्क को प्रशिक्षित करते हैं।

हम जावा में तंत्रिका नेटवर्क को पोर्ट करते हैं और हमारे कार्यक्रम के लिए एक अपडेट जारी करते हैं।

लाभ। हालांकि नहीं। कार्यक्रम निशुल्क था। केवल अनुभव और भरवां धक्कों।

एक तंत्रिका नेटवर्क बनाना

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

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

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

उपयोग किए गए नेटवर्क में निम्नलिखित संरचना थी:

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 अति है, जैसे रेत के साथ कपास ऊन।

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

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

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

यहां Google Play पर कार्यक्रम का पृष्ठ है , निश्चित रूप से, कार्यक्रम मुफ्त है।

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

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

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

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."; } ?>

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

डेटा को क्रमशः 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")

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

इसलिए, हमने प्राप्त फ़ाइल को समन्वित किया है। इस प्रोजेक्ट की संपत्ति निर्देशिका में एंड्रॉइड स्टूडियो में डायरेक्ट करें , टेनसफ़्लोस्ट्रीमिनिफेरेंस लाइब्रेरी ( यहां देखें, या बेहतर, यहां देखें ), और इसे कनेक्ट करें।

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

यहाँ जावा कोड से एक तंत्रिका नेटवर्क कॉल कैसा दिखता है:

  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 दो तत्वों वाले एक सरणी है - हाँ! - हमारी भविष्यवाणी, शून्य से एक तक सामान्यीकृत।

निष्कर्ष

यहाँ, ऐसा लगता है, किसी को ध्यान देने के लिए धन्यवाद देना चाहिए, और उम्मीद है कि यह दिलचस्प था। इसके बजाय, मैं ध्यान देता हूं कि Google कार्यक्रम का पहला संस्करण है। दूसरा पूरी तरह से तैयार है, लेकिन पर्याप्त डेटा नहीं है। इसलिए यदि आपको तरबूज पसंद हैं - तो कृपया अपने एंड्रॉइड पर एक कार्यक्रम डालें। जितना अधिक डेटा आप भेजेंगे, उतना बेहतर दूसरा संस्करण काम करेगा ...

बेशक, यह मुफ्त होगा।

गुड लक, और हाँ: देखने के लिए धन्यवाद। मुझे उम्मीद है कि यह दिलचस्प था।

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

Google Play पर एक कार्यक्रम के लिए एक विचार से, केरस का उपयोग करके एक तरबूज की परिपक्वता का निर्धारण करना