1. शुरू करने से पहले
इस कोडलैब में, आप REST और gRPC के साथ TensorFlow सर्विंग का इस्तेमाल करके, Android ऐप्लिकेशन से ऑब्जेक्ट की पहचान का अनुमान लगाने का तरीका जानेंगे.
ज़रूरी बातें
- Java की मदद से, Android डेवलपमेंट की बुनियादी जानकारी
- TensorFlow का इस्तेमाल करके, मशीन लर्निंग के बारे में बुनियादी जानकारी, जैसे कि ट्रेनिंग और डिप्लॉयमेंट
- टर्मिनल और डॉकर की बुनियादी जानकारी
आप इन चीज़ों के बारे में जानेंगे
- TensorFlow Hub पर पहले से प्रशिक्षित ऑब्जेक्ट पहचानने के मॉडल ढूंढने का तरीका.
- आसान Android ऐप्लिकेशन बनाने का तरीका. साथ ही, TensorFlow सर्विंग (REST और gRPC) की मदद से, डाउनलोड किए गए ऑब्जेक्ट का पता लगाने वाले मॉडल का इस्तेमाल करके अनुमान लगाएं.
- यूज़र इंटरफ़ेस (यूआई) में पहचान का नतीजा कैसे रेंडर करें.
आपको इनकी ज़रूरत होगी
- Android Studio का नया वर्शन
- डॉकर
- बैश
2. सेट अप करें
इस कोडलैब के लिए कोड डाउनलोड करने के लिए:
- इस कोडलैब के लिए, GitHub की रिपॉज़िटरी पर जाएं.
- इस कोडलैब के सभी कोड डाउनलोड करने के लिए, कोड > ज़िप डाउनलोड करें पर क्लिक करें.
codelabsरूट फ़ोल्डर को अनपैक करने के लिए डाउनलोड किए गए ZIP फ़ाइल को खोलें. इसमें आपको सभी ज़रूरी संसाधन मिलेंगे.
इस कोडलैब के लिए, आपको रिपॉज़िटरी में सिर्फ़ TFServing/ObjectDetectionAndroid सबडायरेक्ट्री की फ़ाइलों की ज़रूरत होती है, जिसमें दो फ़ोल्डर होते हैं:
starterफ़ोल्डर में वह स्टार्टर कोड शामिल है जिसे आपने इस कोडलैब के लिए बनाया है.finishedफ़ोल्डर में, तैयार हो चुके सैंपल ऐप्लिकेशन का पूरा कोड है.
3. प्रोजेक्ट में डिपेंडेंसी जोड़ना
Android Studio में स्टार्टर ऐप्लिकेशन इंपोर्ट करें
- Android Studio में, फ़ाइल > नया > प्रोजेक्ट इंपोर्ट करें पर क्लिक करें. इसके बाद, पहले डाउनलोड किए गए सोर्स कोड से
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 एम्युलेटर शुरू करें, और इसके बाद, नेविगेशन मेन्यू में
app' चलाएं पर क्लिक करें.
ऐप्लिकेशन चलाएं और उसके बारे में ज़्यादा जानें
ऐप्लिकेशन को आपके Android डिवाइस पर लॉन्च हो जाना चाहिए. यूज़र इंटरफ़ेस (यूआई) बहुत आसान है: यह एक बिल्ली की इमेज है जिसमें आप ऑब्जेक्ट का पता लगाना चाहते हैं. साथ ही, उपयोगकर्ता REST या gRPC की मदद से बैकएंड में डेटा भेजने का तरीका चुन सकता है. बैकएंड, इमेज पर ऑब्जेक्ट की पहचान करता है और क्लाइंट ऐप्लिकेशन पर पहचान के नतीजे दिखाता है. यह यूज़र इंटरफ़ेस (यूआई) को फिर से रेंडर करता है.
फ़िलहाल, अगर आप अनुमान चलाएं पर क्लिक करते हैं, तो कुछ नहीं होगा. ऐसा इसलिए है, क्योंकि यह अब तक बैकएंड से संपर्क नहीं कर सकता.
5. TensorFlow सर्विंग के साथ ऑब्जेक्ट डिटेक्शन मॉडल को डिप्लॉय करें
ऑब्जेक्ट का पता लगाना, एक सामान्य एमएल टास्क है. इसका मकसद, इमेज में ऑब्जेक्ट का पता लगाना है. इससे ऑब्जेक्ट की संभावित कैटगरी का पता लगाया जा सकता है. साथ ही, इन ऑब्जेक्ट के आस-पास मौजूद बॉक्स की पहचान की जा सकती है. पहचान के नतीजे का एक उदाहरण यहां दिया गया है:
Google ने TensorFlow हब पर कई प्रशिक्षित मॉडल प्रकाशित किए हैं. पूरी सूची देखने के लिए, obtract_detection पेज पर जाएं. आप इस कोडलैब के लिए, दूसरे मॉडल के मुकाबले हल्की लाइट वाले SSD MobileNet V2 FPNLite 320x320 मॉडल का इस्तेमाल करते हैं. इससे, इसे चलाने के लिए आपको जीपीयू का इस्तेमाल नहीं करना पड़ता.
ऑब्जेक्ट का पता लगाने वाले मॉडल को TensorFlow सर्विंग के साथ डिप्लॉय करने के लिए:
- मॉडल फ़ाइल डाउनलोड करें.
- डाउनलोड की गई
.tar.gzफ़ाइल को कंप्रेस करने के लिए, उसे कंप्रेस करने वाले टूल का इस्तेमाल करें, जैसे कि 7-ZIP. ssd_mobilenet_v2_2_320फ़ोल्डर बनाएं और फिर उसके अंदर123सबफ़ोल्डर बनाएं.- निकाले गए
variablesफ़ोल्डर औरsaved_model.pbफ़ाइल को123सबफ़ोल्डर में रखें.
आप ssd_mobilenet_v2_2_320 फ़ोल्डर को SavedModel फ़ोल्डर के तौर पर देख सकते हैं. 123, वर्शन नंबर का उदाहरण है. अगर आप चाहें, तो दूसरा नंबर चुन सकते हैं.
फ़ोल्डर का स्ट्रक्चर इस इमेज जैसा दिखना चाहिए:
TensorFlow सर्विंग शुरू करें
- अपने टर्मिनल में, TensorFlow सेवा को डॉक करने वाले टूल से शुरू करें. हालांकि, अपने कंप्यूटर पर
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
डॉकर सबसे पहले TensorFlow सर्विंग इमेज को अपने-आप डाउनलोड कर लेता है. इसमें एक मिनट लगता है. इसके बाद, TensorFlow सर्विंग शुरू हो जानी चाहिए. लॉग इस कोड स्निपेट जैसा दिखना चाहिए:
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 सर्विंग से कनेक्ट करें
अब बैकएंड तैयार है, ताकि आप इमेज के अंदर ऑब्जेक्ट का पता लगाने के लिए, TensorFlow सर्विंग को क्लाइंट के अनुरोध भेज सकें. TensorFlow सर्विंग को दो तरीकों से अनुरोध भेजे जा सकते हैं:
- आरएसटी
- gRPC
REST के ज़रिए अनुरोध भेजें और जवाब पाएं
तीन आसान चरण हैं:
- REST अनुरोध बनाएं.
- TensorFlow सर्विंग को REST का अनुरोध भेजें.
- REST के जवाब से अनुमानित नतीजे निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.
आप MainActivity.java. में ये हासिल कर लेंगे
REST अनुरोध बनाएं
अभी, MainActivity.java फ़ाइल में एक खाली createRESTRequest() फ़ंक्शन है. आप इस फ़ंक्शन को लागू करके, REST अनुरोध बनाते हैं.
private Request createRESTRequest() {
}
TensorFlow सर्विंग की सुविधा एक ऐसे पोस्ट अनुरोध की उम्मीद करती है जिसमें आपके इस्तेमाल किए जाने वाले एसएसडी मोबाइलनेट मॉडल के लिए इमेज टेंशनर हो. इसलिए, आपको इमेज के हर पिक्सल से एक श्रेणी में आरजीबी मान निकालना होगा. इसके बाद, रेंज को 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 सर्विंग के लिए REST अनुरोध भेजें
यह ऐप्लिकेशन, उपयोगकर्ताओं को TensorFlow सर्विंग के लिए, 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 सर्व करने का अनुरोध भेजने के लिए, 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 सर्विंग से मिलने वाले 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);
अब पोस्टप्रोसेसिंग फ़ंक्शन, रिस्पॉन्स से अनुमानित वैल्यू निकालता है, ऑब्जेक्ट की सबसे संभावित कैटगरी की पहचान करता है और बाउंडिंग-बॉक्स वर्टेक्स के निर्देशांक बनाता है. साथ ही, यह आखिर में यूज़र इंटरफ़ेस (यूआई) पर पहचान बाउंडिंग बॉक्स को रेंडर करता है.
इसे चलाएं
- नेविगेशन मेन्यू में app' पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
- REST > अनुमान चलाएं चुनें.
ऐप्लिकेशन, बिल्ली के पास मौजूद बॉक्स को रेंडर करने में कुछ सेकंड लेता है. साथ ही, यह ऑब्जेक्ट की कैटगरी के तौर पर 17 को दिखाता है, जो COCO डेटासेट में cat ऑब्जेक्ट से मैप होता है.
7. gRPC की मदद से, Android ऐप्लिकेशन को TensorFlow सर्विंग से कनेक्ट करें
REST के अलावा, TensorFlow सर्व करने की सुविधा gRPC पर भी काम करती है.
gRPC एक आधुनिक, ओपन सोर्स, हाई-परफ़ॉर्मेंस रिमोट प्रोसेस कॉल (आरपीसी) फ़्रेमवर्क है, जो किसी भी एनवायरमेंट में चल सकता है. यह डेटा केंद्रों में, लोड बैलेंसिंग, ट्रेसिंग, स्वास्थ्य जांच, और पुष्टि करने की सुविधा के साथ बेहतर तरीके से सेवाओं को कनेक्ट कर सकती है. यह देखा गया है कि REST की तुलना में gRPC, बेहतर परफ़ॉर्म करता है.
gRPC से अनुरोध भेजें और जवाब पाएं
चार आसान चरण हैं:
- [ज़रूरी नहीं] gRPC क्लाइंट स्टब कोड जनरेट करें.
- जीआरपीसी अनुरोध बनाएं.
- TensorFlow सर्विंग के लिए जीआरपीसी अनुरोध भेजें.
- gRPC रिस्पॉन्स से अनुमानित नतीजा निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.
आप MainActivity.java. में ये हासिल कर लेंगे
ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करें
TensorFlow सर्विंग के साथ जीआरपीसी का इस्तेमाल करने के लिए, आपको जीआरपीसी वर्कफ़्लो को फ़ॉलो करना होगा. ज़्यादा जानकारी के लिए, gRPC दस्तावेज़ देखें.
TensorFlow सर्विंग और TensorFlow आपके लिए .proto फ़ाइलें तय करते हैं. TensorFlow और TensorFlow 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' }
}
}
}
}
जीआरपीसी अनुरोध बनाएं
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 सर्व करने के लिए, जीआरपीसी का अनुरोध भेजें
अब आप onClick(View view) लिसनर को पूरा कर सकते हैं.
predictButton.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View view) {
if (requestRadioGroup.getCheckedRadioButtonId() == R.id.rest) {
}
else {
// TODO: gRPC request
}
}
}
)
- यह कोड जीआरपीसी शाखा में जोड़ें:
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 सर्विंग से जीआरपीसी जवाब को प्रोसेस करें
जीआरपीसी की तरह ही, आप रिस्पॉन्स को मैनेज करने के लिए 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);
अब पोस्टप्रोसेसिंग फ़ंक्शन, रिस्पॉन्स से अनुमानित वैल्यू निकाल सकता है और यूज़र इंटरफ़ेस (यूआई) में पहचान बाउंडिंग बॉक्स को रेंडर कर सकता है.
इसे चलाएं
- नेविगेशन मेन्यू में app' पर क्लिक करें. इसके बाद, ऐप्लिकेशन के लोड होने का इंतज़ार करें.
- gRPC > अनुमान चलाएं चुनें.
ऐप्लिकेशन, बिल्ली के पास मौजूद बॉक्स को रेंडर करने में कुछ सेकंड लेता है. साथ ही, यह ऑब्जेक्ट की कैटगरी के तौर पर 17 को दिखाता है, जो COCO डेटासेट में cat कैटगरी पर मैप होता है.
8. बधाई हो
आपने अपने ऐप्लिकेशन में ऑब्जेक्ट का पता लगाने की क्षमताएं जोड़ने के लिए, TensorFlow सर्विंग का इस्तेमाल किया है!