इस पेज का अनुवाद Cloud Translation API से किया गया है.

इमेज में मौजूद ऑब्जेक्ट का पता लगाने के लिए Android ऐप्लिकेशन बनाना

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

इस कोडलैब में, Android ऐप्लिकेशन से ऑब्जेक्ट-डिटेक्शन इन्फ़्रेंस चलाने का तरीका बताया गया है. इसके लिए, REST और gRPC के साथ TensorFlow Serving का इस्तेमाल किया जाता है.

ज़रूरी शर्तें

Java का इस्तेमाल करके Android ऐप्लिकेशन डेवलपमेंट की बुनियादी जानकारी
TensorFlow के साथ मशीन लर्निंग की बुनियादी जानकारी, जैसे कि ट्रेनिंग और डिप्लॉयमेंट
टर्मिनल और Docker की बुनियादी जानकारी

आपको क्या सीखने को मिलेगा

TensorFlow Hub पर, ऑब्जेक्ट का पता लगाने वाले पहले से ट्रेन किए गए मॉडल ढूंढने का तरीका.
TensorFlow Serving (REST और gRPC) की मदद से, डाउनलोड किए गए ऑब्जेक्ट डिटेक्शन मॉडल का इस्तेमाल करके, एक सामान्य Android ऐप्लिकेशन बनाने और अनुमान लगाने का तरीका.
यूज़र इंटरफ़ेस (यूआई) में, पहचान के नतीजे को रेंडर करने का तरीका.

आपको किन चीज़ों की ज़रूरत होगी

Android Studio का नया वर्शन
Docker
Bash

2. सेट अप करें

इस कोडलैब के लिए कोड डाउनलोड करने के लिए:

इस कोडलैब के लिए, GitHub रिपॉज़िटरी पर जाएं.
इस कोडलैब के सभी कोड डाउनलोड करने के लिए, कोड > ज़िप फ़ाइल डाउनलोड करें पर क्लिक करें.

डाउनलोड की गई zip फ़ाइल को अनज़िप करें, ताकि आपको अपनी ज़रूरत के सभी संसाधनों के साथ codelabs रूट फ़ोल्डर मिल सके.

इस कोडलैब के लिए, आपको सिर्फ़ रिपॉज़िटरी में मौजूद TFServing/ObjectDetectionAndroid सबडायरेक्ट्री की फ़ाइलों की ज़रूरत होगी. इसमें दो फ़ोल्डर शामिल हैं:

starter फ़ोल्डर में, स्टार्टर कोड होता है. इस कोडलैब के लिए, आपको इसी कोड का इस्तेमाल करना है.
finished फ़ोल्डर में, तैयार किए गए सैंपल ऐप्लिकेशन का पूरा कोड होता है.

3. प्रोजेक्ट में डिपेंडेंसी जोड़ना

स्टार्टर ऐप्लिकेशन को Android Studio में इंपोर्ट करना

Android Studio में, File > New > Import project पर क्लिक करें. इसके बाद, सोर्स कोड से डाउनलोड किया गया starter फ़ोल्डर चुनें.

OkHttp और gRPC के लिए डिपेंडेंसी जोड़ना

अपने प्रोजेक्ट की app/build.gradle फ़ाइल में, डिपेंडेंसी की मौजूदगी की पुष्टि करें.

dependencies {
  // ...
    implementation 'com.squareup.okhttp3:okhttp:4.9.0'
    implementation 'javax.annotation:javax.annotation-api:1.3.2'
    implementation 'io.grpc:grpc-okhttp:1.29.0'
    implementation 'io.grpc:grpc-protobuf-lite:1.29.0'
    implementation 'io.grpc:grpc-stub:1.29.0'
}

अपने प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करना

नेविगेशन मेन्यू से, Gradle फ़ाइलों के साथ प्रोजेक्ट सिंक करें को चुनें.

4. स्टार्टर ऐप्लिकेशन चलाना

Android Emulator शुरू करें. इसके बाद,नेविगेशन मेन्यू में 'app' चलाएं पर क्लिक करें.

ऐप्लिकेशन को चलाना और उसके बारे में ज़्यादा जानना

ऐप्लिकेशन आपके Android डिवाइस पर लॉन्च होना चाहिए. यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करना बहुत आसान है: इसमें एक बिल्ली की इमेज है, जिसमें आपको ऑब्जेक्ट का पता लगाना है. साथ ही, उपयोगकर्ता REST या gRPC की मदद से, डेटा को बैकएंड में भेजने का तरीका चुन सकता है. बैकएंड, इमेज में मौजूद ऑब्जेक्ट का पता लगाता है. इसके बाद, क्लाइंट ऐप्लिकेशन को ऑब्जेक्ट का पता लगाने से जुड़े नतीजे भेजता है. क्लाइंट ऐप्लिकेशन, यूज़र इंटरफ़ेस (यूआई) को फिर से रेंडर करता है.

फ़िलहाल, अनुमान लगाएं पर क्लिक करने से कुछ नहीं होता. ऐसा इसलिए है, क्योंकि यह अब तक बैकएंड से कम्यूनिकेट नहीं कर सकता.

5. TensorFlow Serving की मदद से, ऑब्जेक्ट का पता लगाने वाले मॉडल को डिप्लॉय करना

ऑब्जेक्ट का पता लगाना, एमएल का एक बहुत ही सामान्य टास्क है. इसका मकसद, इमेज में मौजूद ऑब्जेक्ट का पता लगाना है. इसका मतलब है कि ऑब्जेक्ट की संभावित कैटगरी और उनके आस-पास के बाउंडिंग बॉक्स का अनुमान लगाना. यहां पहचान के नतीजे का एक उदाहरण दिया गया है:

Google ने TensorFlow Hub पर पहले से ट्रेन किए गए कई मॉडल पब्लिश किए हैं. पूरी सूची देखने के लिए, object_detection पेज पर जाएं. इस कोडलैब के लिए, SSD MobileNet V2 FPNLite 320x320 मॉडल का इस्तेमाल किया जाता है. यह मॉडल, अन्य मॉडल की तुलना में कम मेमोरी लेता है. इसलिए, इसे चलाने के लिए आपको GPU का इस्तेमाल करने की ज़रूरत नहीं होती.

TensorFlow Serving की मदद से, ऑब्जेक्ट का पता लगाने वाले मॉडल को डिप्लॉय करने के लिए:

मॉडल फ़ाइल डाउनलोड करें.
डाउनलोड की गई .tar.gz फ़ाइल को अनकंप्रेस करने वाले टूल, जैसे कि 7-Zip की मदद से अनकंप्रेस करें.
एक ssd_mobilenet_v2_2_320 फ़ोल्डर बनाएं. इसके बाद, इसके अंदर एक 123 सबफ़ोल्डर बनाएं.
एक्सट्रैक्ट किए गए variables फ़ोल्डर और saved_model.pb फ़ाइल को 123 सब-फ़ोल्डर में डालें.

ssd_mobilenet_v2_2_320 फ़ोल्डर को SavedModel फ़ोल्डर के तौर पर इस्तेमाल किया जा सकता है. 123 वर्शन नंबर का एक उदाहरण है. अगर आपको कोई और नंबर चाहिए, तो उसे चुना जा सकता है.

फ़ोल्डर का स्ट्रक्चर, इस इमेज जैसा होना चाहिए:

TensorFlow Serving शुरू करना

अपने टर्मिनल में, Docker की मदद से TensorFlow Serving शुरू करें. हालांकि, PATH/TO/SAVEDMODEL प्लेसहोल्डर को अपने कंप्यूटर पर मौजूद ssd_mobilenet_v2_2_320 फ़ोल्डर के पूरे पाथ से बदलें.

docker pull tensorflow/serving

docker run -it --rm -p 8500:8500 -p 8501:8501 -v "PATH/TO/SAVEDMODEL:/models/ssd_mobilenet_v2_2" -e MODEL_NAME=ssd_mobilenet_v2_2 tensorflow/serving

Docker, TensorFlow Serving की इमेज को अपने-आप डाउनलोड करता है. इसमें एक मिनट लगता है. इसके बाद, TensorFlow Serving शुरू हो जाना चाहिए. लॉग, इस कोड स्निपेट जैसा दिखना चाहिए:

2022-02-25 06:01:12.513231: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-02-25 06:01:12.585012: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 3000000000 Hz
2022-02-25 06:01:13.395083: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/ssd_mobilenet_v2_2/123
2022-02-25 06:01:13.837562: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 1928700 microseconds.
2022-02-25 06:01:13.877848: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/ssd_mobilenet_v2_2/123/assets.extra/tf_serving_warmup_requests
2022-02-25 06:01:13.929844: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: ssd_mobilenet_v2_2 version: 123}
2022-02-25 06:01:13.985848: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-02-25 06:01:13.985987: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-02-25 06:01:13.988994: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-02-25 06:01:14.033872: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

6. REST के ज़रिए Android ऐप्लिकेशन को TensorFlow Serving से कनेक्ट करना

बैकएंड अब तैयार है. इसलिए, इमेज में मौजूद ऑब्जेक्ट का पता लगाने के लिए, TensorFlow Serving को क्लाइंट के अनुरोध भेजे जा सकते हैं. TensorFlow Serving को अनुरोध भेजने के दो तरीके हैं:

REST
gRPC

REST के ज़रिए अनुरोध भेजना और जवाब पाना

इसके लिए, ये तीन आसान चरण पूरे करें:

REST अनुरोध बनाएं.
TensorFlow Serving को REST अनुरोध भेजें.
REST रिस्पॉन्स से अनुमानित नतीजे को एक्सट्रैक्ट करें और यूज़र इंटरफ़ेस (यूआई) रेंडर करें.

आपको ये MainActivity.java. में मिलेंगी

REST अनुरोध बनाना

फ़िलहाल, MainActivity.java फ़ाइल में एक खाली createRESTRequest() फ़ंक्शन मौजूद है. REST अनुरोध बनाने के लिए, इस फ़ंक्शन को लागू करें.

private Request createRESTRequest() {
}

TensorFlow Serving को एक POST अनुरोध की ज़रूरत होती है. इसमें आपके इस्तेमाल किए गए SSD MobileNet मॉडल के लिए इमेज टेंसर होता है. इसलिए, आपको इमेज के हर पिक्सल से आरजीबी वैल्यू को एक ऐरे में निकालना होगा. इसके बाद, ऐरे को JSON में रैप करना होगा. यह अनुरोध का पेलोड होता है.

इस कोड को createRESTRequest() फ़ंक्शन में जोड़ें:

//Create the REST request.
int[] inputImg = new int[INPUT_IMG_HEIGHT * INPUT_IMG_WIDTH];
int[][][][] inputImgRGB = new int[1][INPUT_IMG_HEIGHT][INPUT_IMG_WIDTH][3];
inputImgBitmap.getPixels(inputImg, 0, INPUT_IMG_WIDTH, 0, 0, INPUT_IMG_WIDTH, INPUT_IMG_HEIGHT);
int pixel;
for (int i = 0; i < INPUT_IMG_HEIGHT; i++) {
    for (int j = 0; j < INPUT_IMG_WIDTH; j++) {
    // Extract RBG values from each pixel; alpha is ignored
    pixel = inputImg[i * INPUT_IMG_WIDTH + j];
    inputImgRGB[0][i][j][0] = ((pixel >> 16) & 0xff);
    inputImgRGB[0][i][j][1] = ((pixel >> 8) & 0xff);
    inputImgRGB[0][i][j][2] = ((pixel) & 0xff);
    }
}

RequestBody requestBody =
    RequestBody.create("{\"instances\": " + Arrays.deepToString(inputImgRGB) + "}", JSON);

Request request =
    new Request.Builder()
        .url("http://" + SERVER + ":" + REST_PORT + "/v1/models/" + MODEL_NAME + ":predict")
        .post(requestBody)
        .build();

return request;

TensorFlow Serving को REST अनुरोध भेजना

यह ऐप्लिकेशन, उपयोगकर्ता को TensorFlow Serving से कम्यूनिकेट करने के लिए REST या gRPC चुनने की सुविधा देता है. इसलिए, onClick(View view) लिसनर में दो ब्रांच होती हैं.

predictButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            if (requestRadioGroup.getCheckedRadioButtonId() == R.id.rest) {
                // TODO: REST request
            }
            else {

            }
        }
    }
)

TensorFlow Serving को अनुरोध भेजने के लिए, OkHttp का इस्तेमाल करने के लिए, इस कोड को onClick(View view) लिसनर की REST ब्रांच में जोड़ें:

// Send the REST request.
Request request = createRESTRequest();
try {
    client =
        new OkHttpClient.Builder()
            .connectTimeout(20, TimeUnit.SECONDS)
            .writeTimeout(20, TimeUnit.SECONDS)
            .readTimeout(20, TimeUnit.SECONDS)
            .callTimeout(20, TimeUnit.SECONDS)
            .build();
    Response response = client.newCall(request).execute();
    JSONObject responseObject = new JSONObject(response.body().string());
    postprocessRESTResponse(responseObject);
} catch (IOException | JSONException e) {
    Log.e(TAG, e.getMessage());
    responseTextView.setText(e.getMessage());
    return;
}

TensorFlow Serving से मिले REST रिस्पॉन्स को प्रोसेस करना

SSD MobileNet मॉडल कई नतीजे दिखाता है. इनमें ये शामिल हैं:

num_detections: पहचान की गई संख्या
detection_scores: पहचान के स्कोर
detection_classes: ऑब्जेक्ट का पता लगाने वाली क्लास का इंडेक्स
detection_boxes: बाउंडिंग बॉक्स के कोऑर्डिनेट

जवाब को मैनेज करने के लिए, postprocessRESTResponse() फ़ंक्शन लागू करें.

private void postprocessRESTResponse(Predict.PredictResponse response) {

}

इस कोड को postprocessRESTResponse() फ़ंक्शन में जोड़ें:

// Process the REST response.
JSONArray predictionsArray = responseObject.getJSONArray("predictions");
//You only send one image, so you directly extract the first element.
JSONObject predictions = predictionsArray.getJSONObject(0);
// Argmax
int maxIndex = 0;
JSONArray detectionScores = predictions.getJSONArray("detection_scores");
for (int j = 0; j < predictions.getInt("num_detections"); j++) {
    maxIndex =
        detectionScores.getDouble(j) > detectionScores.getDouble(maxIndex + 1) ? j : maxIndex;
}
int detectionClass = predictions.getJSONArray("detection_classes").getInt(maxIndex);
JSONArray boundingBox = predictions.getJSONArray("detection_boxes").getJSONArray(maxIndex);
double ymin = boundingBox.getDouble(0);
double xmin = boundingBox.getDouble(1);
double ymax = boundingBox.getDouble(2);
double xmax = boundingBox.getDouble(3);
displayResult(detectionClass, (float) ymin, (float) xmin, (float) ymax, (float) xmax);

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

इसे चलाएं

नेविगेशन मेन्यू में, 'ऐप्लिकेशन' चलाएं पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
REST > Run inference चुनें.

ऐप्लिकेशन को बिल्ली का बाउंडिंग बॉक्स रेंडर करने में कुछ सेकंड लगते हैं. इसके बाद, वह ऑब्जेक्ट की कैटगरी के तौर पर 17 दिखाता है. यह COCO डेटासेट में मौजूद cat ऑब्जेक्ट से मैप होता है.

7. gRPC के ज़रिए Android ऐप्लिकेशन को TensorFlow Serving से कनेक्ट करना

REST के अलावा, TensorFlow Serving gRPC के साथ भी काम करता है.

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

gRPC की मदद से अनुरोध भेजना और जवाब पाना

इसके लिए, ये चार आसान चरण पूरे करें:

[ज़रूरी नहीं] gRPC क्लाइंट स्टब कोड जनरेट करें.
gRPC अनुरोध बनाएं.
TensorFlow Serving को gRPC अनुरोध भेजें.
gRPC रिस्पॉन्स से अनुमानित नतीजे निकालें और यूज़र इंटरफ़ेस (यूआई) रेंडर करें.

आपको ये MainActivity.java. में मिलेंगी

ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करना

TensorFlow Serving के साथ gRPC का इस्तेमाल करने के लिए, आपको gRPC वर्कफ़्लो का पालन करना होगा. ज़्यादा जानकारी के लिए, gRPC का दस्तावेज़ देखें.

TensorFlow Serving और TensorFlow, आपके लिए .proto फ़ाइलें तय करते हैं. TensorFlow और TensorFlow Serving 2.8 के मुताबिक, ये .proto फ़ाइलें ज़रूरी हैं:

tensorflow/core/example/example.proto
tensorflow/core/example/feature.proto
tensorflow/core/protobuf/struct.proto
tensorflow/core/protobuf/saved_object_graph.proto
tensorflow/core/protobuf/saver.proto
tensorflow/core/protobuf/trackable_object_graph.proto
tensorflow/core/protobuf/meta_graph.proto
tensorflow/core/framework/node_def.proto
tensorflow/core/framework/attr_value.proto
tensorflow/core/framework/function.proto
tensorflow/core/framework/types.proto
tensorflow/core/framework/tensor_shape.proto
tensorflow/core/framework/full_type.proto
tensorflow/core/framework/versions.proto
tensorflow/core/framework/op_def.proto
tensorflow/core/framework/graph.proto
tensorflow/core/framework/tensor.proto
tensorflow/core/framework/resource_handle.proto
tensorflow/core/framework/variable.proto

tensorflow_serving/apis/inference.proto
tensorflow_serving/apis/classification.proto
tensorflow_serving/apis/predict.proto
tensorflow_serving/apis/regression.proto
tensorflow_serving/apis/get_model_metadata.proto
tensorflow_serving/apis/input.proto
tensorflow_serving/apis/prediction_service.proto
tensorflow_serving/apis/model.proto

स्टब जनरेट करने के लिए, इस कोड को app/build.gradle फ़ाइल में जोड़ें.

apply plugin: 'com.google.protobuf'

protobuf {
    protoc { artifact = 'com.google.protobuf:protoc:3.11.0' }
    plugins {
        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.29.0'
        }
    }
    generateProtoTasks {
        all().each { task ->
            task.builtins {
                java { option 'lite' }
            }
            task.plugins {
                grpc { option 'lite' }
            }
        }
    }
}

gRPC अनुरोध बनाएं

REST अनुरोध की तरह ही, createGRPCRequest() फ़ंक्शन में gRPC अनुरोध बनाया जाता है.

private Request createGRPCRequest() {

}

इस कोड को createGRPCRequest() फ़ंक्शन में जोड़ें:

if (stub == null) {
  channel = ManagedChannelBuilder.forAddress(SERVER, GRPC_PORT).usePlaintext().build();
  stub = PredictionServiceGrpc.newBlockingStub(channel);
}

Model.ModelSpec.Builder modelSpecBuilder = Model.ModelSpec.newBuilder();
modelSpecBuilder.setName(MODEL_NAME);
modelSpecBuilder.setVersion(Int64Value.of(MODEL_VERSION));
modelSpecBuilder.setSignatureName(SIGNATURE_NAME);

Predict.PredictRequest.Builder builder = Predict.PredictRequest.newBuilder();
builder.setModelSpec(modelSpecBuilder);

TensorProto.Builder tensorProtoBuilder = TensorProto.newBuilder();
tensorProtoBuilder.setDtype(DataType.DT_UINT8);
TensorShapeProto.Builder tensorShapeBuilder = TensorShapeProto.newBuilder();
tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(1));
tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(INPUT_IMG_HEIGHT));
tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(INPUT_IMG_WIDTH));
tensorShapeBuilder.addDim(TensorShapeProto.Dim.newBuilder().setSize(3));
tensorProtoBuilder.setTensorShape(tensorShapeBuilder.build());
int[] inputImg = new int[INPUT_IMG_HEIGHT * INPUT_IMG_WIDTH];
inputImgBitmap.getPixels(inputImg, 0, INPUT_IMG_WIDTH, 0, 0, INPUT_IMG_WIDTH, INPUT_IMG_HEIGHT);
int pixel;
for (int i = 0; i < INPUT_IMG_HEIGHT; i++) {
    for (int j = 0; j < INPUT_IMG_WIDTH; j++) {
    // Extract RBG values from each pixel; alpha is ignored.
    pixel = inputImg[i * INPUT_IMG_WIDTH + j];
    tensorProtoBuilder.addIntVal((pixel >> 16) & 0xff);
    tensorProtoBuilder.addIntVal((pixel >> 8) & 0xff);
    tensorProtoBuilder.addIntVal((pixel) & 0xff);
    }
}
TensorProto tensorProto = tensorProtoBuilder.build();

builder.putInputs("input_tensor", tensorProto);

builder.addOutputFilter("num_detections");
builder.addOutputFilter("detection_boxes");
builder.addOutputFilter("detection_classes");
builder.addOutputFilter("detection_scores");

return builder.build();

TensorFlow Serving को gRPC अनुरोध भेजना

अब onClick(View view) लिसनर को खत्म किया जा सकता है.

predictButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            if (requestRadioGroup.getCheckedRadioButtonId() == R.id.rest) {

            }
            else {
                // TODO: gRPC request
            }
        }
    }
)

इस कोड को gRPC ब्रांच में जोड़ें:

try {
    Predict.PredictRequest request = createGRPCRequest();
    Predict.PredictResponse response = stub.predict(request);
    postprocessGRPCResponse(response);
} catch (Exception e) {
    Log.e(TAG, e.getMessage());
    responseTextView.setText(e.getMessage());
    return;
}

TensorFlow Serving से मिले gRPC रिस्पॉन्स को प्रोसेस करना

gRPC की तरह ही, रिस्पॉन्स को मैनेज करने के लिए postprocessGRPCResponse() फ़ंक्शन लागू करें.

private void postprocessGRPCResponse(Predict.PredictResponse response) {

}

इस कोड को postprocessGRPCResponse() फ़ंक्शन में जोड़ें:

// Process the response.
float numDetections = response.getOutputsMap().get("num_detections").getFloatValList().get(0);
List<Float> detectionScores =    response.getOutputsMap().get("detection_scores").getFloatValList();
int maxIndex = 0;
for (int j = 0; j < numDetections; j++) {
    maxIndex = detectionScores.get(j) > detectionScores.get(maxIndex + 1) ? j : maxIndex;
}
Float detectionClass =    response.getOutputsMap().get("detection_classes").getFloatValList().get(maxIndex);
List<Float> boundingBoxValues =    response.getOutputsMap().get("detection_boxes").getFloatValList();
float ymin = boundingBoxValues.get(maxIndex * 4);
float xmin = boundingBoxValues.get(maxIndex * 4 + 1);
float ymax = boundingBoxValues.get(maxIndex * 4 + 2);
float xmax = boundingBoxValues.get(maxIndex * 4 + 3);
displayResult(detectionClass.intValue(), ymin, xmin, ymax, xmax);

अब पोस्टप्रोसेसिंग फ़ंक्शन, जवाब से अनुमानित वैल्यू निकाल सकता है. साथ ही, यूज़र इंटरफ़ेस (यूआई) में पहचान किए गए ऑब्जेक्ट के चारों ओर बाउंडिंग बॉक्स रेंडर कर सकता है.

इसे चलाएं

नेविगेशन मेन्यू में, 'ऐप्लिकेशन' चलाएं पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
gRPC > Run inference को चुनें.

ऐप्लिकेशन को बिल्ली का बाउंडिंग बॉक्स रेंडर करने में कुछ सेकंड लगते हैं. इसके बाद, वह ऑब्जेक्ट की कैटगरी के तौर पर 17 दिखाता है. यह COCO डेटासेट में मौजूद cat कैटगरी से मैप होती है.

8. बधाई हो

आपने अपने ऐप्लिकेशन में ऑब्जेक्ट का पता लगाने की सुविधाएं जोड़ने के लिए, TensorFlow Serving का इस्तेमाल किया है!