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

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

यह एपीआई, मांग में डाइनैमिक मॉडल के डाउनलोड की सुविधा पर काम करता है. ज़्यादा जानकारी के लिए यह गाइड देखें.

इसे आज़माएं

• इस एपीआई के इस्तेमाल का उदाहरण देखने के लिए, ऐप्लिकेशन के नमूने का इस्तेमाल करें.

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

इस API के लिए Android API लेवल 19 या उसके बाद का वर्शन होना ज़रूरी है. पक्का करें कि आपके ऐप्लिकेशन की बिल्ड फ़ाइल में, minSdkVersion की 19 या उसके बाद की वैल्यू इस्तेमाल हो.

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

dependencies {
  // ...
  implementation 'com.google.mlkit:digital-ink-recognition:18.1.0'
}

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

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

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

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

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();

DigitalInkRecognitionr का उदाहरण पाएं

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

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

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

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

पहले से संदर्भ वह टेक्स्ट होता है जो Ink में दिए गए स्ट्रोक से ठीक पहले मिलता है. आप पहचान करने वाली जानकारी देकर, उसकी पुष्टि करने में मदद कर सकते हैं.

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

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