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 为应用添加了对象检测功能!