此页面由 Cloud Translation API 翻译。

创建 Android 应用以检测图片中的对象

1. 准备工作

在此 Codelab 中，您将学习如何通过 REST 和 gRPC 使用 TensorFlow Serving 从 Android 应用运行对象检测推断。

前提条件

掌握使用 Java 进行 Android 开发的基础知识
了解有关使用 TensorFlow 进行机器学习（例如训练与部署）的基本知识
了解有关终端和 Docker 的基本知识

学习内容

如何在 TensorFlow Hub 上查找预训练的对象检测模型。
如何构建简单的 Android 应用，并通过 TensorFlow Serving（REST 和 gRPC）使用下载的对象检测模型进行预测。
如何在界面中呈现检测结果。

所需条件

最新版本的 Android Studio
Docker
Bash

2. 进行设置

如需下载此 Codelab 的代码，请执行以下操作：

找到此 Codelab 的 GitHub 代码库。
点击 Code（代码）> Download zip（下载 Zip 文件），下载此 Codelab 的所有代码。

解压缩已下载的 ZIP 文件，这会解压缩 codelabs 根文件夹，其中包含您需要的所有资源。

在此 Codelab 中，您只需要代码库的 TFServing/ObjectDetectionAndroid 子目录（其中包含两个文件夹）中的文件：

starter 文件夹包含您在此 Codelab 中执行构建的起始代码。
finished 文件夹包含已完成示例应用的完成后的代码。

3. 向项目添加依赖项

将 starter 应用导入 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 文件同步

从导航菜单中选择 Sync Project with Gradle Files。

4. 运行起始应用

启动 Android 模拟器，然后点击导航菜单中的 Run 'app'。

运行和探索应用

应用应在 Android 设备上启动。界面非常简单：其中包含一张您要检测对象的猫图片，用户可以选择使用 REST 还是 gRPC 将数据发送到后端。后端对图片执行对象检测，并将检测结果返回给客户端应用，客户端应用再次呈现界面。

目前，如果您点击 Run inference，系统不会执行任何操作。这是因为它还不能与后端进行通信。

5. 使用 TensorFlow Serving 部署对象检测模型

对象检测是一项非常常见的机器学习任务，其目标是检测图片中的对象，即预测对象的可能类别以及围绕对象的边界框。以下是检测结果的示例：

Google 已在 TensorFlow Hub 上发布了许多预训练模型。如需查看完整列表，请访问 object_detection 页面。在此 Codelab 中，您将使用相对轻量级的 SSD MobileNet V2 FPNLite 320x320 模型，因此不一定需要使用 GPU 才能运行该模型。

如需使用 TensorFlow Serving 部署对象检测模型，请执行以下操作：

下载模型文件。
使用 7-Zip 等解压缩工具解压缩下载的 .tar.gz 文件。
创建 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 请求。
将 REST 请求发送到 TensorFlow Serving。
从 REST 响应中提取预测结果，并呈现界面。

您将在 MainActivity.java.内实现这些目标

创建 REST 请求

目前，MainActivity.java 文件中有一个空的 createRESTRequest() 函数。您需要实现此函数才能创建 REST 请求。

private Request createRESTRequest() {
}

TensorFlow Serving 需要一个包含所用 SSD MobileNet 模型的图片张量的 POST 请求，因此您需要将图片的每个像素的 RGB 值提取到一个数组中，然后将该数组封装在 JSON 中，而 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;

将 REST 请求发送到 TensorFlow Serving

该应用允许用户选择使用 REST 还是 gRPC 与 TensorFlow Serving 通信，因此 onClick(View view) 监听器中有两个分支。

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

            }
        }
    }
)

将以下代码添加到 onClick(View view) 监听器的 REST 分支，以使用 OkHttp 将请求发送到 TensorFlow Serving：

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

现在，后处理函数会从响应中提取预测值，识别对象最可能的类别和边界框顶点的坐标，最后在界面上呈现检测边界框。

运行应用

点击导航菜单中的 Run 'app'，然后等待应用加载。
选择 REST > Run inference。

应用需要几秒钟才能渲染猫的边界框，并显示 17 作为对象的类别，该类别对应于 COCO 数据集中的 cat 对象。

7. 通过 gRPC 将 Android 应用与 TensorFlow Serving 关联起来

除了 REST 之外，TensorFlow Serving 还支持 gRPC。

gRPC 是一种开放源代码的现代高性能远程过程调用 (RPC) 框架，可以在任何环境中运行。借助可插拔支持，它可以在数据中心内和跨数据中心高效地连接服务，以实现负载均衡、跟踪、健康检查和身份验证。我们发现，在实践中，gRPC 的性能比 REST 更高。

使用 gRPC 发送请求和接收响应

只需完成以下四个简单步骤：

[可选] 生成 gRPC 客户端桩代码。
创建 gRPC 请求。
向 TensorFlow Serving 发送 gRPC 请求。
从 gRPC 响应中提取预测结果，并呈现界面。

您将在 MainActivity.java.内实现这些目标

可选：生成 gRPC 客户端桩代码

如需将 gRPC 与 TensorFlow Serving 搭配使用，您需要遵循 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);

现在，后处理函数可以从响应中提取预测值，并在界面中呈现检测到的边界框。

运行应用

点击导航菜单中的 Run 'app'，然后等待应用加载。
选择 gRPC > Run inference。

应用需要几秒钟才能渲染猫的边界框，并显示 17 作为对象的类别，该类别对应于 COCO 数据集中的 cat 类别。

8. 恭喜

您已使用 TensorFlow Serving 为应用添加了对象检测功能！

创建 Android 应用以检测图片中的对象 使用集合让一切井井有条 根据您的偏好保存内容并对其进行分类。

1. 准备工作

前提条件

学习内容

所需条件

2. 进行设置

3. 向项目添加依赖项

将 starter 应用导入 Android Studio

添加 OkHttp 和 gRPC 的依赖项

将项目与 Gradle 文件同步

4. 运行起始应用

运行和探索应用

5. 使用 TensorFlow Serving 部署对象检测模型

启动 TensorFlow Serving

6. 通过 REST 将 Android 应用与 TensorFlow Serving 关联起来

通过 REST 发送请求和接收响应

创建 REST 请求

将 REST 请求发送到 TensorFlow Serving

处理来自 TensorFlow Serving 的 REST 响应

运行应用

7. 通过 gRPC 将 Android 应用与 TensorFlow Serving 关联起来

使用 gRPC 发送请求和接收响应

可选：生成 gRPC 客户端桩代码

创建 gRPC 请求

向 TensorFlow Serving 发送 gRPC 请求

处理来自 TensorFlow Serving 的 gRPC 响应

运行应用

8. 恭喜

了解详情

创建 Android 应用以检测图片中的对象