😉 📎 🚏 फ्लास्क का उपयोग करके एपीआई के रूप में उत्पादन वातावरण में मशीन लर्निंग मॉडल को तैनात करने के लिए गाइड 👩‍👩‍👦 💙 🤷

दोस्तों, मार्च के अंत में हम "डेटा साइंटिस्ट" पाठ्यक्रम पर एक नई स्ट्रीम शुरू कर रहे हैं। और अभी, हम आपके साथ पाठ्यक्रम पर उपयोगी सामग्री साझा करना शुरू कर रहे हैं।

परिचय

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

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

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

सामग्री

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

मशीन सीखने के मॉडल के लिए कार्यान्वयन विकल्प।

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

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

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

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

एपीआई क्या है?

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

आप अपने दम पर लेखों के एक जोड़े को पढ़ने में सक्षम होंगे, जो अच्छी तरह से वर्णन करता है कि एपीआई डेवलपर्स के बीच काफी लोकप्रिय विकल्प क्यों है।

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

उदाहरण के लिए, इन API प्रदाताओं में से एक Google अपने Google विज़न API के साथ है ।

सभी डेवलपर को बस Google द्वारा प्रदत्त एसडीके का उपयोग करके आरईएसटी (प्रतिनिधि राज्य स्थानांतरण) एपीआई कॉल करना होगा। देखें कि आप Google विज़न एपीआई का उपयोग करके क्या कर सकते हैं।

बहुत अच्छा लगता है, है ना? इस लेख में, हम यह पता लगाएंगे कि फ्लास्क, पायथन फ्रेमवर्क का उपयोग करके अपना स्वयं का एपीआई कैसे बनाया जाए।

नोट : फ्लास्क इस उद्देश्य के लिए केवल नेटवर्क फ्रेमवर्क नहीं है। Django, फाल्कन, हग और कई अन्य भी हैं जिनका इस लेख में उल्लेख नहीं किया गया है। उदाहरण के लिए, आर के लिए एक पैकेज है जिसे प्लम्बर कहा जाता है

पायथन पर्यावरण को स्थापित करना और फ्लास्क के बारे में बुनियादी जानकारी।

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

यहां आपको पायथन के लिए मिनीकोन्डा इंस्टॉलर मिलेगा;
wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh
प्रश्नों के क्रम का पालन करें।
source .bashrc
यदि आप टाइप करते हैं: conda , आप उपलब्ध आदेशों की एक सूची देख सकते हैं और मदद कर सकते हैं।
एक नया वातावरण बनाने के लिए, टाइप करें: conda create --name <environment-name> python=3.6
उन चरणों का पालन करें जो आपको करने के लिए कहा जाएगा और अंत में दर्ज करें: source activate <environment-name>
आवश्यक पायथन पैकेज स्थापित करें। सबसे महत्वपूर्ण हैं कुप्पी और अंगरखा।

2) हम अपने साधारण "हेलो वर्ल्ड" फ्लास्क एप्लीकेशन का उपयोग करने का प्रयास करेंगे ।

अपना पसंदीदा टेक्स्ट एडिटर खोलें और फ़ोल्डर में hello-world.py फ़ाइल बनाएँ
निम्नलिखित कोड लिखें:

 """Filename: hello-world.py """ from flask import Flask app = Flask(__name__) @app.route('/users/<string:username>') def hello_world(username=None): return("Hello {}!".format(username))

फ़ाइल सहेजें और टर्मिनल पर लौटें।
एपीआई लॉन्च करने के लिए टर्मिनल में gunicorn --bind 0.0.0.0:8000 hello-world:app : gunicorn --bind 0.0.0.0:8000 hello-world:app
यदि आपको निम्नलिखित मिलता है, तो आप सही रास्ते पर हैं:

ब्राउज़र में, निम्न दर्ज करें: https://localhost:8000/users/any-name

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

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

मशीन लर्निंग मॉडल बनाना।

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

 import os import json import numpy as np import pandas as pd from sklearn.externals import joblib from sklearn.model_selection import train_test_split, GridSearchCV from sklearn.base import BaseEstimator, TransformerMixin from sklearn.ensemble import RandomForestClassifier from sklearn.pipeline import make_pipeline import warnings warnings.filterwarnings("ignore")

डेटासेट को फ़ोल्डर में सहेजें:

 !ls /home/pratos/Side-Project/av_articles/flask_api/data/

 test.csv training.csv

 data = pd.read_csv('../data/training.csv')

 list(data.columns)

 ['Loan_ID', 'Gender', 'Married', 'Dependents', 'Education', 'Self_Employed', 'ApplicantIncome', 'CoapplicantIncome', 'LoanAmount', 'Loan_Amount_Term', 'Credit_History', 'Property_Area', 'Loan_Status']

 data.shape

 (614, 13)

ul>
स्तंभों में शून्य / नैन मान खोजें:

 for _ in data.columns: print("The number of null values in:{} == {}".format(_, data[_].isnull().sum()))

 The number of null values in:Loan_ID == 0 The number of null values in:Gender == 13 The number of null values in:Married == 3 The number of null values in:Dependents == 15 The number of null values in:Education == 0 The number of null values in:Self_Employed == 32 The number of null values in:ApplicantIncome == 0 The number of null values in:CoapplicantIncome == 0 The number of null values in:LoanAmount == 22 The number of null values in:Loan_Amount_Term == 14 The number of null values in:Credit_History == 50 The number of null values in:Property_Area == 0 The number of null values in:Loan_Status == 0

अगला कदम प्रशिक्षण और परीक्षण के लिए डेटासेट बनाना है:

 red_var = ['Gender','Married','Dependents','Education','Self_Employed','ApplicantIncome','CoapplicantIncome',\ 'LoanAmount','Loan_Amount_Term','Credit_History','Property_Area'] X_train, X_test, y_train, y_test = train_test_split(data[pred_var], data['Loan_Status'], \ test_size=0.25, random_state=42)

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

यह समझने के लिए कि हमने इसे कैसे बनाया है, निम्नलिखित पढ़ें।

 from sklearn.base import BaseEstimator, TransformerMixin class PreProcessing(BaseEstimator, TransformerMixin): """Custom Pre-Processing estimator for our use-case """ def __init__(self): pass def transform(self, df): """Regular transform() that is a help for training, validation & testing datasets (NOTE: The operations performed here are the ones that we did prior to this cell) """ pred_var = ['Gender','Married','Dependents','Education','Self_Employed','ApplicantIncome',\ 'CoapplicantIncome','LoanAmount','Loan_Amount_Term','Credit_History','Property_Area'] df = df[pred_var] df['Dependents'] = df['Dependents'].fillna(0) df['Self_Employed'] = df['Self_Employed'].fillna('No') df['Loan_Amount_Term'] = df['Loan_Amount_Term'].fillna(self.term_mean_) df['Credit_History'] = df['Credit_History'].fillna(1) df['Married'] = df['Married'].fillna('No') df['Gender'] = df['Gender'].fillna('Male') df['LoanAmount'] = df['LoanAmount'].fillna(self.amt_mean_) gender_values = {'Female' : 0, 'Male' : 1} married_values = {'No' : 0, 'Yes' : 1} education_values = {'Graduate' : 0, 'Not Graduate' : 1} employed_values = {'No' : 0, 'Yes' : 1} property_values = {'Rural' : 0, 'Urban' : 1, 'Semiurban' : 2} dependent_values = {'3+': 3, '0': 0, '2': 2, '1': 1} df.replace({'Gender': gender_values, 'Married': married_values, 'Education': education_values, \ 'Self_Employed': employed_values, 'Property_Area': property_values, \ 'Dependents': dependent_values}, inplace=True) return df.as_matrix() def fit(self, df, y=None, **fit_params): """Fitting the Training dataset & calculating the required values from train eg: We will need the mean of X_train['Loan_Amount_Term'] that will be used in transformation of X_test """ self.term_mean_ = df['Loan_Amount_Term'].mean() self.amt_mean_ = df['LoanAmount'].mean() return self

y_train और y_test को np.array :

 y_train = y_train.replace({'Y':1, 'N':0}).as_matrix() y_test = y_test.replace({'Y':1, 'N':0}).as_matrix()

आइए हम यह सुनिश्चित करने के लिए एक पाइपलाइन बनाएं कि हम जो भी पूर्व-प्रक्रिया वाले कदम उठाते हैं, वह स्किटिट-लर्न मूल्यांकनकर्ता का काम है।

 pipe = make_pipeline(PreProcessing(), RandomForestClassifier())

 pipe

 Pipeline(memory=None, steps=[('preprocessing', PreProcessing()), ('randomforestclassifier', RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1, oob_score=False, random_state=None, verbose=0, warm_start=False))])

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

Param_grid को परिभाषित करें:

 param_grid = {"randomforestclassifier__n_estimators" : [10, 20, 30], "randomforestclassifier__max_depth" : [None, 6, 8, 10], "randomforestclassifier__max_leaf_nodes": [None, 5, 10, 20], "randomforestclassifier__min_impurity_split": [0.1, 0.2, 0.3]}

ग्रिड खोज शुरू करता है:

 grid = GridSearchCV(pipe, param_grid=param_grid, cv=3)

हम पाइपलाइन अनुमानक के लिए प्रशिक्षण डेटा को समायोजित करते हैं:

 grid.fit(X_train, y_train)

 GridSearchCV(cv=3, error_score='raise', estimator=Pipeline(memory=None, steps=[('preprocessing', PreProcessing()), ('randomforestclassifier', RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impu..._jobs=1, oob_score=False, random_state=None, verbose=0, warm_start=False))]), fit_params=None, iid=True, n_jobs=1, param_grid={'randomforestclassifier__n_estimators': [10, 20, 30], 'randomforestclassifier__max_leaf_nodes': [None, 5, 10, 20], 'randomforestclassifier__min_impurity_split': [0.1, 0.2, 0.3], 'randomforestclassifier__max_depth': [None, 6, 8, 10]}, pre_dispatch='2*n_jobs', refit=True, return_train_score=True, scoring=None, verbose=0)

आइए देखें कि ग्रिड पर खोज का कौन सा पैरामीटर चुना गया है:

 print("Best parameters: {}".format(grid.best_params_))

 Best parameters: {'randomforestclassifier__n_estimators': 30, 'randomforestclassifier__max_leaf_nodes': 20, 'randomforestclassifier__min_impurity_split': 0.2, 'randomforestclassifier__max_depth': 8}

हम गणना:

 print("Validation set score: {:.2f}".format(grid.score(X_test, y_test)))

 Validation set score: 0.79

परीक्षण सूट डाउनलोड करें:

 test_df = pd.read_csv('../data/test.csv', encoding="utf-8-sig") test_df = test_df.head()

 grid.predict(test_df)

 array([1, 1, 1, 1, 1])

अगले महत्वपूर्ण कदम पर आगे बढ़ने के लिए हमारी पाइपलाइन अच्छी लगती है: मशीन लर्निंग मॉडल को सीरियल करना।

सेविंग मशीन लर्निंग मॉडल: सीरियलाइज़ेशन एंड डिसेरिएलाइज़ेशन।

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

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

 list_to_pickle = [1, 'here', 123, 'walker'] #Pickling the list import pickle list_pickle = pickle.dumps(list_to_pickle)

 list_pickle

 b'\x80\x03]q\x00(K\x01X\x04\x00\x00\x00hereq\x01K{X\x06\x00\x00\x00walkerq\x02e.'

फिर हम डिब्बाबंद वस्तु को फिर से उतारते हैं:

 loaded_pickle = pickle.loads(list_pickle)

 loaded_pickle

 [1, 'here', 123, 'walker']

हम डिब्बाबंद वस्तुओं को एक फ़ाइल में सहेज सकते हैं और उनका उपयोग कर सकते हैं। यह विधि .rda फ़ाइलों को बनाने के समान है, उदाहरण के लिए, आर प्रोग्रामिंग में।

नोट: कुछ इस तरह के संरक्षण के लिए परिरक्षण विधि पसंद नहीं कर सकते। एक विकल्प h5py हो सकता है।

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

मॉडल के प्रशिक्षण के लिए सभी कोड वाली एक अलग training.py फ़ाइल बनाना उचित है। (एक उदाहरण यहां देखा जा सकता है )।

dill स्थापित करें

 !pip install dill

 Requirement already satisfied: dill in /home/pratos/miniconda3/envs/ordermanagement/lib/python3.5/site-packages

 import dill as pickle filename = 'model_v1.pk'

 with open('../flask_api/models/'+filename, 'wb') as file: pickle.dump(grid, file)

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

 with open('../flask_api/models/'+filename ,'rb') as f: loaded_model = pickle.load(f)

 loaded_model.predict(test_df)

 array([1, 1, 1, 1, 1])

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

फ्लास्क का उपयोग करके एक एपीआई बनाना

चलो फ़ोल्डर संरचना को यथासंभव सरल रखें:

apicall() फ़ंक्शन के लिए एक आवरण बनाने के लिए तीन महत्वपूर्ण भाग हैं:

request डेटा प्राप्त करना (जिसके लिए एक पूर्वानुमान बनाया जाएगा);
डिब्बाबंद मूल्यांकक लोड हो रहा है;
JSON प्रारूप में हमारे पूर्वानुमान का अनुवाद और एक प्रतिक्रिया status code: 200 प्राप्त करना status code: 200 ;

HTTP संदेश हेडर और बॉडी से बनाए जाते हैं। सामान्य तौर पर, मुख्य निकाय सामग्री JSON प्रारूप में प्रसारित की जाती है। हम पूर्वानुमान प्राप्त करने के लिए पैकेज के रूप में आने वाले डेटा ( POST url-endpoint/ ) भेजेंगे।

नोट: आप प्रारूप के विनिमेयता के लिए सीधे सादे पाठ, XML, cvs या एक चित्र भेज सकते हैं, हालांकि हमारे मामले में JSON का उपयोग करना बेहतर है।

 """Filename: server.py """ import os import pandas as pd from sklearn.externals import joblib from flask import Flask, jsonify, request app = Flask(__name__) @app.route('/predict', methods=['POST']) def apicall(): """API Call Pandas dataframe (sent as a payload) from API Call """ try: test_json = request.get_json() test = pd.read_json(test_json, orient='records') #To resolve the issue of TypeError: Cannot compare types 'ndarray(dtype=int64)' and 'str' test['Dependents'] = [str(x) for x in list(test['Dependents'])] #Getting the Loan_IDs separated out loan_ids = test['Loan_ID'] except Exception as e: raise e clf = 'model_v1.pk' if test.empty: return(bad_request()) else: #Load the saved model print("Loading the model...") loaded_model = None with open('./models/'+clf,'rb') as f: loaded_model = pickle.load(f) print("The model has been loaded...doing predictions now...") predictions = loaded_model.predict(test) """Add the predictions as Series to a new pandas dataframe OR Depending on the use-case, the entire test data appended with the new files """ prediction_series = list(pd.Series(predictions)) final_predictions = pd.DataFrame(list(zip(loan_ids, prediction_series))) """We can be as creative in sending the responses. But we need to send the response codes as well. """ responses = jsonify(predictions=final_predictions.to_json(orient="records")) responses.status_code = 200 return (responses)

निष्पादन के बाद, दर्ज करें: gunicorn --bind 0.0.0.0:8000 server:app
आइए https:0.0.0.0:8000/predict पर स्थानीय रूप से एपीआई चलाने के लिए पूर्वानुमान और एक कतार के लिए डेटा उत्पन्न करें

 import json import requests

 """Setting the headers to send and accept json responses """ header = {'Content-Type': 'application/json', \ 'Accept': 'application/json'} """Reading test batch """ df = pd.read_csv('../data/test.csv', encoding="utf-8-sig") df = df.head() """Converting Pandas Dataframe to json """ data = df.to_json(orient='records')

 data

 '[{"Loan_ID":"LP001015","Gender":"Male","Married":"Yes","Dependents":"0","Education":"Graduate","Self_Employed":"No","ApplicantIncome":5720,"CoapplicantIncome":0,"LoanAmount":110.0,"Loan_Amount_Term":360.0,"Credit_History":1.0,"Property_Area":"Urban"},{"Loan_ID":"LP001022","Gender":"Male","Married":"Yes","Dependents":"1","Education":"Graduate","Self_Employed":"No","ApplicantIncome":3076,"CoapplicantIncome":1500,"LoanAmount":126.0,"Loan_Amount_Term":360.0,"Credit_History":1.0,"Property_Area":"Urban"},{"Loan_ID":"LP001031","Gender":"Male","Married":"Yes","Dependents":"2","Education":"Graduate","Self_Employed":"No","ApplicantIncome":5000,"CoapplicantIncome":1800,"LoanAmount":208.0,"Loan_Amount_Term":360.0,"Credit_History":1.0,"Property_Area":"Urban"},{"Loan_ID":"LP001035","Gender":"Male","Married":"Yes","Dependents":"2","Education":"Graduate","Self_Employed":"No","ApplicantIncome":2340,"CoapplicantIncome":2546,"LoanAmount":100.0,"Loan_Amount_Term":360.0,"Credit_History":null,"Property_Area":"Urban"},{"Loan_ID":"LP001051","Gender":"Male","Married":"No","Dependents":"0","Education":"Not Graduate","Self_Employed":"No","ApplicantIncome":3276,"CoapplicantIncome":0,"LoanAmount":78.0,"Loan_Amount_Term":360.0,"Credit_History":1.0,"Property_Area":"Urban"}]'

 """POST <url>/predict """ resp = requests.post("http://0.0.0.0:8000/predict", \ data = json.dumps(data),\ headers= header)

 resp.status_code

 """The final response we get is as follows: """ resp.json()

 {'predictions': '[{"0":"LP001015","1":1},{...

निष्कर्ष

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

एपीआई बनाते समय कुछ बातों का ध्यान रखना चाहिए:

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

अगला तार्किक कदम इस तरह के एपीआई को एक छोटी आभासी मशीन पर तैनात करने के लिए यांत्रिकी बनाना है। ऐसा करने के लिए विभिन्न तरीके हैं, लेकिन हम उन्हें अगले लेख में कवर करेंगे।

इस लेख के लिए कोड और स्पष्टीकरण

उपयोगी स्रोत:

[१] अपना डेटा न चुनें।
[२] बिल्डिंग स्किटिट संगत ट्रांसफार्मर सीखें ।
[३] फ्लास्क में jsonify का उपयोग करना ।
[४] फ्लास्क-क्विकस्टार्ट।

यहाँ ऐसी सामग्री है। प्रकाशन पसंद आया तो हमें सब्सक्राइब करें, और विषय पर एक मुफ्त ओपन वेबिनार के लिए साइन अप करें: "मैट्रिक वर्गीकरण एल्गोरिदम", जो डेवलपर और डेटा वैज्ञानिक द्वारा 12 मार्च को 5 साल के अनुभव के साथ आयोजित किया जाएगा - अलेक्जेंडर निकितिन ।

फ्लास्क का उपयोग करके एपीआई के रूप में उत्पादन वातावरण में मशीन लर्निंग मॉडल को तैनात करने के लिए गाइड

More articles: