डॉग ब्रीड आइडेंटिफ़ायर: केरस प्रोग्राम से एंड्रॉइड ऐप तक पूर्ण चक्र विकास। खेलने के बाजार पर

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

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

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

आप में से जो अंतिम परिणाम देखना चाहते हैं, उनके लिए यहां Google Play पर NeuroDog App का लिंक दिया गया है।

मेरे रोबोटिक्स के साथ वेब साइट: robotics.snowcron.com ।
के साथ वेब साइट: न्यूरोडॉग यूजर गाइड ।

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

एक अवलोकन

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

हम CNNs - कन्वेंशनल न्यूरल नेटवर्क्स का उपयोग करेंगे। CNNs (और उनके आधार पर अधिक उन्नत नेटवर्क) छवि मान्यता में वास्तविक मानक हैं। हालांकि, एक को ठीक से पढ़ाना एक दुर्जेय कार्य हो सकता है: नेटवर्क की संरचना, सीखने के पैरामीटर (उन सभी सीखने की दर, गति, L1 और L2 और इसी तरह) को सावधानी से समायोजित किया जाना चाहिए, और जैसा कि कार्य बहुत सारे कम्प्यूटेशनल संसाधनों को लेता है, हम बस सभी संभव संयोजनों की कोशिश नहीं कर सकते।

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

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

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

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

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

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

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

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

अंत में हमारे पास पूरी तरह से काम करने वाला "कमर्शियल" (उद्धरण में, क्योंकि यह बाज़ार-तैयार होने के बावजूद मुफ़्त है) Android NN- सशक्त अनुप्रयोग।

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

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

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

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

इस लेखन के क्षण में, इस लिंक से कोलाब तक पहुँचा जा सकता है, लेकिन यह बदल सकता है। बस Google को "Google Colab।"

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

कुछ हैं (इस लेखन के क्षण में - तीन) अलग-अलग दृष्टिकोण; हम उस चीज़ का उपयोग करने जा रहे हैं जो मेरा मानना ​​है कि सबसे अच्छा है: Google ड्राइव का उपयोग करना।

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

एनएन का निर्माण और प्रशिक्षण

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

प्रारंभ

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

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 ड्राइव में संग्रहीत की जाती हैं। बाद में हम उन्हें ट्रेन, वैध और परीक्षण फ़ोल्डर में कॉपी करने जा रहे हैं। हम सहेजने जा रहे हैं। मॉडल फ़ोल्डर में प्रशिक्षित मॉडल। लेबल.एससीवी फ़ाइल के लिए, यह एक डेटासेट का हिस्सा है, यह कुत्ते की नस्लों के लिए छवि फ़ाइलों को मैप करता है।

कई परीक्षण हैं जिनसे आप यह पता लगा सकते हैं कि यह आपके पास क्या है, आइए बस एक को चलाते हैं:

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

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

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

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

 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" 

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

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

 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> 

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

हम Keras की सुविधा का उपयोग करने जा रहे हैं जिसे 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) 

Attn: विजेता! इस NN ने सर्वोत्तम परिणामों का प्रदर्शन किया:

 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 ने हमें लॉग आउट किया, इसलिए हमें NN को फिर से लोड करने की आवश्यकता है: "हटाएं" भाग पर टिप्पणी करें और "लोड" भाग को अनइंस्टॉल करें।

 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 

विजेता NN के लिए सटीकता और हानि चार्ट हैं:




जैसा कि आप देख सकते हैं, नेटवर्क अच्छी तरह से सीखता है।

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

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

 # --- 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 

जावा को NN निर्यात करना

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

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

निर्यात NN बनाने के लिए इन कार्यों का उपयोग करें:

 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 एप्लिकेशन को NN निर्यात कर रहा है। अच्छी तरह से औपचारिक है और किसी भी कठिनाइयों का सामना नहीं करना चाहिए। हमेशा की तरह, इसे करने के एक से अधिक तरीके हैं; हम सबसे लोकप्रिय (कम से कम, इस समय) का उपयोग करने जा रहे हैं।

सबसे पहले, एक नया प्रोजेक्ट बनाने के लिए एंड्रॉइड स्टूडियो का उपयोग करें। हम कोनों को थोड़ा काटने जा रहे हैं, इसलिए इसमें केवल एक ही गतिविधि होगी।



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

ग्रेड फ़ाइल

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



अतिरिक्त "हार्ड टू फाइंड " डिटेल के रूप में, वर्जन नोट करें: वर्जनकोड और वर्जननाम । जैसे ही आप अपने ऐप पर काम करते हैं, आपको Google Play पर नए संस्करण अपलोड करने होंगे। संस्करणों को अपडेट किए बिना (जैसे 1 -> 2 -> 3 ...) आप इसे करने में सक्षम नहीं होंगे।

प्रकट

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

इसलिए हम यह सुनिश्चित करने जा रहे हैं कि हमारे ऐप का केवल एक उदाहरण है:

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

Android जोड़कर : लॉन्चमैड = "सिंगलटैस्क" को मेनऐक्टिविटी के लिए, हम एंड्रॉइड को एक मौजूदा ऐप खोलने के लिए कहते हैं, बजाय एक और उदाहरण लॉन्च करने के।

फिर हम अपने ऐप को सुनिश्चित करते हैं। साझा किए गए चित्रों को संभालने में सक्षम अनुप्रयोगों की एक सूची में दिखाता है:

 <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 गतिविधि का विस्तार करती है:

 public class MainActivity extends Activity 

आइए एनएन संचालन के लिए कोड रिस्पॉन्सिबल पर एक नज़र डालें।

सबसे पहले, एनएन एक बिटमैप को स्वीकार करता है। मूल रूप से यह फ़ाइल या कैमरा (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 ऑब्जेक्ट को रखने के लिए वैरिएबल की घोषणा करते हैं। इसके अलावा, हम संपत्ति में एनएन फ़ाइल का पथ संग्रहीत करते हैं:

 निजी TensorFlowInferenceInterface tf;
 निजी स्ट्रिंग MODEL_PATH = 
	 "फाइल: ///android_asset/dogs.pb";

कुत्तों की नस्ल, उपयोगकर्ता को एक सार्थक जानकारी के साथ प्रस्तुत करने के लिए, सरणी में अनुक्रमित के बजाय:

 private String[] m_arrBreedsArray; 

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

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

टेंसोफ़्लो इंफ़ेक्शन लाइब्रेरी लोड करें

 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); } } 

MainActivity के ऑनक्रिएट () में, हमें "प्रोसेस" फाइल के लिए onClickListener को जोड़ना होगा:

 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 से संबंधित कोड पर चर्चा नहीं करने जा रहे हैं, क्योंकि यह तुच्छ है और निश्चित रूप से "NN पोर्टिंग" कार्य का हिस्सा नहीं है। हालांकि, कुछ चीजें हैं जिन्हें स्पष्ट किया जाना चाहिए।

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

यहाँ स्थिति को संभालने का एक तरीका दिया गया है:

1. मेनऐक्टिविटी के onCreate में, ऑनशेयरडेंट फ़ंक्शन को कॉल करें:

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

इसके अलावा, चालू के लिए एक हैंडलर जोड़ें:

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

OnSaredIntent फ़ंक्शन ही:

 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 से यदि कोई उदाहरण स्मृति में पाया गया था।




अ छा! यदि आप इस लेख को पसंद करते हैं, तो कृपया इसे सामाजिक नेटवर्क में "पसंद" करें, साथ ही किसी साइट पर सामाजिक बटन भी हैं ।