Python में Machine Learning मॉडलों को APIs में बदलना

Flask – Python में वेब सर्विसेज़ का फ्रेमवर्क:

अब, आप सोच सकते हैं कि वेब सर्विस क्या है? वेब सर्विस भी API का ही एक रूप है, जो यह मानती है कि API किसी सर्वर पर होस्टेड है और उसे कंज्यूम किया जा सकता है। Web API, Web Service - ये शब्द आम तौर पर एक-दूसरे के स्थान पर उपयोग किए जाते हैं।

Flask की बात करें तो यह Python में वेब सर्विस डेवलपमेंट का एक फ्रेमवर्क है। Python में यह अकेला नहीं है, कुछ और भी हैं जैसे Django, Falcon, Hug, आदि। लेकिन आप इस ट्यूटोरियल के लिए Flask का उपयोग करेंगे। Flask के बारे में सीखने के लिए आप इन ट्यूटोरियल्स को देख सकते हैं।

यदि आपने Anaconda डिस्ट्रीब्यूशन डाउनलोड किया है, तो आपके पास पहले से ही Flask इंस्टॉल होगा। अन्यथा, आपको इसे खुद इंस्टॉल करना होगा:

pip install flask

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

निम्नलिखित कोड Flask की न्यूनतमतावादिता को अच्छी तरह दर्शाता है। यह कोड एक सरल Web-API बनाता है जो किसी विशेष URL को प्राप्त होने पर एक विशिष्ट आउटपुट देता है।

from flask import Flask

app = Flask(__name__)


@app.route("")
def hello():
    return "Welcome to machine learning model APIs!"


if __name__ == '__main__':
    app.run(debug=True)

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

कुछ बिंदु:

• Jupyter Notebooks मार्कडाउन, R और Python से जुड़ी चीज़ों के लिए बेहतरीन हैं। लेकिन जब वेब सर्वर बनाने की बात आती है, तो यह असंगत व्यवहार दिखा सकता है। इसलिए, Flask का कोड किसी टेक्स्ट एडिटर जैसे Sublime में लिखना और टर्मिनल/कमांड प्रॉम्प्ट से चलाना बेहतर विचार है।

• सुनिश्चित करें कि आप फ़ाइल का नाम flask.py न रखें।

• Flask डिफ़ॉल्ट रूप से पोर्ट 5000 पर चलता है। कभी-कभी Flask सर्वर इस पोर्ट पर सफलतापूर्वक शुरू हो जाता है, लेकिन जब आप वेब ब्राउज़र या किसी API-क्लाइंट जैसे Postman में URL (जो सर्वर टर्मिनल पर लौटाता है) हिट करते हैं, तो आउटपुट नहीं मिलता। निम्न स्थिति पर विचार करें:

• Flask के अनुसार, इसका सर्वर पोर्ट 5000 पर सफलतापूर्वक शुरू हो गया है, लेकिन जब ब्राउज़र में URL फायर किया गया, तो कुछ नहीं लौटा। यह पोर्ट नंबर कॉन्फ्लिक्ट का संभावित मामला हो सकता है। इस स्थिति में, डिफ़ॉल्ट पोर्ट 5000 को बदलकर अपने इच्छित पोर्ट नंबर पर करना अच्छा विकल्प होगा। आप ऐसा इस तरह कर सकते हैं:

  app.run(debug=True,port=12345)

• उस स्थिति में, Flask सर्वर कुछ इस तरह दिखेगा:

अब, उस कोड को चरण दर चरण समझते हैं जो आपने लिखा:

• आपने Flask क्लास का एक इंस्टांस बनाया और उसमें "name" वेरिएबल पास किया (जिसे Python स्वयं भरता है)। यदि इस फ़ाइल को सीधे Python से स्क्रिप्ट की तरह चलाया जा रहा है, तो यह वेरिएबल "main" होगा। यदि आपने फ़ाइल को इम्पोर्ट किया है, तो "name" का मान उस फ़ाइल का नाम होगा जिसे आपने इम्पोर्ट किया है। उदाहरण के लिए, यदि आपके पास test.py और run.py हैं, और आपने test.py को run.py में इम्पोर्ट किया तो test.py का "name" मान test होगा (app = Flask(test))।

• hello() मेथड की परिभाषा के ऊपर @app.route("") है। route() एक डेकोरेटर है जो Flask को बताता है कि कौन सा URL hello() के रूप में परिभाषित फ़ंक्शन को ट्रिगर करेगा।

• hello() मेथड आउटपुट (Welcome to machine learning model APIs!) उत्पन्न करने के लिए ज़िम्मेदार है जब भी आपकी API सही से हिट (या कंज्यूम) की जाती है। इस मामले में, वेब-ब्राउज़र में localhost:5000/ हिट करने पर इच्छित आउटपुट मिलेगा (बशर्ते flask सर्वर पोर्ट 5000 पर चल रहा हो)।

अब आप उन कारकों का अध्ययन करेंगे जिन्हें आपको ध्यान में रखना होगा यदि आप अपने (scikit-learn का उपयोग करके बनाए गए) मशीन लर्निंग मॉडल्स को Flask API में बदल रहे हैं।

Flask के साथ Scikit-learn मॉडल्स

scikit-learn के साथ Python में बहुत सरल से बहुत जटिल मशीन लर्निंग मॉडल बनाना पहले कभी इतना आसान नहीं था। लेकिन scikit-learn के बारे में कुछ बातें आपको याद रखनी होंगी:

• Scikit-learn एक Python लाइब्रेरी है जो डेटा माइनिंग और डेटा एनालिसिस के लिए सरल और कुशल टूल्स प्रदान करती है। Scikit-learn के प्रमुख मॉड्यूल निम्न हैं:
  • क्लस्टरिंग
  • रिग्रेशन
  • क्लासिफिकेशन
  • डायमेंशनलिटी रिडक्शन
  • मॉडल सेलेक्शन
  • प्रीप्रोसेसिंग

(DataCamp का Supervised Learning with scikit-learn कोर्स ज़रूर देखें जिसे scikit-learn के कोर डेवलपर Andreas Müller पढ़ाते हैं)

• Scikit-learn उन मॉडलों के सीरियलाइज़ेशन और डी-सीरियलाइज़ेशन का सपोर्ट देता है जिनको आप scikit-learn से ट्रेन करते हैं। इससे मॉडल को दोबारा ट्रेन करने का समय बचता है। scikit-learn से बनाए गए अपने मॉडल की एक serialized कॉपी के साथ आप Flask API लिख सकते हैं।
  
  
• Scikit-learn मॉडल्स को डेटा न्यूमेरिक फॉर्मैट में चाहिए। इसलिए, यदि डेटासेट में नॉन-न्यूमेरिक कैटेगोरिकल फीचर्स हैं, तो उन्हें न्यूमेरिक में बदलना ज़रूरी है। इस ट्रांसफॉर्मेशन के लिए scikit-learn LabelEncoder, OneHotEncoder जैसी यूटिलिटीज़ प्रदान करता है। ये sklearn.preprocessing मॉड्यूल में मिलती हैं।
  
  
• Scikit-learn मॉडल्स मिसिंग वैल्यूज़ को अपने आप हैंडल नहीं कर सकते। आपको अपने डेटासेट में मिसिंग वैल्यूज़ को खुद हैंडल करना होगा, और फिर आप उसे अपने मॉडल में फीड कर सकते हैं। मिसिंग वैल्यूज़ को हैंडल करने के लिए scikit-learn की कई यूटिलिटीज़ sklearn.preprocessing मॉड्यूल में मिलती हैं।

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

• Preprocessing for Machine Learning in Python

इस ट्यूटोरियल के लिए, आप Titanic डेटासेट का उपयोग करेंगे जो कई कारणों से सबसे लोकप्रिय डेटासेट में से एक है - जैसे इसमें विभिन्न प्रकार के वेरिएबल्स हैं, और इसमें मिसिंग वैल्यूज़ भी हैं, आदि। यह DataCamp ट्यूटोरियल इस डेटासेट का उत्कृष्ट विश्लेषण कवर करता है, और डेटासेट यहाँ से डाउनलोड किया जा सकता है।

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

नोट: Variables और Features शब्दों का इस ट्यूटोरियल में कई जगह एक-दूसरे के स्थान पर उपयोग किया गया है।

चीज़ों को और सरल बनाने के लिए, आप केवल चार वेरिएबल्स का उपयोग करेंगे: age, sex, embarked, और survived जहाँ survived क्लास लेबल है।

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

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

Scikit-learn उन सेल वैल्यूज़ को NaN मानता है जिनमें कुछ नहीं होता। यहाँ, आप केवल NaN को 0 से बदल देंगे, और इसके लिए एक हेल्पर फ़ंक्शन लिखेंगे।

categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

ऊपर दिए गए कोड की पंक्तियाँ निम्न कार्य करती हैं:

• डेटाफ्रेम df की सभी कॉलम्स पर इटरेट करती हैं और (नॉन-न्यूमेरिक मानों वाली) कॉलम्स को सूची categorical में जोड़ती हैं।

• यदि कॉलम्स में नॉन-न्यूमेरिक मान नहीं हैं (जो इस मामले में केवल Age है), तो यह जाँचता है कि उसमें मिसिंग वैल्यूज़ हैं या नहीं और उन्हें 0 से भरता है।

  NaNs को एक ही वैल्यू से भरना अनपेक्षित परिणाम दे सकता है, खासकर यदि वह मात्रा, जिससे आप NaNs को बदल रहे हैं, न्यूमेरिक वेरिएबल के ऑब्ज़र्व्ड रेंज के भीतर हो। चूँकि शून्य उम्र का न तो ऑब्ज़र्व्ड और न वैध मान है, आप पूर्वाग्रह नहीं ला रहे, जैसा कि आप 36 का उपयोग करते तो लाते! - स्रोत

अब जब आपने मिसिंग वैल्यूज़ को हैंडल कर लिया और नॉन-न्यूमेरिक कॉलम्स को अलग कर लिया है, आप उन्हें न्यूमेरिक में बदलने के लिए तैयार हैं। आप यह One Hot Encoding का उपयोग करके करेंगे। Pandas get_dummies() नामक एक सरल मेथड प्रदान करता है जो दिए गए डेटाफ्रेम के लिए OHE वेरिएबल्स बनाता है।

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

जब आप OHE का उपयोग करते हैं, तो प्रत्येक कॉलम/वैल्यू संयोजन के लिए एक नया कॉलम बनता है, कॉलम_वैल्यू फॉर्मेट में। उदाहरण के लिए - “Embarked” वेरिएबल के लिए, OHE “Embarked_C”, “Embarked_Q”, “Embarked_S”, और “Embarked_nan” बनाएगा।

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

from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)

आपने अपना मशीन लर्निंग मॉडल बना लिया है। अब आप इस मॉडल को सेव करेंगे। तकनीकी रूप से कहें तो, आप इस मॉडल को सीरियलाइज़ करेंगे। Python में, इसे Pickling कहते हैं।

मॉडल सेव करना: सीरियलाइज़ेशन और डी-सीरियलाइज़ेशन

आप इसके लिए sklearn की joblib का उपयोग करेंगे।

from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')

['model.pkl']

Logistic Regression मॉडल अब कायम (persist) हो गया है। आप एक लाइन कोड से इस मॉडल को मेमोरी में लोड कर सकते हैं। मॉडल को अपने वर्कस्पेस में वापस लोड करना Deserialization कहलाता है।

lr = joblib.load('model.pkl')

अब आप अपने persisted मॉडल को सर्व करने के लिए Flask का उपयोग करने के लिए तैयार हैं। आपने पहले ही देखा है कि शुरुआत करने के लिए Flask कितना मिनिमलिस्टिक है।

Flask का उपयोग करके मशीन लर्निंग मॉडल से API बनाना

अपने मॉडल को Flask के साथ सर्व करने के लिए, आप निम्न दो कार्य करेंगे:

• एप्लिकेशन शुरू होने पर persisted मॉडल को मेमोरी में लोड करें,
• एक API एंडपॉइंट बनाएं जो इनपुट वेरिएबल्स ले, उन्हें उपयुक्त फ़ॉर्मेट में ट्रांसफॉर्म करे और प्रेडिक्शन लौटाए।

विशेष रूप से, आपकी API के लिए सैंपल इनपुट निम्न जैसा दिखेगा:

[
    {"Age": 85, "Sex": "male", "Embarked": "S"},
    {"Age": 24, "Sex": '"female"', "Embarked": "C"},
    {"Age": 3, "Sex": "male", "Embarked": "C"},
    {"Age": 21, "Sex": "male", "Embarked": "S"}
]

(जो कि JSON की एक list है)

और आपकी API का आउटपुट निम्न जैसा होगा:

{"prediction": [0, 1, 1, 0]}

प्रेडिक्शंस जीवित रहने की स्थिति को दर्शाते हैं जहाँ 0 का अर्थ No और 1 का अर्थ Yes है।

JSON का अर्थ JavaScript Object Notation है, और यह सबसे व्यापक रूप से उपयोग किए जाने वाले डेटा इंटरचेंज फ़ॉर्मैट्स में से एक है। यदि आपको इसका त्वरित परिचय चाहिए, तो ये ट्यूटोरियल्स देखें।

आइए एक फ़ंक्शन predict() लिखते हैं जो यह करेगा:

• एप्लिकेशन शुरू होते समय persisted मॉडल को मेमोरी में लोड करें,
• एक API एंडपॉइंट बनाएँ जो इनपुट वेरिएबल्स ले, उन्हें उपयुक्त फ़ॉर्मैट में बदले, और प्रेडिक्शंस लौटाए।

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

from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/predict', methods=['POST'])
def predict():
     json_ = request.json
     query_df = pd.DataFrame(json_)
     query = pd.get_dummies(query_df)
     prediction = lr.predict(query)
     return jsonify({'prediction': list(prediction)})

शानदार! लेकिन यहाँ एक छोटी-सी समस्या है।

यह फ़ंक्शन तभी काम करेगा जब इनकमिंग रिक्वेस्ट में कैटेगोरिकल वेरिएबल्स के सभी संभावित मान शामिल हों, जो रियल-टाइम में हो भी सकते हैं और नहीं भी। यदि इनकमिंग रिक्वेस्ट में कैटेगोरिकल वेरिएबल्स के सभी संभावित मान शामिल नहीं हैं, तो predict() की वर्तमान परिभाषा के अनुसार get_dummies() एक ऐसा डेटाफ्रेम जेनरेट करेगा जिसमें क्लासिफायर की अपेक्षा से कम कॉलम होंगे, जिससे रनटाइम एरर होगा।

इस समस्या को हल करने के लिए, आप मॉडल ट्रेनिंग के समय कॉलम्स की सूची भी persist करेंगे। आप किसी भी Python ऑब्जेक्ट को .pkl फ़ाइल में सीरियलाइज़ कर सकते हैं। आप joblib का उपयोग पहले की तरह ही करेंगे।

(यह ध्यान रखें कि, जैसा पहले चर्चा की गई, सर्वर-लेवल का सारा कोड किसी टेक्स्ट एडिटर में लिखना और फिर टर्मिनल से चलाना हमेशा बेहतर रहता है)

model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')

['model_columns.pkl']

क्योंकि आपने पहले ही कॉलम्स की सूची को persist कर दिया है, आप प्रेडिक्शन के समय मिसिंग वैल्यूज़ को हैंडल कर सकते हैं। आपको एप्लिकेशन शुरू होने पर मॉडल कॉलम्स लोड करने होंगे।

@app.route('/predict', methods=['POST']) # Your API endpoint URL would consist /predict
def predict():
    if lr:
        try:
            json_ = request.json
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': prediction})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

आपने "/predict" API में सभी आवश्यक तत्व शामिल कर दिए, और अब आपको केवल मेन क्लास लिखनी है।

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line argument
    except:
        port = 12345 # If you don't provide any port then the port will be set to 12345
    lr = joblib.load(model_file_name) # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load(model_columns_file_name) # Load "model_columns.pkl"
    print ('Model columns loaded')
    app.run(port=port, debug=True)

आपकी API अब होस्ट होने के लिए तैयार है। लेकिन आगे बढ़ने से पहले, अब तक आपने जो किया उसका एक सारांश देख लेते हैं:

सभी चीज़ों को साथ लाना:

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

आइए सारा कोड एक जगह रख दें ताकि कुछ छूट न जाए। साथ ही, अच्छा प्रोग्रामिंग अभ्यास यह है कि आप अपने Logistic Regression मॉडल के कोड और Flask API के कोड को अलग-अलग .py फ़ाइलों में बाँटें।

तो आपकी model.py फ़ाइल निम्न जैसी दिखनी चाहिए:

# Import dependencies
import pandas as pd
import numpy as np

# Load the dataset in a dataframe object and include only four features as mentioned
url = "http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
df = pd.read_csv(url)
include = ['Age', 'Sex', 'Embarked', 'Survived'] # Only four features
df_ = df[include]

# Data Preprocessing
categoricals = []
for col, col_type in df_.dtypes.iteritems():
     if col_type == 'O':
          categoricals.append(col)
     else:
          df_[col].fillna(0, inplace=True)

df_ohe = pd.get_dummies(df_, columns=categoricals, dummy_na=True)

# Logistic Regression classifier
from sklearn.linear_model import LogisticRegression
dependent_variable = 'Survived'
x = df_ohe[df_ohe.columns.difference([dependent_variable])]
y = df_ohe[dependent_variable]
lr = LogisticRegression()
lr.fit(x, y)

# Save your model
from sklearn.externals import joblib
joblib.dump(lr, 'model.pkl')
print("Model dumped!")

# Load the model that you just saved
lr = joblib.load('model.pkl')

# Saving the data columns from training
model_columns = list(x.columns)
joblib.dump(model_columns, 'model_columns.pkl')
print("Models columns dumped!")

आपकी api.py फ़ाइल निम्न जैसी दिखनी चाहिए:

# Dependencies
from flask import Flask, request, jsonify
from sklearn.externals import joblib
import traceback
import pandas as pd
import numpy as np

# Your API definition
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if lr:
        try:
            json_ = request.json
            print(json_)
            query = pd.get_dummies(pd.DataFrame(json_))
            query = query.reindex(columns=model_columns, fill_value=0)

            prediction = list(lr.predict(query))

            return jsonify({'prediction': str(prediction)})

        except:

            return jsonify({'trace': traceback.format_exc()})
    else:
        print ('Train the model first')
        return ('No model here to use')

if __name__ == '__main__':
    try:
        port = int(sys.argv[1]) # This is for a command-line input
    except:
        port = 12345 # If you don't provide any port the port will be set to 12345

    lr = joblib.load("model.pkl") # Load "model.pkl"
    print ('Model loaded')
    model_columns = joblib.load("model_columns.pkl") # Load "model_columns.pkl"
    print ('Model columns loaded')

    app.run(port=port, debug=True)

काफी बढ़िया! अब आप इस API का परीक्षण Postman नामक API क्लाइंट में करेंगे। बस यह सुनिश्चित करें कि model.py और api.py एक ही डायरेक्टरी में हैं और परीक्षण से पहले दोनों को कम्पाइल किया गया है। नीचे टर्मिनल का स्नैपशॉट दिया गया है जो दोनों .py फ़ाइलों के सफलतापूर्वक कम्पाइल होने के बाद लिया गया है।

यदि आपकी सभी फ़ाइलें सफलतापूर्वक कम्पाइल हो गई हैं, तो डायरेक्टरी संरचना निम्न जैसी होनी चाहिए:

नोट: IPYNB फ़ाइल वैकल्पिक है।

Postman में अपनी API का परीक्षण

अपनी API का परीक्षण करने के लिए, आपको किसी न किसी प्रकार के API क्लाइंट की आवश्यकता होगी। Postman निस्संदेह सर्वश्रेष्ठ में से एक है। आप इसे ऊपर दिए गए लिंक से आसानी से डाउनलोड कर सकते हैं।

यदि आपने नवीनतम संस्करण डाउनलोड किया है तो Postman इंटरफ़ेस कुछ इस तरह दिखता है:

Flask सर्वर को सफलतापूर्वक शुरू करने के बाद, आपको Postman में सही पोर्ट नंबर के साथ सही URL दर्ज करना होगा। यह निम्न जैसा दिखना चाहिए:

बधाई हो! आपने अपनी पहली मशीन लर्निंग API बना ली है।

आपकी API यह भविष्यवाणी कर सकती है कि Titanic जहाज़-डूबने में कोई यात्री जीवित बचा या नहीं, बशर्ते उसके age, sex और embarked की जानकारी दी जाए। अब, आपका मित्र इसे अपने फ्रंट-एंड कोड से कॉल कर सकता है और API के आउटपुट को किसी रोचक रूप में प्रोसेस कर सकता है।

आगे बढ़ते हुए:

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

इसे बेहतर बनाने के लिए आप बहुत कुछ कर सकते हैं। कुछ संभावित विकल्प:

• एक "/train" API लिखें जो डेटा के साथ Logistic Regression क्लासिफ़ायर ट्रेन करे।
• keras का उपयोग करके एक Neural Network मॉडल कोड करें और उससे API बनाएं।
• अपनी API को क्लाउड पर होस्ट करें ताकि इसे कंज्यूम किया जा सके।
• इसे अधिक उन्नत स्तरों तक ले जाने के लिए, आप इस Machine Learning Mastery ब्लॉग को देख सकते हैं जिसमें कई इंडस्ट्री-ग्रेडेड अप्रोच पर चर्चा है।

यहाँ संभावनाएँ और अवसर बहुत बड़े हैं। आपको बस वे चुनने हैं जो आपके लिए सबसे उपयुक्त हों।

यदि आप Python में Machine Learning के बारे में और सीखना चाहते हैं, तो DataCamp का Preprocessing for Machine Learning in Python कोर्स लें और हमारा Machine Learning Basics - The Norms ट्यूटोरियल देखें।

संदर्भ:

इस ब्लॉग को लिखते समय निम्न संदर्भों का उपयोग किया गया:

• Flask: Building Python Web Services
• इस विषय पर एक Quora थ्रेड