हम फ्लास्क का उपयोग REST API के रूप में ML प्रोजेक्ट को करते हैं और इसे फ़्लटर एप्लिकेशन के माध्यम से सुलभ बनाते हैं

परिचय

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

हम अपने आरएएसटी एपीआई के लिए फ्लास्क , मोबाइल एप्लिकेशन के लिए फ़्लटर और मशीन सीखने के लिए केर का उपयोग करेंगे। हम छवियों की सामग्री के बारे में जानकारी संग्रहीत करने के लिए एक डेटाबेस के रूप में MongoDB का उपयोग करते हैं, और जानकारी के लिए हम पहले से प्रशिक्षित ResNet50 मॉडल लेते हैं । यदि आवश्यक हो, तो हम केर में उपलब्ध save_model () और load_model () विधियों का उपयोग करके मॉडल को बदल सकते हैं। उत्तरार्द्ध को मॉडल के प्रारंभिक लोड होने पर लगभग 100 एमबी की आवश्यकता होगी। आप प्रलेखन में अन्य उपलब्ध मॉडल के बारे में पढ़ सकते हैं।

चलो फ्लास्क से शुरू करते हैं

यदि आप फ्लास्क से अपरिचित हैं, तो आप नियंत्रक के लिए केवल ऐप .route ('/') डेकोरेटर को जोड़कर उस पर एक मार्ग बना सकते हैं, जहाँ ऐप एप्लिकेशन वेरिएबल है। एक उदाहरण:

from flask import Flask app = Flask(__name__) @app.route('/') def hello_world(): return 'Hello, World!' 

जब आप शुरू करते हैं और डिफ़ॉल्ट पते पर जाते हैं 127.0.0.1 : 5000 / हम उत्तर देखेंगे हैलो वर्ल्ड! आप प्रलेखन में कुछ और जटिल करने के तरीके के बारे में पढ़ सकते हैं।

चलो एक पूर्ण बैकएंड बनाना शुरू करते हैं:

 import os import tensorflow as tf from tensorflow.keras.models import load_model from tensorflow.keras.preprocessing import image as img from keras.preprocessing.image import img_to_array import numpy as np from PIL import Image from keras.applications.resnet50 import ResNet50,decode_predictions,preprocess_input from datetime import datetime import io from flask import Flask,Blueprint,request,render_template,jsonify from modules.dataBase import collection as db 

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

 mod = Blueprint('backend', __name__, template_folder='templates', static_folder='./static') UPLOAD_URL = 'http://192.168.1.103:5000/static/' model = ResNet50(weights='imagenet') model._make_predict_function() 

पहली पंक्ति में हम एप्लिकेशन के अधिक सुविधाजनक संगठन के लिए एक खाका बनाते हैं। इस वजह से, आपको नियंत्रक को सजाने के लिए मॉड .route ('/') का उपयोग करना होगा। Resnet50 मॉडल, पूर्व- कल्पना पर प्रशिक्षित , को प्रारंभ करने के लिए _make_predict_function () को कॉल करने की आवश्यकता है। इस चरण के बिना, त्रुटि होने की संभावना है। और एक अन्य मॉडल का उपयोग लाइन को प्रतिस्थापित करके किया जा सकता है

 model = ResNet50(weights='imagenet') 

पर

 model = load_model('saved_model.h5') 

यहां कंट्रोलर कैसा दिखेगा:

 @mod.route('/predict', methods=['POST']) def predict(): if request.method == 'POST': # ,    if 'file' not in request.files: return "someting went wrong 1" user_file = request.files['file'] temp = request.files['file'] if user_file.filename == '': return "file name not found ..." else: path = os.path.join(os.getcwd()+'\\modules\\static\\'+user_file.filename) user_file.save(path) classes = identifyImage(path) db.addNewImage( user_file.filename, classes[0][0][1], str(classes[0][0][2]), datetime.now(), UPLOAD_URL+user_file.filename) return jsonify({ "status":"success", "prediction":classes[0][0][1], "confidence":str(classes[0][0][2]), "upload_time":datetime.now() }) 

ऊपर दिए गए कोड में, डाउनलोड की गई छवि को आइडेंटिफ़ैम (file_path) विधि से पारित किया गया है, जिसे निम्नानुसार लागू किया जाता है:

 def identifyImage(img_path): image = img.load_img(img_path, target_size=(224,224)) x = img_to_array(image) x = np.expand_dims(x, axis=0) # images = np.vstack([x]) x = preprocess_input(x) preds = model.predict(x) preds = decode_predictions(preds, top=1) print(preds) return preds 

सबसे पहले, हम छवि को 224 * 224 के आकार में परिवर्तित करते हैं, क्योंकि यह वह है जिसे हमारे मॉडल की जरूरत है। फिर हम मॉडल.प्रिक्टेड () प्री-प्रोसेस्ड इमेज बाइट्स को पास करते हैं। अब हमारा मॉडल यह अनुमान लगा सकता है कि छवि पर क्या है (एकल सबसे अधिक संभावित परिणाम प्राप्त करने के लिए शीर्ष = 1 की आवश्यकता है)।

Db.addData () फ़ंक्शन का उपयोग करके MongoDB में छवि सामग्री के बारे में प्राप्त डेटा को सहेजें। यहाँ कोड का प्रासंगिक टुकड़ा है:

 from pymongo import MongoClient from bson import ObjectId client = MongoClient("mongodb://localhost:27017") # host uri db = client.image_predition #Select the database image_details = db.imageData def addNewImage(i_name, prediction, conf, time, url): image_details.insert({ "file_name":i_name, "prediction":prediction, "confidence":conf, "upload_time":time, "url":url }) def getAllImages(): data = image_details.find() return data 

चूंकि हमने ब्लूप्रिंट का उपयोग किया था, इसलिए एपीआई के लिए कोड एक अलग फाइल में रखा जा सकता है:

 from flask import Flask,render_template,jsonify,Blueprint mod = Blueprint('api',__name__,template_folder='templates') from modules.dataBase import collection as db from bson.json_util import dumps @mod.route('/') def api(): return dumps(db.getAllImages()) 

जैसा कि आप देख सकते हैं, हम डेटाबेस डेटा को वापस करने के लिए json का उपयोग करते हैं। आप परिणाम 127.0.0.1 : 5000 / एपीआई पते पर देख सकते हैं

ऊपर, ज़ाहिर है, केवल कोड के सबसे महत्वपूर्ण टुकड़े हैं। पूरा प्रोजेक्ट गिटहब रिपॉजिटरी में देखा जा सकता है । और यहां पाइमंगो के बारे में और जानकारी मिल सकती है।

हम स्पंदन अनुप्रयोग बनाते हैं

मोबाइल संस्करण REST API के माध्यम से अपनी सामग्री पर चित्र और डेटा प्राप्त करेगा। यहाँ परिणाम है:

ImageData वर्ग छवि डेटा encapsulate:

 import 'dart:convert'; import 'package:http/http.dart' as http; import 'dart:async'; class ImageData { // static String BASE_URL ='http://192.168.1.103:5000/'; String uri; String prediction; ImageData(this.uri,this.prediction); } Future<List<ImageData>> LoadImages() async { List<ImageData> list; //complete fetch .... var data = await http.get('http://192.168.1.103:5000/api/'); var jsondata = json.decode(data.body); List<ImageData> newslist = []; for (var data in jsondata) { ImageData n = ImageData(data['url'],data['prediction']); newslist.add(n); } return newslist; } 

यहां हमें json मिलता है, इसे ImageData ऑब्जेक्ट्स की सूची में परिवर्तित करें , और लोडआईएमआई () फ़ंक्शन का उपयोग करके इसे फ्यूचर बिल्डर को लौटाएं

सर्वर पर चित्र अपलोड करना

 uploadImageToServer(File imageFile) async { print("attempting to connecto server......"); var stream = new http.ByteStream(DelegatingStream.typed(imageFile.openRead())); var length = await imageFile.length(); print(length); var uri = Uri.parse('http://192.168.1.103:5000/predict'); print("connection established."); var request = new http.MultipartRequest("POST", uri); var multipartFile = new http.MultipartFile('file', stream, length, filename: basename(imageFile.path)); //contentType: new MediaType('image', 'png')); request.files.add(multipartFile); var response = await request.send(); print(response.statusCode); } 

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

 app.run(debug=False, host='192.168.1.103', port=5000) 

कभी-कभी एक फ़ायरवॉल किसी एप्लिकेशन को लोकलहोस्ट को एक्सेस करने से रोक सकता है, फिर इसे फिर से कॉन्फ़िगर या अक्षम करना होगा।

सभी आवेदन स्रोत कोड github पर उपलब्ध है। यहां वे लिंक दिए गए हैं जो आपको यह समझने में मदद करेंगे कि क्या हो रहा है:

केरस: https://keras.io/

स्पंदन: https://flutter.dev/

MongoDB: https://www.tutorialspoint.com/mongodb/

हार्वर्ड पायथन और फ्लास्क कोर्स: https://www.youtube.com/watch?v=j5wysXqaIV8&t=5515s (व्याख्यान 2,3,4 विशेष रूप से महत्वपूर्ण हैं)

गिटहब: https://github.com/SHARONZACHARIA