סיווג טקסט עם אנדרואיד

מדריך זה מראה לך כיצד לבנות יישום אנדרואיד באמצעות TensorFlow Lite כדי לסווג טקסט בשפה טבעית. אפליקציה זו מיועדת למכשיר אנדרואיד פיזי אך יכולה לפעול גם על אמולטור מכשיר.

היישום לדוגמה משתמש ב-TensorFlow Lite כדי לסווג טקסט כחיובי או שלילי, תוך שימוש בספריית המשימות לשפה טבעית (NL) כדי לאפשר ביצוע של מודלים של למידה חישובית לסיווג טקסט.

אם אתה מעדכן פרויקט קיים, אתה יכול להשתמש ביישום לדוגמה כהפניה או כתבנית. להוראות כיצד להוסיף סיווג טקסט ליישום קיים, עיין בעדכון ושינוי היישום שלך .

סקירת סיווג טקסט

סיווג טקסט הוא משימת למידת מכונה של הקצאת קבוצה של קטגוריות מוגדרות מראש לטקסט פתוח. מודל סיווג טקסט מאומן על קורפוס של טקסט בשפה טבעית, שבו מילים או ביטויים מסווגים באופן ידני.

המודל המאומן מקבל טקסט כקלט ומנסה לסווג את הטקסט על פי קבוצת המחלקות הידועות אותו הוכשר לסווג. לדוגמה, המודלים בדוגמה זו מקבלים קטע טקסט וקובעים אם הסנטימנט של הטקסט חיובי או שלילי. עבור כל קטע טקסט, מודל סיווג הטקסט מוציא ציון המציין את הביטחון של הטקסט שמסווג נכון כחיובי או שלילי.

למידע נוסף על האופן שבו המודלים במדריך זה נוצרים, עיין במדריך סיווג טקסט עם TensorFlow Lite Model Maker .

מודלים ומערך נתונים

מדריך זה משתמש במודלים שהוכשרו באמצעות מערך הנתונים SST-2 (Stanford Sentiment Treebank). SST-2 מכיל 67,349 ביקורות סרטים להדרכה ו-872 ביקורות סרטים לבדיקה, כאשר כל ביקורת מסווגת כחיובית או שלילית. הדגמים המשמשים באפליקציה זו הוכשרו באמצעות הכלי TensorFlow Lite Model Maker .

היישום לדוגמה משתמש במודלים הבאים שהוכשרו מראש:

  • Average Word Vector ( NLClassifier ) ​​- ה- NLClassifier של ספריית המשימות מסווג טקסט קלט לקטגוריות שונות, ויכול להתמודד עם רוב דגמי סיווג הטקסט.

  • MobileBERT ( BertNLClassifier ) - BertNLClassifier של ספריית המשימות דומה ל-NLClassifier אך מותאם למקרים הדורשים אסימון Wordpiece ו-Senencepiece מחוץ לגרף.

הגדר והפעל את האפליקציה לדוגמה

כדי להגדיר את אפליקציית סיווג הטקסט, הורד את האפליקציה לדוגמה מ- GitHub והפעל אותה באמצעות Android Studio .

דרישות מערכת

  • Android Studio גרסה 2021.1.1 (Bumblebee) ומעלה.
  • Android SDK גרסה 31 ומעלה
  • מכשיר אנדרואיד עם גרסת מערכת הפעלה מינימלית של SDK 21 (אנדרואיד 7.0 - נוגט) עם מצב מפתחים מופעל, או אמולטור אנדרואיד.

קבל את הקוד לדוגמה

צור עותק מקומי של הקוד לדוגמה. תשתמש בקוד זה כדי ליצור פרויקט ב-Android Studio ולהפעיל את היישום לדוגמה.

כדי לשכפל ולהגדיר את הקוד לדוגמה:

  1. שכפל את מאגר git
    git clone https://github.com/tensorflow/examples.git
  2. לחלופין, הגדר את מופע ה-git שלך לשימוש בקופה דלילה, כך שיהיו לך רק את הקבצים עבור האפליקציה לדוגמה לסיווג טקסט:
    cd examples
git sparse-checkout init --cone
git sparse-checkout set lite/examples/text_classification/android

ייבוא ​​והפעל את הפרויקט

צור פרוייקט מהקוד לדוגמה שהורד, בנה את הפרוייקט ולאחר מכן הפעל אותו.

כדי לייבא ולבנות את פרויקט הקוד לדוגמה:

  1. הפעל את Android Studio .
  2. מ-Android Studio, בחר קובץ > חדש > ייבוא ​​פרויקט .
  3. נווט אל ספריית הקוד לדוגמה המכילה את הקובץ build.gradle ( .../examples/lite/examples/text_classification/android/build.gradle ) ובחר את הספרייה הזו.
  4. אם Android Studio מבקש סינכרון Gradle, בחר אישור.
  5. ודא שמכשיר האנדרואיד שלך מחובר למחשב שלך ומצב מפתח מופעל. לחץ על חץ Run הירוק.

אם תבחר את הספרייה הנכונה, Android Studio יוצר פרויקט חדש ובונה אותו. תהליך זה עשוי להימשך מספר דקות, בהתאם למהירות המחשב שלך ואם השתמשת ב-Android Studio עבור פרויקטים אחרים. כאשר הבנייה מסתיימת, ה-Android Studio מציג הודעת BUILD SUCCESSFUL בחלונית סטטוס Build Output .

להפעלת הפרויקט:

  1. מ-Android Studio, הפעל את הפרויקט על ידי בחירה בהפעלה > הפעלה... .
  2. בחר מכשיר אנדרואיד (או אמולטור) מחובר כדי לבדוק את האפליקציה.

שימוש באפליקציה

אפליקציה לדוגמה לסיווג טקסט באנדרואיד

לאחר הפעלת הפרויקט ב-Android Studio, האפליקציה תיפתח אוטומטית במכשיר המחובר או באמולטור המכשיר.

כדי להשתמש במסווג הטקסט:

  1. הזן קטע טקסט בתיבת הטקסט.
  2. מהתפריט הנפתח Delegate , בחר CPU או NNAPI .
  3. ציין דגם על ידי בחירת AverageWordVec או MobileBERT .
  4. בחר סיווג .

האפליקציה מוציאה ציון חיובי וציון שלילי . שני ציונים אלה יסכמו ל-1, ומודד את הסבירות שהסנטימנט של טקסט הקלט הוא חיובי או שלילי. מספר גבוה יותר מציין רמה גבוהה יותר של ביטחון.

כעת יש לך יישום סיווג טקסט מתפקד. השתמש בסעיפים הבאים כדי להבין טוב יותר כיצד פועל היישום לדוגמה, וכיצד ליישם תכונות סיווג טקסט ליישומי הייצור שלך:

כיצד פועלת האפליקציה לדוגמה

היישום משתמש בחבילת Task Library for Natural Language (NL) כדי ליישם את המודלים לסיווג טקסט. שני הדגמים, Average Word Vector ו-MobileBERT, הוכשרו באמצעות TensorFlow Lite Model Maker . האפליקציה פועלת על CPU כברירת מחדל, עם אפשרות להאצת חומרה באמצעות נציג NNAPI.

הקבצים והספריות הבאים מכילים את הקוד החיוני עבור יישום סיווג טקסט זה:

  • TextClassificationHelper.kt - מאתחל את מסווג הטקסט ומטפל בבחירת המודל והנציג.
  • MainActivity.kt - מיישם את האפליקציה, כולל קריאה ל- TextClassificationHelper ול- ResultsAdapter .
  • ResultsAdapter.kt - מטפל ומעצב את התוצאות.

שנה את האפליקציה שלך

הסעיפים הבאים מסבירים את השלבים העיקריים לשינוי אפליקציית Android משלך כדי להפעיל את הדגם המוצג באפליקציה לדוגמה. הוראות אלה משתמשות באפליקציה לדוגמה כנקודת התייחסות. השינויים הספציפיים הדרושים לאפליקציה שלך עשויים להשתנות מהאפליקציה לדוגמה.

פתח או צור פרויקט אנדרואיד

אתה צריך פרויקט פיתוח אנדרואיד ב-Android Studio כדי לבצע יחד עם שאר ההוראות האלה. עקוב אחר ההוראות שלהלן כדי לפתוח פרויקט קיים או ליצור פרויקט חדש.

כדי לפתוח פרויקט פיתוח אנדרואיד קיים:

  • ב-Android Studio, בחר קובץ > פתח ובחר פרויקט קיים.

כדי ליצור פרויקט פיתוח בסיסי של אנדרואיד:

למידע נוסף על השימוש ב-Android Studio, עיין בתיעוד של Android Studio .

הוסף תלות בפרויקט

ביישום משלך, עליך להוסיף תלות ספציפית בפרויקט כדי להפעיל מודלים של למידה חישובית של TensorFlow Lite, ולגשת לפונקציות שירות הממירות נתונים כגון מחרוזות, לפורמט נתוני טנסור שניתן לעבד על ידי המודל שבו אתה משתמש.

ההוראות הבאות מסבירות כיצד להוסיף את התלות הנדרשת בפרויקט ובמודול לפרויקט אפליקציית Android משלך.

כדי להוסיף תלות במודול:

  1. במודול המשתמש ב-TensorFlow Lite, עדכן את קובץ build.gradle של המודול כך שיכלול את התלות הבאה.

    ביישום לדוגמה, התלות ממוקמות ב- app/build.gradle :

    dependencies {
  ...
  implementation 'org.tensorflow:tensorflow-lite-task-text:0.4.0'
}

    הפרויקט חייב לכלול את ספריית המשימות Text ( tensorflow-lite-task-text ).

    אם ברצונך לשנות את האפליקציה הזו כך שתפעל על יחידת עיבוד גרפית (GPU), ספריית ה-GPU ( tensorflow-lite-gpu-delegate-plugin ) מספקת את התשתית להפעלת האפליקציה על GPU, ו-Delegate ( tensorflow-lite-gpu ) מספק את רשימת התאימות. הפעלת אפליקציה זו על GPU היא מחוץ לתחום של מדריך זה.

  2. ב-Android Studio, סנכרן את התלות בפרויקט על ידי בחירה: קובץ > סנכרן פרויקט עם קבצי Gradle .

אתחל את דגמי ה-ML

באפליקציית האנדרואיד שלך, עליך לאתחל את מודל הלמידה המכונה TensorFlow Lite עם פרמטרים לפני הפעלת תחזיות עם המודל.

דגם TensorFlow Lite מאוחסן כקובץ *.tflite . קובץ המודל מכיל את לוגיקת החיזוי ובדרך כלל כולל מטא נתונים לגבי אופן הפירוש של תוצאות חיזוי, כגון שמות מחלקות חיזוי. בדרך כלל, קבצי המודל מאוחסנים בספריית src/main/assets של פרויקט הפיתוח שלך, כמו בדוגמה של הקוד:

  • <project>/src/main/assets/mobilebert.tflite
  • <project>/src/main/assets/wordvec.tflite

מטעמי נוחות וקריאות קוד, הדוגמה מצהירה על אובייקט נלווה המגדיר את ההגדרות עבור המודל.

כדי לאתחל את הדגם באפליקציה שלך:

  1. צור אובייקט נלווה כדי להגדיר את ההגדרות עבור המודל. ביישום לדוגמה, אובייקט זה ממוקם ב- TextClassificationHelper.kt :

    companion object {
  const val DELEGATE_CPU = 0
  const val DELEGATE_NNAPI = 1
  const val WORD_VEC = "wordvec.tflite"
  const val MOBILEBERT = "mobilebert.tflite"
}

  2. צור את ההגדרות עבור המודל על ידי בניית אובייקט מסווג, ובנה אובייקט TensorFlow Lite באמצעות BertNLClassifier או NLClassifier .

    ביישום לדוגמה, זה ממוקם בפונקציה initClassifier בתוך TextClassificationHelper.kt :

    fun initClassifier() {
  ...
  if( currentModel == MOBILEBERT ) {
    ...
    bertClassifier = BertNLClassifier.createFromFileAndOptions(
      context,
      MOBILEBERT,
      options)
  } else if (currentModel == WORD_VEC) {
      ...
      nlClassifier = NLClassifier.createFromFileAndOptions(
        context,
        WORD_VEC,
        options)
  }
}

אפשר האצת חומרה (אופציונלי)

בעת אתחול מודל TensorFlow Lite באפליקציה שלך, עליך לשקול להשתמש בתכונות האצת חומרה כדי להאיץ את חישובי הניבוי של המודל. נציגי TensorFlow Lite הם מודולי תוכנה המאיצים את הביצוע של מודלים של למידת מכונה באמצעות חומרת עיבוד מיוחדת במכשיר נייד, כגון יחידות עיבוד גרפיות (GPU) או יחידות עיבוד טנזור (TPUs).

כדי להפעיל האצת חומרה באפליקציה שלך:

  1. צור משתנה כדי להגדיר את הנציג שבו האפליקציה תשתמש. ביישום לדוגמה, משתנה זה ממוקם מוקדם ב- TextClassificationHelper.kt :

    var currentDelegate: Int = 0

  2. צור בורר נציגים. ביישום לדוגמה, בורר הנציגים ממוקם בפונקציה initClassifier בתוך TextClassificationHelper.kt :

    val baseOptionsBuilder = BaseOptions.builder()
when (currentDelegate) {
   DELEGATE_CPU -> {
       // Default
   }
   DELEGATE_NNAPI -> {
       baseOptionsBuilder.useNnapi()
   }
}

מומלץ להשתמש בנציגים להפעלת דגמי TensorFlow Lite, אך לא חובה. למידע נוסף על שימוש בנציגים עם TensorFlow Lite, ראה TensorFlow Lite Delegates .

הכן נתונים עבור המודל

באפליקציית Android שלך, הקוד שלך מספק נתונים למודל לצורך פרשנות על ידי הפיכת נתונים קיימים כגון טקסט גולמי לפורמט נתוני Tensor שניתן לעבד על ידי המודל שלך. הנתונים ב-Tensor שאתה מעביר למודל חייבים להיות בעלי ממדים ספציפיים, או צורה, התואמים את הפורמט של הנתונים המשמשים לאימון המודל.

אפליקציית סיווג טקסט זו מקבלת מחרוזת כקלט , והדגמים מאומנים אך ורק על קורפוס בשפה האנגלית. תווים מיוחדים ומילים שאינן באנגלית מתעלמים במהלך ההסקה.

כדי לספק נתוני טקסט למודל:

  1. ודא שהפונקציה initClassifier מכילה את הקוד עבור הנציג והדגמים, כפי שהוסבר בסעיפים אתחול את דגמי ה-ML ואפשר האצת חומרה .

  2. השתמש בבלוק init כדי לקרוא לפונקציה initClassifier . ביישום לדוגמה, ה- init ממוקם ב- TextClassificationHelper.kt :

    init {
  initClassifier()
}

הפעל תחזיות

באפליקציית האנדרואיד שלך, לאחר שאתחול אובייקט BertNLClassifier או NLClassifier , אתה יכול להתחיל להזין טקסט קלט עבור המודל כדי לסווג אותו כ"חיובי" או "שלילי".

כדי להפעיל תחזיות:

  1. צור פונקציית classify , המשתמשת במסווג שנבחר ( currentModel ) ומודד את הזמן שנדרש לסיווג טקסט הקלט ( inferenceTime ). ביישום לדוגמה, פונקציית classify ממוקמת ב- TextClassificationHelper.kt :

    fun classify(text: String) {
  executor = ScheduledThreadPoolExecutor(1)

  executor.execute {
    val results: List<Category>
    // inferenceTime is the amount of time, in milliseconds, that it takes to
    // classify the input text.
    var inferenceTime = SystemClock.uptimeMillis()

    // Use the appropriate classifier based on the selected model
    if(currentModel == MOBILEBERT) {
      results = bertClassifier.classify(text)
    } else {
      results = nlClassifier.classify(text)
    }

    inferenceTime = SystemClock.uptimeMillis() - inferenceTime

    listener.onResult(results, inferenceTime)
  }
}

  2. העבירו את התוצאות classify לאובייקט המאזין.

    fun classify(text: String) {
  ...
  listener.onResult(results, inferenceTime)
}

ידית פלט דגם

לאחר הזנת שורת טקסט, המודל מייצר ציון חיזוי, המבוטא כצף, בין 0 ל-1 עבור הקטגוריות 'חיוביות' ו'שליליות'.

כדי לקבל את תוצאות החיזוי מהמודל:

  1. צור פונקציה onResult עבור אובייקט המאזין כדי לטפל בפלט. ביישום לדוגמה, אובייקט המאזין ממוקם ב- MainActivity.kt

    private val listener = object : TextClassificationHelper.TextResultsListener {
  override fun onResult(results: List<Category>, inferenceTime: Long) {
    runOnUiThread {
      activityMainBinding.bottomSheetLayout.inferenceTimeVal.text =
        String.format("%d ms", inferenceTime)

      adapter.resultsList = results.sortedByDescending {
        it.score
      }

      adapter.notifyDataSetChanged()
    }
  }
  ...
}

  2. הוסף פונקציה onError לאובייקט המאזין כדי לטפל בשגיאות:

      private val listener = object : TextClassificationHelper.TextResultsListener {
    ...
    override fun onError(error: String) {
      Toast.makeText(this@MainActivity, error, Toast.LENGTH_SHORT).show()
    }
  }

לאחר שהמודל החזיר קבוצה של תוצאות חיזוי, האפליקציה שלך יכולה לפעול לפי התחזיות האלה על ידי הצגת התוצאה למשתמש שלך או הפעלת היגיון נוסף. היישום לדוגמה מפרט את ציוני החיזוי בממשק המשתמש.

הצעדים הבאים