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

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

इसे आज़माएं

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

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

अब Ink ऑब्जेक्ट में मौजूद टेक्स्ट को पहचाना जा सकता है.

Ink ऑब्जेक्ट बनाना

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

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

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" के बीच का अंतर, और कॉमा बनाम फ़ॉरवर्ड स्लैश.

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

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

प्री-कॉन्टेक्स्ट

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

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

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

आपको प्री-कॉन्टेक्स्ट स्ट्रिंग की सबसे लंबी वैल्यू देनी चाहिए. इसमें स्पेस के साथ-साथ ज़्यादा से ज़्यादा 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 में एक आयत और एक अंडाकार एक-दूसरे के बगल में मौजूद हैं, तो पहचान करने वाला टूल, नतीजे के तौर पर इनमें से कोई एक या कोई बिलकुल अलग आकार दिखा सकता है. ऐसा इसलिए, क्योंकि पहचान के लिए एक ही उम्मीदवार दो आकृतियों को नहीं दिखा सकता.