Android पर एमएल किट की मदद से डिजिटल इंक की पहचान करना

ML Kit की डिजिटल इंक पहचानने की सुविधा से, सैकड़ों भाषाओं में किसी डिजिटल प्लैटफ़ॉर्म पर हाथ से लिखे गए टेक्स्ट की पहचान की जा सकती है. साथ ही, स्केच की कैटगरी तय की जा सकती है.

इसे आज़माएं

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

  1. प्रोजेक्ट-लेवल की build.gradle फ़ाइल में, अपने buildscript और allprojects, दोनों सेक्शन में Google की Maven रिपॉज़िटरी को शामिल करना न भूलें.
  2. अपने मॉड्यूल की ऐप्लिकेशन-लेवल की Gradle फ़ाइल में, ML Kit Android लाइब्रेरी के लिए डिपेंडेंसी जोड़ें. आम तौर पर, यह app/build.gradle होती है:
dependencies {
  // ...
  implementation 'com.google.mlkit:digital-ink-recognition:18.1.0'
}

अब आप Ink ऑब्जेक्ट में टेक्स्ट को पहचानने के लिए तैयार हैं.

कोई Ink ऑब्जेक्ट बनाएं

Ink ऑब्जेक्ट को बनाने का मुख्य तरीका यह है कि उसे टचस्क्रीन पर बनाया जाए. Android पर, इस काम के लिए कैनवस का इस्तेमाल किया जा सकता है. आपके टच इवेंट हैंडलर को उपयोगकर्ता के बनाए गए Ink ऑब्जेक्ट में स्ट्रोक में पॉइंट सेव करने के लिए, नीचे दिए गए कोड स्निपेट में दिखाए गए addNewTouchEvent() तरीके को कॉल करना चाहिए.

यह सामान्य पैटर्न, नीचे दिए गए कोड स्निपेट में दिखाया गया है. ज़्यादा उदाहरण के लिए, एमएल किट का क्विकस्टार्ट सैंपल देखें.

Kotlin

var inkBuilder = Ink.builder()
lateinit var strokeBuilder: Ink.Stroke.Builder

// Call this each time there is a new event.
fun addNewTouchEvent(event: MotionEvent) {
  val action = event.actionMasked
  val x = event.x
  val y = event.y
  var t = System.currentTimeMillis()

  // If your setup does not provide timing information, you can omit the
  // third paramater (t) in the calls to Ink.Point.create
  when (action) {
    MotionEvent.ACTION_DOWN -> {
      strokeBuilder = Ink.Stroke.builder()
      strokeBuilder.addPoint(Ink.Point.create(x, y, t))
    }
    MotionEvent.ACTION_MOVE -> strokeBuilder!!.addPoint(Ink.Point.create(x, y, t))
    MotionEvent.ACTION_UP -> {
      strokeBuilder.addPoint(Ink.Point.create(x, y, t))
      inkBuilder.addStroke(strokeBuilder.build())
    }
    else -> {
      // Action not relevant for ink construction
    }
  }
}

...

// This is what to send to the recognizer.
val ink = inkBuilder.build()

Java

Ink.Builder inkBuilder = Ink.builder();
Ink.Stroke.Builder strokeBuilder;

// Call this each time there is a new event.
public void addNewTouchEvent(MotionEvent event) {
  float x = event.getX();
  float y = event.getY();
  long t = System.currentTimeMillis();

  // If your setup does not provide timing information, you can omit the
  // third paramater (t) in the calls to Ink.Point.create
  int action = event.getActionMasked();
  switch (action) {
    case MotionEvent.ACTION_DOWN:
      strokeBuilder = Ink.Stroke.builder();
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      break;
    case MotionEvent.ACTION_MOVE:
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      break;
    case MotionEvent.ACTION_UP:
      strokeBuilder.addPoint(Ink.Point.create(x, y, t));
      inkBuilder.addStroke(strokeBuilder.build());
      strokeBuilder = null;
      break;
  }
}

...

// This is what to send to the recognizer.
Ink ink = inkBuilder.build();

DigitalInkRecognizer का इंस्टेंस पाएं

पहचान करने के लिए, Ink इंस्टेंस को किसी DigitalInkRecognizer ऑब्जेक्ट पर भेजें. नीचे दिए गए कोड में बताया गया है कि ऐसे आइडेंटिफ़ायर को BCP-47 टैग से कैसे इंस्टैंशिएट किया जा सकता है.

Kotlin

// Specify the recognition model for a language
var modelIdentifier: DigitalInkRecognitionModelIdentifier
try {
  modelIdentifier = DigitalInkRecognitionModelIdentifier.fromLanguageTag("en-US")
} catch (e: MlKitException) {
  // language tag failed to parse, handle error.
}
if (modelIdentifier == null) {
  // no model was found, handle error.
}
var model: DigitalInkRecognitionModel =
    DigitalInkRecognitionModel.builder(modelIdentifier).build()


// Get a recognizer for the language
var recognizer: DigitalInkRecognizer =
    DigitalInkRecognition.getClient(
        DigitalInkRecognizerOptions.builder(model).build())

Java

// Specify the recognition model for a language
DigitalInkRecognitionModelIdentifier modelIdentifier;
try {
  modelIdentifier =
    DigitalInkRecognitionModelIdentifier.fromLanguageTag("en-US");
} catch (MlKitException e) {
  // language tag failed to parse, handle error.
}
if (modelIdentifier == null) {
  // no model was found, handle error.
}

DigitalInkRecognitionModel model =
    DigitalInkRecognitionModel.builder(modelIdentifier).build();

// Get a recognizer for the language
DigitalInkRecognizer recognizer =
    DigitalInkRecognition.getClient(
        DigitalInkRecognizerOptions.builder(model).build());

Ink ऑब्जेक्ट को प्रोसेस करें

Kotlin

recognizer.recognize(ink)
    .addOnSuccessListener { result: RecognitionResult ->
      // `result` contains the recognizer's answers as a RecognitionResult.
      // Logs the text from the top candidate.
      Log.i(TAG, result.candidates[0].text)
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error during recognition: $e")
    }

Java

recognizer.recognize(ink)
    .addOnSuccessListener(
        // `result` contains the recognizer's answers as a RecognitionResult.
        // Logs the text from the top candidate.
        result -> Log.i(TAG, result.getCandidates().get(0).getText()))
    .addOnFailureListener(
        e -> Log.e(TAG, "Error during recognition: " + e));

ऊपर दिया गया सैंपल कोड यह मानता है कि पहचान मॉडल को पहले ही डाउनलोड किया जा चुका है, जैसा कि अगले सेक्शन में बताया गया है.

मॉडल डाउनलोड मैनेज करना

डिजिटल इंक पहचानने वाला एपीआई सैकड़ों भाषाओं के साथ काम करता है. हालांकि, हर भाषा के लिए पहचान करने से पहले कुछ डेटा डाउनलोड करने की ज़रूरत होती है. हर भाषा के लिए करीब 20 एमबी स्टोरेज की ज़रूरत होती है. इसे RemoteModelManager ऑब्जेक्ट, मैनेज करता है.

नया मॉडल डाउनलोड करें

Kotlin

import com.google.mlkit.common.model.DownloadConditions
import com.google.mlkit.common.model.RemoteModelManager

var model: DigitalInkRecognitionModel =  ...
val remoteModelManager = RemoteModelManager.getInstance()

remoteModelManager.download(model, DownloadConditions.Builder().build())
    .addOnSuccessListener {
      Log.i(TAG, "Model downloaded")
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error while downloading a model: $e")
    }

Java

import com.google.mlkit.common.model.DownloadConditions;
import com.google.mlkit.common.model.RemoteModelManager;

DigitalInkRecognitionModel model = ...;
RemoteModelManager remoteModelManager = RemoteModelManager.getInstance();

remoteModelManager
    .download(model, new DownloadConditions.Builder().build())
    .addOnSuccessListener(aVoid -> Log.i(TAG, "Model downloaded"))
    .addOnFailureListener(
        e -> Log.e(TAG, "Error while downloading a model: " + e));

यह देखना कि मॉडल पहले से डाउनलोड है या नहीं

Kotlin

var model: DigitalInkRecognitionModel =  ...
remoteModelManager.isModelDownloaded(model)

Java

DigitalInkRecognitionModel model = ...;
remoteModelManager.isModelDownloaded(model);

डाउनलोड किए गए मॉडल को मिटाना

डिवाइस के स्टोरेज से किसी मॉडल को हटाने पर, स्टोरेज खाली हो जाता है.

Kotlin

var model: DigitalInkRecognitionModel =  ...
remoteModelManager.deleteDownloadedModel(model)
    .addOnSuccessListener {
      Log.i(TAG, "Model successfully deleted")
    }
    .addOnFailureListener { e: Exception ->
      Log.e(TAG, "Error while deleting a model: $e")
    }

Java

DigitalInkRecognitionModel model = ...;
remoteModelManager.deleteDownloadedModel(model)
                  .addOnSuccessListener(
                      aVoid -> Log.i(TAG, "Model successfully deleted"))
                  .addOnFailureListener(
                      e -> Log.e(TAG, "Error while deleting a model: " + e));

टेक्स्ट की पहचान करने की सुविधा को बेहतर बनाने के लिए सलाह

टेक्स्ट की पहचान कितनी सटीक है, यह अलग-अलग भाषाओं के हिसाब से अलग-अलग हो सकती है. कितना सटीक है, यह लिखने के तरीके पर भी निर्भर करता है. हालांकि, डिजिटल इंक रिकग्निशन को लिखने के कई तरह के स्टाइल को हैंडल करने के लिए ट्रेन किया गया है, लेकिन हर उपयोगकर्ता के लिए नतीजे अलग-अलग हो सकते हैं.

टेक्स्ट आइडेंटिफ़ायर को ज़्यादा सटीक बनाने के कुछ तरीके यहां दिए गए हैं. ध्यान रखें कि ये तकनीकें, इमोजी, ऑटोड्रॉ, और आकृतियों के लिए ड्रॉइंग क्लासिफ़ायर पर लागू नहीं होतीं.

लिखने का क्षेत्र

कई ऐप्लिकेशन में उपयोगकर्ताओं के इनपुट के लिए, लिखने का अच्छा तरीका होता है. किसी चिह्न का मतलब कुछ हद तक उसके साइज़ से तय होता है. यह साइज़, उस जगह के साइज़ से तय होता है जिसमें वह मौजूद होता है. उदाहरण के लिए, लोअर या अपर केस में "o" या "c" का और कॉमा बनाम फ़ॉरवर्ड स्लैश.

आइडेंटिफ़ायर को लिखने के लिए चुनी गई जगह की चौड़ाई और ऊंचाई के बारे में बताने से, टेक्स्ट को ज़्यादा सटीक बनाया जा सकता है. हालांकि, आइडेंटिफ़ायर यह मानता है कि राइटिंग एरिया में टेक्स्ट की सिर्फ़ एक लाइन है. अगर फ़िज़िकल राइटिंग एरिया इतना बड़ा है कि उपयोगकर्ता दो या उससे ज़्यादा लाइनें लिख सकता है, तो आपको राइटिंग एरिया में ऐसी ऊंचाई पास करके बेहतर नतीजे मिल सकते हैं जो टेक्स्ट की एक लाइन की ऊंचाई का सबसे सही अनुमान है. आइडेंटिफ़ायर को पास की जाने वाली राइटिंगएरिया ऑब्जेक्ट, स्क्रीन पर मौजूद जगह के हिसाब से होना ज़रूरी नहीं है. इस तरह राइटिंग एरिया की ऊंचाई बदलने से कुछ भाषाओं के मुकाबले अन्य भाषाओं में यह बेहतर तरीके से काम करता है.

लिखने का क्षेत्र तय करते समय, इसकी चौड़ाई और ऊंचाई की जानकारी उन इकाइयों में दें जो स्ट्रोक निर्देशांकों में दी गई हैं. x,y कोऑर्डिनेट आर्ग्युमेंट के लिए किसी यूनिट की ज़रूरत नहीं होती - एपीआई सभी इकाइयों को सामान्य बनाता है. इसलिए, स्ट्रोक के साइज़ और पोज़िशन की जानकारी मायने रखती है. आपके सिस्टम के लिए जो भी स्केल सही है उसमें आप निर्देशांकों को शामिल करने के लिए स्वतंत्र हैं.

कॉन्टेक्स्ट से पहले

प्री-कॉन्टेक्स्ट, वह टेक्स्ट होता है जो Ink में स्ट्रोक के ठीक पहले आता है. साथ ही, इसे पहचानने की कोशिश की जा रही होती है. पहचान करने वाले को पहले संदर्भ के बारे में बताकर उसकी मदद की जा सकती है.

उदाहरण के लिए, कर्सिव अक्षर "n" और "u" को गलती से एक-दूसरे से जोड़ दिया जाता है. अगर उपयोगकर्ता ने पहले से ही आंशिक शब्द "आर्ग" डाल दिया है, तो वे ऐसे स्ट्रोक के साथ जारी रख सकते हैं जिन्हें "ument" या "nment" के तौर पर पहचाना जा सके. प्री-कॉन्टेक्स्ट "आर्ग" तय करने से, शब्द साफ़ तौर पर समझ नहीं आता. ऐसा इसलिए, क्योंकि "तर्क" की तुलना में, "तर्क" शब्द ज़्यादा होने की संभावना है.

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

आपको प्री-कॉन्टेक्स्ट की सबसे लंबी स्ट्रिंग देनी चाहिए. इसमें 20 वर्ण हो सकते हैं. इसमें स्पेस भी होने चाहिए. अगर स्ट्रिंग लंबी है, तो आइडेंटिफ़ायर आखिरी 20 वर्णों का ही इस्तेमाल करता है.

नीचे दिए गए कोड सैंपल में बताया गया है कि लिखने की जगह कैसे तय की जाए. साथ ही, प्री-कॉन्टेक्स्ट तय करने के लिए, RecognitionContext ऑब्जेक्ट का इस्तेमाल कैसे किया जाए.

Kotlin

var preContext : String = ...;
var width : Float = ...;
var height : Float = ...;
val recognitionContext : RecognitionContext =
    RecognitionContext.builder()
        .setPreContext(preContext)
        .setWritingArea(WritingArea(width, height))
        .build()

recognizer.recognize(ink, recognitionContext)

Java

String preContext = ...;
float width = ...;
float height = ...;
RecognitionContext recognitionContext =
    RecognitionContext.builder()
                      .setPreContext(preContext)
                      .setWritingArea(new WritingArea(width, height))
                      .build();

recognizer.recognize(ink, recognitionContext);

स्ट्रोक का क्रम

पहचान की सटीक जानकारी, स्ट्रोक के क्रम पर निर्भर करती है. पहचान करने वाले लोग उम्मीद करते हैं कि स्ट्रोक उसी क्रम में होने चाहिए जिस क्रम में लोग स्वाभाविक रूप से लिखेंगे. उदाहरण के लिए, अंग्रेज़ी के लिए लेफ़्ट-टू-राइट. अगर कोई केस इस पैटर्न से अलग होता है, जैसे कि आखिरी शब्द से शुरू होने वाला अंग्रेज़ी वाक्य लिखना, तो नतीजे सटीक नहीं होते.

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

साफ़-साफ़ जानकारी न देने वाले आकारों से निपटना

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

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