स्पैम फ़िल्टर करने वाले मशीन लर्निंग मॉडल का इस्तेमाल करने के लिए, अपने ऐप्लिकेशन को अपडेट करें

1. शुरू करने से पहले

इस कोडलैब में, आपको उस ऐप्लिकेशन को अपडेट करना होगा जिसे आपने 'मोबाइल पर टेक्स्ट को कैटगरी में बांटने से जुड़े कोडलैब शुरू करें' में बनाया था.

ज़रूरी शर्तें

इस कोडलैब को उन अनुभवी डेवलपर के लिए बनाया गया है जो मशीन लर्निंग के लिए नए हैं.
यह कोडलैब, क्रम से बनाए गए पाथवे का हिस्सा है. अगर आपने अब तक, मैसेजिंग स्टाइल वाला बुनियादी ऐप्लिकेशन बनाने या स्पैम वाली टिप्पणियों का पता लगाने के लिए मशीन लर्निंग मॉडल बनाने का काम पूरा नहीं किया है, तो कृपया इसे अभी पूरा करें.

आपको [बनाने या सीखने] को क्या मिलेगा

आपको पिछले चरणों में बनाए गए ऐप्लिकेशन में, अपने कस्टम मॉडल को इंटिग्रेट करने का तरीका बताया जाएगा.

आपको किन चीज़ों की ज़रूरत होगी

Android Studio या iOS के लिए CocoaPods

2. मौजूदा Android ऐप्लिकेशन खोलना

इसके लिए, कोडलैब 1 में दिया गया कोड इस्तेमाल करें. इसके अलावा, इस रेपो को क्लोन करके और TextClassificationStep1 से ऐप्लिकेशन लोड करके भी कोड इस्तेमाल किया जा सकता है.

git clone https://github.com/googlecodelabs/odml-pathways

यह आपको TextClassificationOnMobile->Android पाथ में दिखेगा.

पूरा हो चुका कोड भी आपके लिए TextClassificationStep2 के तौर पर उपलब्ध है.

इसके बाद, दूसरे चरण पर जाएं.

3. मॉडल फ़ाइल और मेटाडेटा इंपोर्ट करना

'टिप्पणियों में स्पैम का पता लगाने के लिए मशीन लर्निंग मॉडल बनाना' कोडलैब में, आपने .TFLITE मॉडल बनाया था.

आपने मॉडल फ़ाइल डाउनलोड की हो. अगर आपके पास यह नहीं है, तो इस कोडलैब के लिए repo से इसे डाउनलोड किया जा सकता है. साथ ही, मॉडल यहां उपलब्ध है.

ऐसेट डायरेक्ट्री बनाकर, इसे अपने प्रोजेक्ट में जोड़ें.

प्रोजेक्ट नेविगेटर का इस्तेमाल करके, पक्का करें कि सबसे ऊपर Android चुना गया हो.
ऐप्लिकेशन फ़ोल्डर पर राइट क्लिक करें. नया > डायरेक्ट्री चुनें.

नई डायरेक्ट्री डायलॉग में, src/main/assets चुनें.

आपको दिखेगा कि ऐप्लिकेशन में अब एक नया ऐसेट फ़ोल्डर उपलब्ध है.

assets पर राइट क्लिक करें.
इसके बाद, एक मेन्यू खुलेगा. इसमें आपको (mac पर) Finder में दिखाएं दिखेगा. इसे चुनें. (Windows पर यह Show in Explorer और Ubuntu पर Show in Files के तौर पर दिखेगा.)

फ़ाइलों की जगह दिखाने के लिए, Finder लॉन्च होगा. Windows पर File Explorer और Linux पर Files लॉन्च होगा.

labels.txt, model.tflite, और vocab फ़ाइलों को इस डायरेक्ट्री में कॉपी करें.

Android Studio पर वापस जाएं. आपको ये ऐसेट, assets फ़ोल्डर में दिखेंगी.

4. TensorFlow Lite का इस्तेमाल करने के लिए, build.gradle फ़ाइल अपडेट करना

TensorFlow Lite और इसे सपोर्ट करने वाली TensorFlow Lite टास्क लाइब्रेरी का इस्तेमाल करने के लिए, आपको अपनी build.gradle फ़ाइल अपडेट करनी होगी.

Android प्रोजेक्ट में अक्सर एक से ज़्यादा बिल्ड फ़ाइलें होती हैं. इसलिए, ऐप्लिकेशन लेवल की बिल्ड फ़ाइल ढूंढना न भूलें. Android व्यू में प्रोजेक्ट एक्सप्लोरर में, इसे Gradle Scripts सेक्शन में ढूंढें. सही ऐप्लिकेशन को .app के तौर पर लेबल किया जाएगा. यह यहां दिखाया गया है:

आपको इस फ़ाइल में दो बदलाव करने होंगे. पहला, सबसे नीचे मौजूद dependencies सेक्शन में है. TensorFlow Lite टास्क लाइब्रेरी के लिए, इस तरह से टेक्स्ट implementation जोड़ें:

implementation 'org.tensorflow:tensorflow-lite-task-text:0.1.0'

यह लेख लिखे जाने के बाद से, वर्शन नंबर में बदलाव हो सकता है. इसलिए, नए वर्शन के लिए https://www.tensorflow.org/lite/inference_with_metadata/task_library/nl_classifier पर जाएं.

टास्क लाइब्रेरी के लिए भी, एसडीके का कम से कम वर्शन 21 होना ज़रूरी है. इस सेटिंग को android > default config में जाकर ढूंढें और इसे 21 पर सेट करें:

अब आपके पास सभी डिपेंडेंसी हैं. इसलिए, अब कोडिंग शुरू करने का समय है!

5. सहायक क्लास जोड़ना

अनुमान लगाने के लॉजिक को अलग करने के लिए, जहां आपका ऐप्लिकेशन मॉडल का इस्तेमाल करता है, यूज़र इंटरफ़ेस से मॉडल के अनुमान को मैनेज करने के लिए एक और क्लास बनाएं. इसे "सहायक" क्लास कहा जाता है.

उस पैकेज के नाम पर राइट क्लिक करें जिसमें आपका MainActivity कोड मौजूद है.
नया > पैकेज चुनें.

आपको स्क्रीन के बीच में एक डायलॉग दिखेगा. इसमें आपको पैकेज का नाम डालने के लिए कहा जाएगा. इसे मौजूदा पैकेज के नाम के आखिर में जोड़ें. (यहां इसे सहायक कहा जाता है.)

इसके बाद, प्रोजेक्ट एक्सप्लोरर में helpers फ़ोल्डर पर राइट क्लिक करें.
नई > Java क्लास चुनें और इसे TextClassificationClient नाम दें. अगले चरण में, फ़ाइल में बदलाव किया जा सकेगा.

आपकी TextClassificationClient हेल्पर क्लास इस तरह दिखेगी. हालांकि, आपके पैकेज का नाम अलग हो सकता है.

package com.google.devrel.textclassificationstep1.helpers;

public class TextClassificationClient {
}

इस कोड से फ़ाइल अपडेट करें:

package com.google.devrel.textclassificationstep2.helpers;

import android.content.Context;
import android.util.Log;
import java.io.IOException;
import java.util.List;

import org.tensorflow.lite.support.label.Category;
import org.tensorflow.lite.task.text.nlclassifier.NLClassifier;

public class TextClassificationClient {
    private static final String MODEL_PATH = "model.tflite";
    private static final String TAG = "CommentSpam";
    private final Context context;

    NLClassifier classifier;

    public TextClassificationClient(Context context) {
        this.context = context;
    }

    public void load() {
        try {
            classifier = NLClassifier.createFromFile(context, MODEL_PATH);
        } catch (IOException e) {
            Log.e(TAG, e.getMessage());
        }
    }

    public void unload() {
        classifier.close();
        classifier = null;
    }

    public List<Category> classify(String text) {
        List<Category> apiResults = classifier.classify(text);
        return apiResults;
    }

}

यह क्लास, TensorFlow Lite इंटरप्रेटर के लिए रैपर उपलब्ध कराएगी. इससे मॉडल लोड होगा और आपके ऐप्लिकेशन और मॉडल के बीच डेटा इंटरचेंज को मैनेज करने की जटिलता कम होगी.

load() तरीके में, यह मॉडल पाथ से एक नया NLClassifier टाइप इंस्टैंशिएट करेगा. मॉडल पाथ, मॉडल का नाम model.tflite होता है. NLClassifier टाइप, टेक्स्ट टास्क लाइब्रेरी का हिस्सा है. यह आपकी स्ट्रिंग को टोकन में बदलने, सही क्रम की लंबाई का इस्तेमाल करने, इसे मॉडल को पास करने, और नतीजों को पार्स करने में आपकी मदद करता है.

(इनके बारे में ज़्यादा जानने के लिए, स्पैम वाली टिप्पणियों का पता लगाने वाला मशीन लर्निंग मॉडल बनाएं लेख पढ़ें.)

क्लासिफ़िकेशन, classify मेथड में किया जाता है. इसमें आपको एक स्ट्रिंग पास करनी होती है. इसके बाद, यह List दिखाता है. मशीन लर्निंग मॉडल का इस्तेमाल करके, कॉन्टेंट को कैटगरी में बांटने के दौरान, यह तय किया जाता है कि कोई स्ट्रिंग स्पैम है या नहीं. ऐसे में, सभी जवाबों को उनकी असाइन की गई संभावनाओं के साथ वापस भेज दिया जाता है. उदाहरण के लिए, अगर आपने इसे स्पैम जैसा दिखने वाला कोई मैसेज दिया, तो आपको दो जवाब मिलेंगे. एक में यह बताया जाएगा कि मैसेज के स्पैम होने की कितनी संभावना है और दूसरे में यह बताया जाएगा कि मैसेज के स्पैम न होने की कितनी संभावना है. स्पैम/स्पैम नहीं है, कैटगरी हैं. इसलिए, List में इन संभावनाओं के बारे में जानकारी होगी. आपको बाद में उसे पार्स करना होगा.

अब आपके पास हेल्पर क्लास है. इसलिए, वापस MainActivity पर जाएं और इसे अपडेट करें, ताकि इसका इस्तेमाल करके अपने टेक्स्ट को कैटगरी में बांटा जा सके. अगले चरण में आपको यह दिखेगा!

6. टेक्स्ट को कैटगरी में बांटना

अपने MainActivity में, आपको सबसे पहले उन हेल्पर को इंपोर्ट करना होगा जिन्हें आपने अभी बनाया है!

MainActivity.kt में सबसे ऊपर, अन्य इंपोर्ट के साथ-साथ यह भी जोड़ें:

import com.google.devrel.textclassificationstep2.helpers.TextClassificationClient
import org.tensorflow.lite.support.label.Category

इसके बाद, आपको हेल्पर लोड करने होंगे. onCreate में, setContentView लाइन के तुरंत बाद, हेल्पर क्लास को इंस्टैंटिएट और लोड करने के लिए ये लाइनें जोड़ें:

val client = TextClassificationClient(applicationContext)
client.load()

फ़िलहाल, आपके बटन का onClickListener ऐसा दिखना चाहिए:

btnSendText.setOnClickListener {
     var toSend:String = txtInput.text.toString()
     txtOutput.text = toSend
 }

इसे इस तरह अपडेट करो:

btnSendText.setOnClickListener {
    var toSend:String = txtInput.text.toString()
    var results:List<Category> = client.classify(toSend)
    val score = results[1].score
    if(score>0.8){
        txtOutput.text = "Your message was detected as spam with a score of " + score.toString() + " and not sent!"
    } else {
        txtOutput.text = "Message sent! \nSpam score was:" + score.toString()
    }
    txtInput.text.clear()
}

इससे फ़ंक्शन में यह बदलाव होता है कि वह सिर्फ़ उपयोगकर्ता के इनपुट को आउटपुट के तौर पर दिखाने के बजाय, पहले उसे कैटगरी में बांटता है.

इस लाइन की मदद से, उपयोगकर्ता की ओर से डाली गई स्ट्रिंग को मॉडल को पास किया जाएगा. इसके बाद, आपको नतीजे मिलेंगे:

var results:List<Category> = client.classify(toSend)

सिर्फ़ दो कैटगरी हैं: False और True

. (TensorFlow इन्हें वर्णमाला के क्रम में लगाता है. इसलिए, False आइटम 0 होगा और True आइटम 1 होगा.)

वैल्यू के True होने की संभावना का स्कोर पाने के लिए, results[1].score को इस तरह देखा जा सकता है:

    val score = results[1].score

थ्रेशोल्ड वैल्यू (इस मामले में 0.8) चुनी गई है. इसमें बताया गया है कि अगर True कैटगरी का स्कोर थ्रेशोल्ड वैल्यू (0.8) से ज़्यादा है, तो मैसेज स्पैम है. अगर ऐसा नहीं है, तो यह स्पैम नहीं है और मैसेज को सुरक्षित तरीके से भेजा जा सकता है:

    if(score>0.8){
        txtOutput.text = "Your message was detected as spam with a score of " + score.toString() + " and not sent!"
    } else {
        txtOutput.text = "Message sent! \nSpam score was:" + score.toString()
    }

यहां मॉडल को काम करते हुए देखें. "सामान खरीदने के लिए मेरे ब्लॉग पर जाएं!" मैसेज को स्पैम के तौर पर फ़्लैग किया गया है:

इसके उलट, "अरे, यह मज़ेदार ट्यूटोरियल है, धन्यवाद!" को स्पैम के तौर पर मार्क किए जाने की संभावना बहुत कम थी:

7. TensorFlow Lite मॉडल का इस्तेमाल करने के लिए, iOS ऐप्लिकेशन को अपडेट करना

इसके लिए, कोडलैब 1 में दिया गया कोड इस्तेमाल करें. इसके अलावा, इस रेपो को क्लोन करके और TextClassificationStep1 से ऐप्लिकेशन लोड करके भी कोड इस्तेमाल किया जा सकता है. यह आपको TextClassificationOnMobile->iOS पाथ में दिखेगा.

पूरा हो चुका कोड भी आपके लिए TextClassificationStep2 के तौर पर उपलब्ध है.

'स्पैम टिप्पणी का पता लगाने के लिए मशीन लर्निंग मॉडल बनाएं' कोडलैब में, आपने एक बहुत ही सामान्य ऐप्लिकेशन बनाया था. इसमें उपयोगकर्ता को UITextView में कोई मैसेज टाइप करने की सुविधा मिलती है. इसके बाद, मैसेज को बिना किसी फ़िल्टर के आउटपुट में पास कर दिया जाता है.

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

शुरू करने के लिए, आपको पहले चरण में बताए गए ऐप्लिकेशन की ज़रूरत होगी. इसे repo से क्लोन किया जा सकता है.

TensorFlow Lite को शामिल करने के लिए, CocoaPods का इस्तेमाल किया जाएगा. अगर आपने इन्हें पहले से इंस्टॉल नहीं किया है, तो https://cocoapods.org/ पर दिए गए निर्देशों का पालन करके इन्हें इंस्टॉल किया जा सकता है.

CocoaPods इंस्टॉल करने के बाद, TextClassification ऐप्लिकेशन के लिए .xcproject वाली डायरेक्ट्री में Podfile नाम की फ़ाइल बनाएं. इस फ़ाइल का कॉन्टेंट ऐसा दिखना चाहिए:

target 'TextClassificationStep2' do
  use_frameworks!

  # Pods for NLPClassifier
    pod 'TensorFlowLiteSwift'

end

आपके ऐप्लिकेशन का नाम पहली लाइन में होना चाहिए, न कि "TextClassificationStep2."

टर्मिनल का इस्तेमाल करके, उस डायरेक्ट्री पर जाएं और pod install चलाएं. अगर यह प्रोसेस पूरी हो जाती है, तो आपके पास Pods नाम की एक नई डायरेक्ट्री होगी. साथ ही, आपके लिए एक नई .xcworkspace फ़ाइल बनाई जाएगी. आने वाले समय में, आपको .xcproject के बजाय इसका इस्तेमाल करना होगा.

अगर ऐसा नहीं होता है, तो कृपया पक्का करें कि आपके पास उसी डायरेक्ट्री में Podfile हो जहां .xcproject था. आम तौर पर, गलत डायरेक्ट्री में पॉडफ़ाइल या गलत टारगेट का नाम होने की वजह से ऐसा होता है!

8. मॉडल और शब्दावली फ़ाइलें जोड़ना

TensorFlow Lite Model maker का इस्तेमाल करके मॉडल बनाते समय, मॉडल (model.tflite के तौर पर) और शब्दावली (vocab.txt के तौर पर) को आउटपुट किया जा सकता है.

उन्हें अपने प्रोजेक्ट में जोड़ने के लिए, Finder से खींचकर अपने प्रोजेक्ट की विंडो में छोड़ें. पक्का करें कि टारगेट में जोड़ें विकल्प चुना गया हो:

सेट अप पूरा करने के बाद, आपको ये अपने प्रोजेक्ट में दिखेंगे:

पक्का करें कि उन्हें बंडल में जोड़ा गया हो, ताकि उन्हें किसी डिवाइस पर डिप्लॉय किया जा सके. इसके लिए, अपने प्रोजेक्ट को चुनें. ऊपर दिए गए स्क्रीनशॉट में, यह नीला आइकॉन TextClassificationStep2 है. इसके बाद, Build Phases टैब देखें:

9. शब्दों की जानकारी लोड करना

एनएलपी क्लासिफ़िकेशन करते समय, मॉडल को ऐसे शब्दों से ट्रेन किया जाता है जिन्हें वेक्टर में कोड किया गया हो. मॉडल, शब्दों को नाम और वैल्यू के एक खास सेट के साथ एन्कोड करता है. मॉडल को ट्रेनिंग देते समय, यह सेट तैयार होता है. कृपया ध्यान दें कि ज़्यादातर मॉडल में अलग-अलग शब्दावलियां होंगी. इसलिए, आपके लिए अपने मॉडल की शब्दावली का इस्तेमाल करना ज़रूरी है. यह शब्दावली, ट्रेनिंग के समय जनरेट की गई थी. यह vocab.txt फ़ाइल है, जिसे आपने अभी-अभी अपने ऐप्लिकेशन में जोड़ा है.

एनकोडिंग देखने के लिए, फ़ाइल को Xcode में खोला जा सकता है. "song" जैसे शब्दों को 6 और "love" को 12 के तौर पर कोड किया जाता है. यह क्रम असल में फ़्रीक्वेंसी के हिसाब से लगाया गया क्रम है. इसलिए, डेटासेट में "I" शब्द सबसे ज़्यादा बार आया है. इसके बाद, "check" शब्द सबसे ज़्यादा बार आया है.

जब आपका उपयोगकर्ता शब्दों को टाइप करता है, तो आपको उन्हें इस शब्दावली के साथ एन्कोड करना होगा. इसके बाद, उन्हें मॉडल को भेजना होगा, ताकि उन्हें क्लासिफ़ाई किया जा सके.

आइए, उस कोड के बारे में जानें. सबसे पहले, शब्दावली लोड करें.

डिक्शनरी को सेव करने के लिए, क्लास लेवल वैरिएबल तय करें:

var words_dictionary = [String : Int]()

इसके बाद, इस शब्दकोश में शब्दावली लोड करने के लिए, क्लास में func बनाएं:

func loadVocab(){
    // This func will take the file at vocab.txt and load it into a has table
    // called words_dictionary. This will be used to tokenize the words before passing them
    // to the model trained by TensorFlow Lite Model Maker
    if let filePath = Bundle.main.path(forResource: "vocab", ofType: "txt") {
        do {
            let dictionary_contents = try String(contentsOfFile: filePath)
            let lines = dictionary_contents.split(whereSeparator: \.isNewline)
            for line in lines{
                let tokens = line.components(separatedBy: " ")
                let key = String(tokens[0])
                let value = Int(tokens[1])
                words_dictionary[key] = value
            }
        } catch {
            print("Error vocab could not be loaded")
        }
    } else {
        print("Error -- vocab file not found")

    }
}

इसे viewDidLoad से कॉल करके चलाया जा सकता है:

override func viewDidLoad() {
    super.viewDidLoad()
    txtInput.delegate = self
    loadVocab()
}

10. किसी स्ट्रिंग को टोकन के क्रम में बदलना

आपके उपयोगकर्ता शब्दों को एक वाक्य के तौर पर टाइप करेंगे, जो एक स्ट्रिंग बन जाएगी. अगर वाक्य में मौजूद हर शब्द, डिक्शनरी में मौजूद है, तो उसे शब्द के लिए तय की गई वैल्यू में कोड किया जाएगा.

आम तौर पर, एनएलपी मॉडल एक तय लंबाई वाले सीक्वेंस को स्वीकार करता है. ragged tensors का इस्तेमाल करके बनाए गए मॉडल में कुछ अपवाद हैं. हालांकि, ज़्यादातर मामलों में आपको यह समस्या ठीक दिखेगी. मॉडल बनाते समय, आपने इस अवधि के बारे में बताया था. पक्का करें कि आपने iOS ऐप्लिकेशन में भी उतनी ही लंबाई का इस्तेमाल किया हो.

आपने पहले TensorFlow Lite Model Maker के लिए Colab में डिफ़ॉल्ट तौर पर 20 का इस्तेमाल किया था. इसलिए, यहां भी इसे सेट अप करें:

let SEQUENCE_LENGTH = 20

यह func जोड़ें. यह स्ट्रिंग लेगा, उसे लोअरकेस में बदलेगा, और उसमें मौजूद किसी भी विराम चिह्न को हटा देगा:

func convert_sentence(sentence: String) -> [Int32]{
// This func will split a sentence into individual words, while stripping punctuation
// If the word is present in the dictionary it's value from the dictionary will be added to
// the sequence. Otherwise we'll continue

// Initialize the sequence to be all 0s, and the length to be determined
// by the const SEQUENCE_LENGTH. This should be the same length as the
// sequences that the model was trained for
  var sequence = [Int32](repeating: 0, count: SEQUENCE_LENGTH)
  var words : [String] = []
  sentence.enumerateSubstrings(
    in: sentence.startIndex..<sentence.endIndex,options: .byWords) {
            (substring, _, _, _) -> () in words.append(substring!) }
  var thisWord = 0
  for word in words{
    if (thisWord>=SEQUENCE_LENGTH){
      break
    }
    let seekword = word.lowercased()
    if let val = words_dictionary[seekword]{
      sequence[thisWord]=Int32(val)
      thisWord = thisWord + 1
    }
  }
  return sequence
}

ध्यान दें कि यह क्रम Int32 का होगा. इसे जान-बूझकर चुना गया है, क्योंकि TensorFlow Lite को वैल्यू पास करते समय, आपको लो-लेवल मेमोरी से डील करना होगा. साथ ही, TensorFlow Lite, स्ट्रिंग सीक्वेंस में मौजूद पूर्णांकों को 32-बिट पूर्णांक के तौर पर मानता है. इससे मॉडल को स्ट्रिंग पास करने में आपको थोड़ी आसानी होगी.

11. कैटगरी तय करना

किसी वाक्य को कैटगरी में रखने के लिए, उसे सबसे पहले वाक्य में मौजूद शब्दों के आधार पर टोकन के क्रम में बदलना होगा. यह काम नौवें चरण में किया जाएगा.

अब आपको इस वाक्य को मॉडल में पास करना होगा. इसके बाद, मॉडल इस वाक्य पर अनुमान लगाएगा और नतीजों को पार्स करेगा.

यह TensorFlow Lite इंटरप्रेटर का इस्तेमाल करेगा. आपको इसे इंपोर्ट करना होगा:

import TensorFlowLite

अपने क्रम को इनपुट के तौर पर लेने वाले func से शुरू करें. यह Int32 टाइप का एक ऐरे था:

func classify(sequence: [Int32]){
  // Model Path is the location of the model in the bundle
  let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
  var interpreter: Interpreter
  do{
    interpreter = try Interpreter(modelPath: modelPath!)
  } catch _{
    print("Error loading model!")
    return
  }

इससे बंडल से मॉडल फ़ाइल लोड हो जाएगी और इंटरप्रेटर चालू हो जाएगा.

अगला चरण, क्रम में सेव की गई मेमोरी को myData, नाम के बफ़र में कॉपी करना होगा, ताकि इसे टेंसर को पास किया जा सके. TensorFlow Lite पॉड और इंटरप्रेटर को लागू करते समय, आपको एक टेंसर टाइप का ऐक्सेस मिला.

कोड को इस तरह से शुरू करें (अब भी classify func में है):

let tSequence = Array(sequence)
let myData = Data(copyingBufferOf: tSequence.map { Int32($0) })
let outputTensor: Tensor

अगर आपको copyingBufferOf पर कोई गड़बड़ी दिखती है, तो चिंता न करें. इसे बाद में एक्सटेंशन के तौर पर लागू किया जाएगा.

अब इंटरप्रेटर पर टेंसर असाइन करें. इसके बाद, अभी-अभी बनाए गए डेटा बफ़र को इनपुट टेंसर में कॉपी करें. इसके बाद, इंटरप्रेटर को इनफ़रेंस करने के लिए शुरू करें:

do {
  // Allocate memory for the model's input `Tensor`s.
  try interpreter.allocateTensors()

  // Copy the data to the input `Tensor`.
  try interpreter.copy(myData, toInputAt: 0)

  // Run inference by invoking the `Interpreter`.
  try interpreter.invoke()

इनवोकेशन पूरा होने के बाद, नतीजे देखने के लिए इंटरप्रेटर का आउटपुट देखा जा सकता है.

ये रॉ वैल्यू होंगी (हर न्यूरॉन के लिए 4 बाइट). इसके बाद, आपको इन्हें पढ़ना होगा और बदलना होगा. इस मॉडल में दो आउटपुट न्यूरॉन हैं. इसलिए, आपको आठ बाइट पढ़ने होंगे. इन्हें पार्स करने के लिए, Float32 में बदला जाएगा. आपके डिवाइस में कम मेमोरी है. इसलिए, unsafeData.

// Get the output `Tensor` to process the inference results.
outputTensor = try interpreter.output(at: 0)
// Turn the output tensor into an array. This will have 2 values
// Value at index 0 is the probability of negative sentiment
// Value at index 1 is the probability of positive sentiment
let resultsArray = outputTensor.data
let results: [Float32] = [Float32](unsafeData: resultsArray) ?? []

अब स्पैम की क्वालिटी का पता लगाने के लिए, डेटा को पार्स करना आसान हो गया है. मॉडल के दो आउटपुट होते हैं. पहले आउटपुट में, मैसेज के स्पैम न होने की संभावना होती है. दूसरे आउटपुट में, मैसेज के स्पैम होने की संभावना होती है. इसलिए, स्पैम वैल्यू ढूंढने के लिए results[1] को देखें:

let positiveSpamValue = results[1]
var outputString = ""
if(positiveSpamValue>0.8){
    outputString = "Message not sent. Spam detected with probability: " + String(positiveSpamValue)
} else {
    outputString = "Message sent!"
}
txtOutput.text = outputString

आपकी सुविधा के लिए, यहां पूरा तरीका बताया गया है:

func classify(sequence: [Int32]){
  // Model Path is the location of the model in the bundle
  let modelPath = Bundle.main.path(forResource: "model", ofType: "tflite")
  var interpreter: Interpreter
  do{
    interpreter = try Interpreter(modelPath: modelPath!)
    } catch _{
      print("Error loading model!")
      Return
  }
  
  let tSequence = Array(sequence)
  let myData = Data(copyingBufferOf: tSequence.map { Int32($0) })
  let outputTensor: Tensor
  do {
    // Allocate memory for the model's input `Tensor`s.
    try interpreter.allocateTensors()

    // Copy the data to the input `Tensor`.
    try interpreter.copy(myData, toInputAt: 0)

    // Run inference by invoking the `Interpreter`.
    try interpreter.invoke()

    // Get the output `Tensor` to process the inference results.
    outputTensor = try interpreter.output(at: 0)
    // Turn the output tensor into an array. This will have 2 values
    // Value at index 0 is the probability of negative sentiment
    // Value at index 1 is the probability of positive sentiment
    let resultsArray = outputTensor.data
    let results: [Float32] = [Float32](unsafeData: resultsArray) ?? []

    let positiveSpamValue = results[1]
    var outputString = ""
    if(positiveSpamValue>0.8){
      outputString = "Message not sent. Spam detected with probability: " + 
                      String(positiveSpamValue)
    } else {
      outputString = "Message sent!"
    }
    txtOutput.text = outputString

  } catch let error {
    print("Failed to invoke the interpreter with error: \(error.localizedDescription)")
  }
}

12. Swift एक्सटेंशन जोड़ना

ऊपर दिए गए कोड में, डेटा टाइप के एक्सटेंशन का इस्तेमाल किया गया है. इससे आपको Int32 कलेक्शन के रॉ बिट को Data में कॉपी करने की अनुमति मिलती है. उस एक्सटेंशन का कोड यहां दिया गया है:

extension Data {
  /// Creates a new buffer by copying the buffer pointer of the given array.
  ///
  /// - Warning: The given array's element type `T` must be trivial in that it can be copied bit
  ///     for bit with no indirection or reference-counting operations; otherwise, reinterpreting
  ///     data from the resulting buffer has undefined behavior.
  /// - Parameter array: An array with elements of type `T`.
  init<T>(copyingBufferOf array: [T]) {
    self = array.withUnsafeBufferPointer(Data.init)
  }
}

कम लेवल की मेमोरी का इस्तेमाल करते समय, "असुरक्षित" डेटा का इस्तेमाल किया जाता है. साथ ही, ऊपर दिए गए कोड के लिए, आपको असुरक्षित डेटा की एक ऐरे को शुरू करना होगा. यह एक्सटेंशन, ऐसा करने की सुविधा देता है:

extension Array {
  /// Creates a new array from the bytes of the given unsafe data.
  ///
  /// - Warning: The array's `Element` type must be trivial in that it can be copied bit for bit
  ///     with no indirection or reference-counting operations; otherwise, copying the raw bytes in
  ///     the `unsafeData`'s buffer to a new array returns an unsafe copy.
  /// - Note: Returns `nil` if `unsafeData.count` is not a multiple of
  ///     `MemoryLayout<Element>.stride`.
  /// - Parameter unsafeData: The data containing the bytes to turn into an array.
  init?(unsafeData: Data) {
    guard unsafeData.count % MemoryLayout<Element>.stride == 0 else { return nil }
    #if swift(>=5.0)
    self = unsafeData.withUnsafeBytes { .init($0.bindMemory(to: Element.self)) }
    #else
    self = unsafeData.withUnsafeBytes {
      .init(UnsafeBufferPointer<Element>(
        start: $0,
        count: unsafeData.count / MemoryLayout<Element>.stride
      ))
    }
    #endif  // swift(>=5.0)
  }
}

13. iOS ऐप्लिकेशन चलाना

ऐप्लिकेशन को चलाएं और उसकी जांच करें.

अगर सब कुछ ठीक रहा, तो आपको अपने डिवाइस पर ऐप्लिकेशन इस तरह दिखेगा:

"ऑनलाइन ट्रेडिंग सीखने के लिए मेरी किताब खरीदें!" मैसेज भेजने पर, ऐप्लिकेशन ने स्पैम का पता चलने की सूचना भेजी है .इसकी संभावना 99% है!

14. बधाई हो!

आपने अब एक बहुत ही सामान्य ऐप्लिकेशन बना लिया है. यह ऐप्लिकेशन, स्पैम वाली टिप्पणियों के लिए टेक्स्ट को फ़िल्टर करता है. इसके लिए, यह ऐसे मॉडल का इस्तेमाल करता है जिसे स्पैम वाले ब्लॉग के लिए इस्तेमाल किए गए डेटा पर ट्रेन किया गया था.

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