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 पर, इस काम के लिए कैनवस का इस्तेमाल किया जा सकता है. आपका टच इवेंट हैंडलर addNewTouchEvent() पर कॉल करना चाहिए स्ट्रोक में पॉइंट स्टोर करने के लिए, नीचे दिए गए कोड स्निपेट को दिखाने का तरीका उपयोगकर्ता Ink ऑब्जेक्ट में ले जाता है.

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

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

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 टैग से इस तरह के रेकग्निज़र को इंस्टैंशिएट करने का तरीका बताया गया है.

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

// 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 ऑब्जेक्ट प्रोसेस करें

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")
    }

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 ऑब्जेक्ट मैनेज करता है.

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

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")
    }

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

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

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

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

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

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

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")
    }

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

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

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

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

प्री-कॉन्टेक्स्ट, वह टेक्स्ट है जो Ink में स्ट्रोक से ठीक पहले होता है को पहचानने की कोशिश कर रहे हैं. बोली पहचानने की सुविधा को बेहतर बनाने के लिए, बोली से पहले की बातचीत के बारे में बताएं.

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

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

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

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

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)

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