एक कुत्ते की नस्ल का निर्धारण: पायथन में एक तंत्रिका नेटवर्क से Google Play पर एक आवेदन के लिए एक पूर्ण विकास चक्र

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

हालाँकि, अभी भी कई विवरण हैं जो इस कार्य को इतना अयोग्य नहीं बनाते हैं जितना कि ... उबाऊ, मैं कहूंगा। इसमें बहुत अधिक समय लगता है, खासकर यदि आप एक शुरुआतकर्ता हैं जिन्हें नेतृत्व, कदम-दर-कदम, आपकी आंखों के ठीक सामने एक परियोजना, और शुरू से अंत तक पूरा करने की आवश्यकता है। ऐसे मामलों में सामान्य के बिना, "इस स्पष्ट भाग को छोड़ दें" बहाने।

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

यदि आप तैयार परिणाम को देखना चाहते हैं, तो यह है: Google Play पर NeuroDog ऐप ।

मेरी रोबोटिक्स (प्रगति में) के साथ वेबसाइट: robotics.snowcron.com ।
एक गाइड सहित कार्यक्रम के साथ वेब साइट: न्यूरोडॉग उपयोगकर्ता गाइड ।

और यहाँ कार्यक्रम का एक स्क्रीनशॉट है:

समस्या का बयान

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

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

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

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

हमने इनपुट के रूप में नेटवर्क को एक चित्र (संख्याओं की एक सरणी, जो है) को "खिलाया" है। पहली परत सरल पैटर्न के लिए छवि का विश्लेषण करती है, जैसे "क्षैतिज रेखा", "चाप", आदि। अगली परत एक इनपुट के रूप में इन पैटर्नों को प्राप्त करती है, और दूसरे क्रम के पैटर्न का उत्पादन करती है, जैसे कि "फर", "आंख का कोना" ... आखिरकार, हमें एक पहेली मिलती है जिससे हम कुत्ते को फिर से संगठित कर सकते हैं: ऊन, दो आंखें और दांतों में एक मानव हाथ।

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

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

चूंकि हम कुत्तों की नस्लों को पहचानने के लिए अपने तंत्रिका नेटवर्क को सिखाने की योजना बनाते हैं, इसलिए हमें विभिन्न नस्लों के नमूनों को "दिखाना" चाहिए। सौभाग्य से, एक समान कार्य के लिए यहां बनाई गई तस्वीरों का एक सेट है ( मूल यहां है )।

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

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

नतीजतन, हमें एंड्रॉइड के लिए पूरी तरह कार्यात्मक "वाणिज्यिक" (उद्धरण चिह्नों में, जैसा कि इसे मुफ्त में रखा गया है) मिलता है और तंत्रिका नेटवर्क का उपयोग करता है।

विकास का वातावरण

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

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

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

फिलहाल, कोलाब को यहां काम पर रखा जा सकता है , लेकिन Google को जानकर, यह किसी भी समय बदल सकता है। बस Google Google Colab।

कोलाब का उपयोग करने के साथ स्पष्ट समस्या यह है कि यह एक WEB सेवा है। हम अपने डेटा तक कैसे पहुँच सकते हैं? प्रशिक्षण के बाद तंत्रिका नेटवर्क को बचाएं, उदाहरण के लिए, हमारे कार्य और इतने पर विशिष्ट डेटा डाउनलोड करें?

कई हैं (इस लेख को लिखने के समय - तीन) अलग-अलग तरीके, हम एक का उपयोग करते हैं जो मुझे लगता है कि सबसे सुविधाजनक है - हम Google ड्राइव का उपयोग करते हैं।

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

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

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

प्रारंभ

सबसे पहले, चलिए Google Drive को माउंट करते हैं। केवल दो लाइनें। इस कोड को केवल एक बार एक Colab सत्र में निष्पादित किया जाना चाहिए (जैसे, प्रत्येक 6 घंटे में एक बार)। यदि आप इसे दूसरी बार कहते हैं, जबकि सत्र अभी भी "जीवित" है, तो इसे छोड़ दिया जाएगा क्योंकि ड्राइव पहले से ही घुड़सवार है।

from google.colab import drive drive.mount('/content/drive/') 

पहली शुरुआत में, आपको अपने इरादों की पुष्टि करने के लिए कहा जाएगा, जटिल कुछ भी नहीं है। यहाँ यह कैसा दिखता है:

 >>> Go to this URL in a browser: ... >>> Enter your authorization code: >>> ·········· >>> Mounted at /content/drive/ 

एक पूरी तरह से मानक में अनुभाग शामिल हैं ; यह संभव है कि कुछ सम्मिलित फ़ाइलों की आवश्यकता न हो, ठीक है ... क्षमा करें। इसके अलावा, चूंकि मैं विभिन्न तंत्रिका नेटवर्क का परीक्षण करने जा रहा हूं, इसलिए आपको विशिष्ट प्रकार के तंत्रिका नेटवर्क के लिए कुछ सम्मिलित मॉड्यूल को टिप्पणी / अनसुना करना होगा: उदाहरण के लिए, InceptionV3 NN का उपयोग करने के लिए, InceptionV3 के शामिल किए जाने में असहजता, और उदाहरण के लिए, ResNet50। या नहीं: इस सब से जो परिवर्तन होता है वह प्रयुक्त मेमोरी का आकार है, और यह बहुत मजबूत नहीं है।

 import datetime as dt import pandas as pd import seaborn as sns import matplotlib.pyplot as plt from tqdm import tqdm import cv2 import numpy as np import os import sys import random import warnings from sklearn.model_selection import train_test_split import keras from keras import backend as K from keras import regularizers from keras.models import Sequential from keras.models import Model from keras.layers import Dense, Dropout, Activation from keras.layers import Flatten, Conv2D from keras.layers import MaxPooling2D from keras.layers import BatchNormalization, Input from keras.layers import Dropout, GlobalAveragePooling2D from keras.callbacks import Callback, EarlyStopping from keras.callbacks import ReduceLROnPlateau from keras.callbacks import ModelCheckpoint import shutil from keras.applications.vgg16 import preprocess_input from keras.preprocessing import image from keras.preprocessing.image import ImageDataGenerator from keras.models import load_model from keras.applications.resnet50 import ResNet50 from keras.applications.resnet50 import preprocess_input from keras.applications.resnet50 import decode_predictions from keras.applications import inception_v3 from keras.applications.inception_v3 import InceptionV3 from keras.applications.inception_v3 import preprocess_input as inception_v3_preprocessor from keras.applications.mobilenetv2 import MobileNetV2 from keras.applications.nasnet import NASNetMobile 

Google डिस्क पर, हम अपनी फ़ाइलों के लिए एक फ़ोल्डर बनाते हैं। दूसरी पंक्ति इसकी सामग्री प्रदर्शित करती है:

 working_path = "/content/drive/My Drive/DeepDogBreed/data/" !ls "/content/drive/My Drive/DeepDogBreed/data" >>> all_images labels.csv models test train valid 

जैसा कि आप देख सकते हैं, कुत्तों की तस्वीरें (Google ड्राइव पर स्टैनफोर्ड डेटासेट (ऊपर देखें) से कॉपी की गई) सबसे पहले ऑल्टिमेंट फ़ोल्डर में सहेजी जाती हैं। बाद में, हम उन्हें ट्रेन, मान्य और परीक्षण निर्देशिकाओं में कॉपी कर लेंगे। हम प्रशिक्षित मॉडल को मॉडल फ़ोल्डर में सहेजेंगे। के रूप में Label.csv फ़ाइल के लिए, यह तस्वीरों के साथ डेटासेट का हिस्सा है, इसमें चित्रों और कुत्तों की नस्लों के नामों के पत्राचार की एक तालिका है।

ऐसे कई परीक्षण हैं जिन्हें आप यह समझने के लिए चला सकते हैं कि Google से अस्थायी उपयोग के लिए हमें वास्तव में क्या मिला। उदाहरण के लिए:

 # Is GPU Working? import tensorflow as tf tf.test.gpu_device_name() >>> '/device:GPU:0' 

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

अगला, हमें कुछ स्थिरांक घोषित करने की आवश्यकता है, जैसे कि छवियों का आकार, आदि। हम 256x256 पिक्सल के आकार के साथ चित्रों का उपयोग करेंगे, यह एक बड़ी पर्याप्त छवि है ताकि विस्तार न खोएं, और इतना छोटा है कि सब कुछ स्मृति में फिट बैठता है। हालाँकि, ध्यान दें कि कुछ प्रकार के तंत्रिका नेटवर्क जो हम 224x224 पिक्सेल छवियों की अपेक्षा करेंगे। ऐसे मामलों में, हम 256 और अप्रतिबंधित 224 टिप्पणी करते हैं।

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

 warnings.filterwarnings("ignore") os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' np.random.seed(7) start = dt.datetime.now() BATCH_SIZE = 16 EPOCHS = 15 TESTING_SPLIT=0.3 # 70/30 % NUM_CLASSES = 120 IMAGE_SIZE = 256 #strModelFileName = "models/ResNet50.h5" # strModelFileName = "models/InceptionV3.h5" strModelFileName = "models/InceptionV3_Sgd.h5" #IMAGE_SIZE = 224 #strModelFileName = "models/MobileNetV2.h5" #IMAGE_SIZE = 224 #strModelFileName = "models/NASNetMobileSgd.h5" 

डेटा लोड हो रहा है

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

 labels = pd.read_csv(working_path + 'labels.csv') print(labels.head()) train_ids, valid_ids = train_test_split(labels, test_size = TESTING_SPLIT) print(len(train_ids), 'train ids', len(valid_ids), 'validation ids') print('Total', len(labels), 'testing images') >>> id breed >>> 0 000bec180eb18c7604dcecc8fe0dba07 boston_bull >>> 1 001513dfcb2ffafc82cccf4d8bbaba97 dingo >>> 2 001cdf01b096e06d78e9e5112d419397 pekinese >>> 3 00214f311d5d2247d5dfe4fe24b2303d bluetick >>> 4 0021f9ceb3235effd7fcde7f7538ed62 golden_retriever >>> 7155 train ids 3067 validation ids >>> Total 10222 testing images 

अगला, फ़ाइल नामों के अनुसार छवि फ़ाइलों को प्रशिक्षण / सत्यापन / परीक्षण फ़ोल्डर में कॉपी करें। निम्न फ़ंक्शन उन फ़ाइलों की प्रतिलिपि बनाता है जिनके नाम हम निर्दिष्ट फ़ोल्डर में स्थानांतरित करते हैं।

 def copyFileSet(strDirFrom, strDirTo, arrFileNames): arrBreeds = np.asarray(arrFileNames['breed']) arrFileNames = np.asarray(arrFileNames['id']) if not os.path.exists(strDirTo): os.makedirs(strDirTo) for i in tqdm(range(len(arrFileNames))): strFileNameFrom = strDirFrom + arrFileNames[i] + ".jpg" strFileNameTo = strDirTo + arrBreeds[i] + "/" + arrFileNames[i] + ".jpg" if not os.path.exists(strDirTo + arrBreeds[i] + "/"): os.makedirs(strDirTo + arrBreeds[i] + "/") # As a new breed dir is created, copy 1st file # to "test" under name of that breed if not os.path.exists(working_path + "test/"): os.makedirs(working_path + "test/") strFileNameTo = working_path + "test/" + arrBreeds[i] + ".jpg" shutil.copy(strFileNameFrom, strFileNameTo) shutil.copy(strFileNameFrom, strFileNameTo) 

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

ऐसा इसलिए किया जाता है क्योंकि केरेस एक समान संरचना की निर्देशिका के साथ काम कर सकता है, आवश्यकतानुसार छवि फ़ाइलों को लोड कर सकता है, और एक बार में सभी नहीं, जो स्मृति को बचाता है। एक बार में सभी 15,000 छवियों को अपलोड करना एक बुरा विचार है।

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

 # Move the data in subfolders so we can # use the Keras ImageDataGenerator. # This way we can also later use Keras # Data augmentation features. # --- Uncomment once, to copy files --- #copyFileSet(working_path + "all_images/", # working_path + "train/", train_ids) #copyFileSet(working_path + "all_images/", # working_path + "valid/", valid_ids) 

कुत्तों की नस्लों की एक सूची प्राप्त करें:

 breeds = np.unique(labels['breed']) map_characters = {} #{0:'none'} for i in range(len(breeds)): map_characters[i] = breeds[i] print("<item>" + breeds[i] + "</item>") >>> <item>affenpinscher</item> >>> <item>afghan_hound</item> >>> <item>african_hunting_dog</item> >>> <item>airedale</item> >>> <item>american_staffordshire_terrier</item> >>> <item>appenzeller</item> 

छवि प्रसंस्करण

हम Kairas लाइब्रेरी फीचर का उपयोग करने जा रहे हैं जिसे ImageDataGenerators कहा जाता है। ImageDataGenerator इमेज, स्केल, रोटेट और इतने पर प्रोसेस कर सकता है। यह एक प्रसंस्करण फ़ंक्शन को भी स्वीकार कर सकता है जो छवियों को अतिरिक्त रूप से संसाधित कर सकता है।

 def preprocess(img): img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE), interpolation = cv2.INTER_AREA) # or use ImageDataGenerator( rescale=1./255... img_1 = image.img_to_array(img) img_1 = cv2.resize(img_1, (IMAGE_SIZE, IMAGE_SIZE), interpolation = cv2.INTER_AREA) img_1 = np.expand_dims(img_1, axis=0) / 255. #img = cv2.blur(img,(5,5)) return img_1[0] 

निम्नलिखित कोड पर ध्यान दें:

 # or use ImageDataGenerator( rescale=1./255... 

हम ImageDataGenerator में ही (मूल 0-255 के बजाय 0-1 की सीमा के तहत उप-डेटा) को सामान्य कर सकते हैं। फिर हमें प्रीप्रोसेसर की आवश्यकता क्यों है? एक उदाहरण के रूप में, धुंधली कॉल पर विचार करें (टिप्पणी की गई है, मैं इसका उपयोग नहीं करता हूं): यह वही कस्टम छवि हेरफेर है जो मनमाना हो सकता है। एचडीआर के विपरीत कुछ भी।

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

 train_datagen = ImageDataGenerator( preprocessing_function=preprocess, #rescale=1./255, # done in preprocess() # randomly rotate images (degrees, 0 to 30) rotation_range=30, # randomly shift images horizontally # (fraction of total width) width_shift_range=0.3, height_shift_range=0.3, # randomly flip images horizontal_flip=True, ,vertical_flip=False, zoom_range=0.3) val_datagen = ImageDataGenerator( preprocessing_function=preprocess) train_gen = train_datagen.flow_from_directory( working_path + "train/", batch_size=BATCH_SIZE, target_size=(IMAGE_SIZE, IMAGE_SIZE), shuffle=True, class_mode="categorical") val_gen = val_datagen.flow_from_directory( working_path + "valid/", batch_size=BATCH_SIZE, target_size=(IMAGE_SIZE, IMAGE_SIZE), shuffle=True, class_mode="categorical") 

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

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

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

 def createModelVanilla(): model = Sequential() # Note the (7, 7) here. This is one of technics # used to reduce memory use by the NN: we scan # the image in a larger steps. # Also note regularizers.l2: this technic is # used to prevent overfitting. The "0.001" here # is an empirical value and can be optimized. model.add(Conv2D(16, (7, 7), padding='same', use_bias=False, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), kernel_regularizer=regularizers.l2(0.001))) # Note the use of a standard CNN building blocks: # Conv2D - BatchNormalization - Activation # MaxPooling2D - Dropout # The last two are used to avoid overfitting, also, # MaxPooling2D reduces memory use. model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')) model.add(Dropout(0.5)) model.add(Conv2D(16, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')) model.add(Dropout(0.5)) model.add(Conv2D(32, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(Dropout(0.5)) model.add(Conv2D(32, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')) model.add(Dropout(0.5)) model.add(Conv2D(64, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(Dropout(0.5)) model.add(Conv2D(64, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')) model.add(Dropout(0.5)) model.add(Conv2D(128, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(Dropout(0.5)) model.add(Conv2D(128, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')) model.add(Dropout(0.5)) model.add(Conv2D(256, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(Dropout(0.5)) model.add(Conv2D(256, (3, 3), padding='same', use_bias=False, kernel_regularizer=regularizers.l2(0.01))) model.add(BatchNormalization(axis=3, scale=False)) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same')) model.add(Dropout(0.5)) # This is the end on "convolutional" part of CNN. # Now we need to transform multidementional # data into one-dim. array for a fully-connected # classifier: model.add(Flatten()) # And two layers of classifier itself (plus an # Activation layer in between): model.add(Dense(NUM_CLASSES, activation='softmax', kernel_regularizer=regularizers.l2(0.01))) model.add(Activation("relu")) model.add(Dense(NUM_CLASSES, activation='softmax', kernel_regularizer=regularizers.l2(0.01))) # We need to compile the resulting network. # Note that there are few parameters we can # try here: the best performing one is uncommented, # the rest is commented out for your reference. #model.compile(optimizer='rmsprop', # loss='categorical_crossentropy', # metrics=['accuracy']) #model.compile( # optimizer=keras.optimizers.RMSprop(lr=0.0005), # loss='categorical_crossentropy', # metrics=['accuracy']) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) #model.compile(optimizer='adadelta', # loss='categorical_crossentropy', # metrics=['accuracy']) #opt = keras.optimizers.Adadelta(lr=1.0, # rho=0.95, epsilon=0.01, decay=0.01) #model.compile(optimizer=opt, # loss='categorical_crossentropy', # metrics=['accuracy']) #opt = keras.optimizers.RMSprop(lr=0.0005, # rho=0.9, epsilon=None, decay=0.0001) #model.compile(optimizer=opt, # loss='categorical_crossentropy', # metrics=['accuracy']) # model.summary() return(model) 

जब हम ट्रांसफर लर्निंग का उपयोग करके नेटवर्क बनाते हैं, तो प्रक्रिया बदल जाती है:

 def createModelMobileNetV2(): # First, create the NN and load pre-trained # weights for it ('imagenet') # Note that we are not loading last layers of # the network (include_top=False), as we are # going to add layers of our own: base_model = MobileNetV2(weights='imagenet', include_top=False, pooling='avg', input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) # Then attach our layers at the end. These are # to build "classifier" that makes sense of # the patterns previous layers provide: x = base_model.output x = Dense(512)(x) x = Activation('relu')(x) x = Dropout(0.5)(x) predictions = Dense(NUM_CLASSES, activation='softmax')(x) # Create a model model = Model(inputs=base_model.input, outputs=predictions) # We need to make sure that pre-trained # layers are not changed when we train # our classifier: # Either this: #model.layers[0].trainable = False # or that: for layer in base_model.layers: layer.trainable = False # As always, there are different possible # settings, I tried few and chose the best: # model.compile(optimizer='adam', # loss='categorical_crossentropy', # metrics=['accuracy']) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) #model.summary() return(model) 

अन्य प्रकार के नेटवर्क बनाना समान पैटर्न का अनुसरण करता है:

 def createModelResNet50(): base_model = ResNet50(weights='imagenet', include_top=False, pooling='avg', input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) x = base_model.output x = Dense(512)(x) x = Activation('relu')(x) x = Dropout(0.5)(x) predictions = Dense(NUM_CLASSES, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) #model.layers[0].trainable = False # model.compile(loss='categorical_crossentropy', # optimizer='adam', metrics=['accuracy']) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) #model.summary() return(model) 

चेतावनी: विजेता! इस एनएन ने सबसे अच्छा परिणाम दिखाया:

 def createModelInceptionV3(): # model.layers[0].trainable = False # model.compile(optimizer='sgd', # loss='categorical_crossentropy', # metrics=['accuracy']) base_model = InceptionV3(weights = 'imagenet', include_top = False, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) predictions = Dense(NUM_CLASSES, activation='softmax')(x) model = Model(inputs = base_model.input, outputs = predictions) for layer in base_model.layers: layer.trainable = False # model.compile(optimizer='adam', # loss='categorical_crossentropy', # metrics=['accuracy']) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) #model.summary() return(model) 

एक और एक:

 def createModelNASNetMobile(): # model.layers[0].trainable = False # model.compile(optimizer='sgd', # loss='categorical_crossentropy', # metrics=['accuracy']) base_model = NASNetMobile(weights = 'imagenet', include_top = False, input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3)) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(512, activation='relu')(x) predictions = Dense(NUM_CLASSES, activation='softmax')(x) model = Model(inputs = base_model.input, outputs = predictions) for layer in base_model.layers: layer.trainable = False # model.compile(optimizer='adam', # loss='categorical_crossentropy', # metrics=['accuracy']) model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy']) #model.summary() return(model) 

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

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

सबसे पहले, हम प्रयोग कर रहे हैं, इसलिए हमें उन तंत्रिका नेटवर्क को हटाने में सक्षम होना चाहिए जिन्हें हमने बचाया है, लेकिन अब उपयोग नहीं करते हैं। निम्न फ़ंक्शन मौजूद होने पर NN निकालता है:

 # Make sure that previous "best network" is deleted. def deleteSavedNet(best_weights_filepath): if(os.path.isfile(best_weights_filepath)): os.remove(best_weights_filepath) print("deleteSavedNet():File removed") else: print("deleteSavedNet():No file to remove") 

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

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

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

 deleteSavedNet(working_path + strModelFileName) #if not os.path.exists(working_path + "models"): # os.makedirs(working_path + "models") # #if not os.path.exists(working_path + # strModelFileName): # model = createModelResNet50() model = createModelInceptionV3() # model = createModelMobileNetV2() # model = createModelNASNetMobile() #else: # model = load_model(working_path + strModelFileName) 

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

 checkpoint = ModelCheckpoint(working_path + strModelFileName, monitor='val_acc', verbose=1, save_best_only=True, mode='auto', save_weights_only=False) callbacks_list = [ checkpoint ] 

अंत में, हम प्रशिक्षण सेट पर तंत्रिका नेटवर्क सिखाते हैं:

 # Calculate sizes of training and validation sets STEP_SIZE_TRAIN=train_gen.n//train_gen.batch_size STEP_SIZE_VALID=val_gen.n//val_gen.batch_size # Set to False if we are experimenting with # some other part of code, use history that # was calculated before (and is still in # memory bDoTraining = True if bDoTraining == True: # model.fit_generator does the actual training # Note the use of generators and callbacks # that were defined earlier history = model.fit_generator(generator=train_gen, steps_per_epoch=STEP_SIZE_TRAIN, validation_data=val_gen, validation_steps=STEP_SIZE_VALID, epochs=EPOCHS, callbacks=callbacks_list) # --- After fitting, load the best model # This is important as otherwise we'll # have the LAST model loaded, not necessarily # the best one. model.load_weights(working_path + strModelFileName) # --- Presentation part # summarize history for accuracy plt.plot(history.history['acc']) plt.plot(history.history['val_acc']) plt.title('model accuracy') plt.ylabel('accuracy') plt.xlabel('epoch') plt.legend(['acc', 'val_acc'], loc='upper left') plt.show() # summarize history for loss plt.plot(history.history['loss']) plt.plot(history.history['val_loss']) plt.title('model loss') plt.ylabel('loss') plt.xlabel('epoch') plt.legend(['loss', 'val_loss'], loc='upper left') plt.show() # As grid optimization of NN would take too long, # I did just few tests with different parameters. # Below I keep results, commented out, in the same # code. As you can see, Inception shows the best # results: # Inception: # adam: val_acc 0.79393 # sgd: val_acc 0.80892 # Mobile: # adam: val_acc 0.65290 # sgd: Epoch 00015: val_acc improved from 0.67584 to 0.68469 # sgd-30 epochs: 0.68 # NASNetMobile, adam: val_acc did not improve from 0.78335 # NASNetMobile, sgd: 0.8 

सटीकता और हानि के लिए सबसे अच्छे विन्यास के ग्राफ निम्नानुसार हैं:




जैसा कि आप देख सकते हैं, तंत्रिका नेटवर्क सीख रहा है, और बुरा नहीं है।

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

प्रशिक्षण पूरा होने के बाद, हमें परिणाम का परीक्षण करना चाहिए; इसके लिए, एनएन उन चित्रों को प्रस्तुत करता है जो उसने पहले कभी नहीं देखे थे - जिन्हें हमने परीक्षण फ़ोल्डर में कॉपी किया था - प्रत्येक कुत्ते की नस्ल के लिए।

 # --- Test j = 0 # Final cycle performs testing on the entire # testing set. for file_name in os.listdir( working_path + "test/"): img = image.load_img(working_path + "test/" + file_name); img_1 = image.img_to_array(img) img_1 = cv2.resize(img_1, (IMAGE_SIZE, IMAGE_SIZE), interpolation = cv2.INTER_AREA) img_1 = np.expand_dims(img_1, axis=0) / 255. y_pred = model.predict_on_batch(img_1) # get 5 best predictions y_pred_ids = y_pred[0].argsort()[-5:][::-1] print(file_name) for i in range(len(y_pred_ids)): print("\n\t" + map_characters[y_pred_ids[i]] + " (" + str(y_pred[0][y_pred_ids[i]]) + ")") print("--------------------\n") j = j + 1 

एक जावा अनुप्रयोग के लिए एक तंत्रिका नेटवर्क निर्यात करें

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

 # Test: load and run model = load_model(working_path + strModelFileName) 

उसी कारण से - कोड पर कूदने के लिए नहीं - मैं यहां निर्यात के लिए आवश्यक फाइलें शामिल करता हूं। कोई भी आपको कार्यक्रम की शुरुआत में उन्हें स्थानांतरित करने के लिए परेशान नहीं करता है अगर आपकी सुंदरता की आवश्यकता है:

 from keras.models import Model from keras.models import load_model from keras.layers import * import os import sys import tensorflow as tf 

एक तंत्रिका नेटवर्क को लोड करने के बाद एक छोटा परीक्षण, बस यह सुनिश्चित करने के लिए कि सब कुछ लोड किया गया है - कार्य:

 img = image.load_img(working_path + "test/affenpinscher.jpg") #basset.jpg") img_1 = image.img_to_array(img) img_1 = cv2.resize(img_1, (IMAGE_SIZE, IMAGE_SIZE), interpolation = cv2.INTER_AREA) img_1 = np.expand_dims(img_1, axis=0) / 255. y_pred = model.predict(img_1) Y_pred_classes = np.argmax(y_pred,axis = 1) # print(y_pred) fig, ax = plt.subplots() ax.imshow(img) ax.axis('off') ax.set_title(map_characters[Y_pred_classes[0]]) plt.show() 

अगला, हमें नेटवर्क के इनपुट और आउटपुट लेयर्स (या तो यह या निर्माण फ़ंक्शन) के नाम प्राप्त करने की आवश्यकता है, हमें स्पष्ट रूप से उन परतों को "नाम" देना होगा, जो हमने नहीं किया था)।

 model.summary() >>> Layer (type) >>> ====================== >>> input_7 (InputLayer) >>> ______________________ >>> conv2d_283 (Conv2D) >>> ______________________ >>> ... >>> dense_14 (Dense) >>> ====================== >>> Total params: 22,913,432 >>> Trainable params: 1,110,648 >>> Non-trainable params: 21,802,784 

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

इस डेटा को प्राप्त करने के लिए नेटवर्क पर रोमिंग कोड:

 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])) 

.

Keras Neural Network pb , , Android.

 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 from tensorflow.python.framework 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(working_path + strModelFileName) keras_to_tensorflow(model, output_dir=working_path + strModelFileName, model_name=working_path + "models/dogs.pb") print_graph_nodes(working_path + "models/dogs.pb") 

.

Android

Android . , , , ( ) .

, Android Studio . « », — . activity.



, «assets» (, ).

Gradle

. , tensorflow-android . , Tensorflow (, , Keras) Java:



: versionCode versionName . , Google Play. gdadle (, 1 -> 2 -> 3...) , « ».

, «» — 100 Mb Neural Network , instance «» Facebook .

instance :

 <activity android:name=".MainActivity" android:launchMode="singleTask"> 

android:launchMode=«singleTask» MainActivity, Android, () , , instance.

, , - «» :

 <intent-filter> <!-- Send action required to display activity in share list --> <action android:name="android.intent.action.SEND" /> <!-- Make activity default to launch --> <category android:name="android.intent.category.DEFAULT" /> <!-- Mime type ie what can be shared with this activity only image and text --> <data android:mimeType="image/*" /> </intent-filter> 

, , :

 <uses-feature android:name="android.hardware.camera" android:required="true" /> <uses-permission android:name= "android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_PHONE_STATE" tools:node="remove" /> 

Android, .

Layout .

layouts, , . Portrait layout .

: (view) , (, «»), «Help», File/Gallery , ( ) «Process» .



, enabling/disabling , .

MainActivity

activity (extends) Android Activity:

 public class MainActivity extends Activity 

, .

, Bitmap. , Bitmap ( ) (m_bitmap), , 256x256 (m_bitmapForNn). (256) :

 static Bitmap m_bitmap = null; static Bitmap m_bitmapForNn = null; private int m_nImageSize = 256; 

; (. ), , :

 private String INPUT_NAME = "input_7_1"; private String OUTPUT_NAME = "output_1"; 

TensofFlow. , ( assets):

private TensorFlowInferenceInterface tf;
private String MODEL_PATH = 
	"file:///android_asset/dogs.pb";

, , :

 private String[] m_arrBreedsArray; 

, Bitmap. , RGB , — , — , . , (, 120 , ):

 private float[] m_arrPrediction = new float[120]; private float[] m_arrInput = null; 

tensorflow inference library:

 static { System.loadLibrary("tensorflow_inference"); } 

, , , « », .

 class PredictionTask extends AsyncTask<Void, Void, Void> { @Override protected void onPreExecute() { super.onPreExecute(); } // --- @Override protected Void doInBackground(Void... params) { try { # We get RGB values packed in integers # from the Bitmap, then break those # integers into individual triplets m_arrInput = new float[ m_nImageSize * m_nImageSize * 3]; int[] intValues = new int[ m_nImageSize * m_nImageSize]; m_bitmapForNn.getPixels(intValues, 0, m_nImageSize, 0, 0, m_nImageSize, m_nImageSize); for (int i = 0; i < intValues.length; i++) { int val = intValues[i]; m_arrInput[i * 3 + 0] = ((val >> 16) & 0xFF) / 255f; m_arrInput[i * 3 + 1] = ((val >> 8) & 0xFF) / 255f; m_arrInput[i * 3 + 2] = (val & 0xFF) / 255f; } // --- tf = new TensorFlowInferenceInterface( getAssets(), MODEL_PATH); //Pass input into the tensorflow tf.feed(INPUT_NAME, m_arrInput, 1, m_nImageSize, m_nImageSize, 3); //compute predictions tf.run(new String[]{OUTPUT_NAME}, false); //copy output into PREDICTIONS array tf.fetch(OUTPUT_NAME, m_arrPrediction); } catch (Exception e) { e.getMessage(); } return null; } // --- @Override protected void onPostExecute(Void result) { super.onPostExecute(result); // --- enableControls(true); // --- tf = null; m_arrInput = null; # strResult contains 5 lines of text # with most probable dog breeds and # their probabilities m_strResult = ""; # What we do below is sorting the array # by probabilities (using map) # and getting in reverse order) the # first five entries TreeMap<Float, Integer> map = new TreeMap<Float, Integer>( Collections.reverseOrder()); for(int i = 0; i < m_arrPrediction.length; i++) map.put(m_arrPrediction[i], i); int i = 0; for (TreeMap.Entry<Float, Integer> pair : map.entrySet()) { float key = pair.getKey(); int idx = pair.getValue(); String strBreed = m_arrBreedsArray[idx]; m_strResult += strBreed + ": " + String.format("%.6f", key) + "\n"; i++; if (i > 5) break; } m_txtViewBreed.setVisibility(View.VISIBLE); m_txtViewBreed.setText(m_strResult); } } 

In onCreate() of the MainActivity, we need to add the onClickListener for the «Process» button:

 m_btn_process.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { processImage(); } }); 

processImage() , :

 private void processImage() { try { enableControls(false); // --- PredictionTask prediction_task = new PredictionTask(); prediction_task.execute(); } catch (Exception e) { e.printStackTrace(); } } 

UI- , . , .

instances , (flow of control): «» Facebook, , . , «» onCreate , onCreate .

:

1. onCreate MainActivity, onSharedIntent:

 protected void onCreate( Bundle savedInstanceState) { super.onCreate(savedInstanceState); .... onSharedIntent(); .... 

onNewIntent:

 @Override protected void onNewIntent(Intent intent) { super.onNewIntent(intent); setIntent(intent); onSharedIntent(); } 

onSharedIntent:

 private void onSharedIntent() { Intent receivedIntent = getIntent(); String receivedAction = receivedIntent.getAction(); String receivedType = receivedIntent.getType(); if (receivedAction.equals(Intent.ACTION_SEND)) { // If mime type is equal to image if (receivedType.startsWith("image/")) { m_txtViewBreed.setText(""); m_strResult = ""; Uri receivedUri = receivedIntent.getParcelableExtra( Intent.EXTRA_STREAM); if (receivedUri != null) { try { Bitmap bitmap = MediaStore.Images.Media.getBitmap( this.getContentResolver(), receivedUri); if(bitmap != null) { m_bitmap = bitmap; m_picView.setImageBitmap(m_bitmap); storeBitmap(); enableControls(true); } } catch (Exception e) { e.printStackTrace(); } } } } } 

onCreate ( ) onNewIntent ( ).




! , , «» , «» .