tensorflow serving java案例

简介: 背景介绍 这篇文章是tensorflow serving java api使用的参考案例,基本上把TFS的核心API的用法都介绍清楚。案例主要分为三部分:动态更新模型:用于在TFS处于runtime时候动态加载模型。

背景介绍

 这篇文章是tensorflow serving java api使用的参考案例,基本上把TFS的核心API的用法都介绍清楚。案例主要分为三部分:

  • 动态更新模型:用于在TFS处于runtime时候动态加载模型。
  • 获取模型状态:用于获取加载的模型的基本信息。
  • 在线模型预测:进行在线预测,分类等操作,着重介绍在线预测。

因为模型的预测需要参考模型内部变量,所以可以先行通过TFS的REST接口获取TF模型的元数据然后才能构建TFS的RPC请求对象


TFS 使用入门

模型源数据获取

curl http://host:port/v1/models/${MODEL_NAME}[/versions/${MODEL_VERSION}]/metadata

说明:


    public static void getModelStatus() {

        // 1、设置访问的RPC协议的host和port
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();

        // 2、构建PredictionServiceBlockingStub对象
        PredictionServiceGrpc.PredictionServiceBlockingStub predictionServiceBlockingStub =
                PredictionServiceGrpc.newBlockingStub(channel);

         // 3、设置待获取的模型
        Model.ModelSpec modelSpec = Model.ModelSpec.newBuilder()
                .setName("wdl_model").build();

        // 4、构建获取元数据的请求
        GetModelMetadata.GetModelMetadataRequest modelMetadataRequest =
                GetModelMetadata.GetModelMetadataRequest.newBuilder()
                        .setModelSpec(modelSpec)
                        .addAllMetadataField(Arrays.asList("signature_def"))
                        .build();
         // 5、获取元数据
        GetModelMetadata.GetModelMetadataResponse getModelMetadataResponse =
                predictionServiceBlockingStub.getModelMetadata(modelMetadataRequest);

        channel.shutdownNow();
    }

说明:

  • Model.ModelSpec.newBuilder绑定需要访问的模型的名字。
  • GetModelMetadataRequest中addAllMetadataField绑定curl命令返回的metadata当中的signature_def 字段。


动态更新模型

    public static void addNewModel() {
        // 1、构建动态更新模型1
        ModelServerConfigOuterClass.ModelConfig modelConfig1 =
                ModelServerConfigOuterClass.ModelConfig.newBuilder()
                        .setBasePath("/models/new_model")
                        .setName("new_model")                      
                        .setModelType(ModelServerConfigOuterClass.ModelType.TENSORFLOW)
                        .build();

        // 2、构建动态更新模型2
        ModelServerConfigOuterClass.ModelConfig modelConfig2 =
                ModelServerConfigOuterClass.ModelConfig.newBuilder()
                        .setBasePath("/models/wdl_model")
                        .setName("wdl_model")
                        .setModelType(ModelServerConfigOuterClass.ModelType.TENSORFLOW)
                        .build();
        
        // 3、合并动态更新模型到ModelConfigList对象中
        ModelServerConfigOuterClass.ModelConfigList modelConfigList =
                ModelServerConfigOuterClass.ModelConfigList.newBuilder()
                        .addConfig(modelConfig1)
                        .addConfig(modelConfig2)
                        .build();

        // 4、添加到ModelConfigList到ModelServerConfig对象当中
        ModelServerConfigOuterClass.ModelServerConfig modelServerConfig = 
                ModelServerConfigOuterClass.ModelServerConfig.newBuilder()
                .setModelConfigList(modelConfigList)
                .build();

        // 5、构建ReloadConfigRequest并绑定ModelServerConfig对象。
        ModelManagement.ReloadConfigRequest reloadConfigRequest =
                ModelManagement.ReloadConfigRequest.newBuilder()
                        .setConfig(modelServerConfig)
                        .build();

        // 6、构建modelServiceBlockingStub访问句柄
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
        ModelServiceGrpc.ModelServiceBlockingStub modelServiceBlockingStub = 
        ModelServiceGrpc.newBlockingStub(channel);

        ModelManagement.ReloadConfigResponse reloadConfigResponse =
                modelServiceBlockingStub.handleReloadConfigRequest(reloadConfigRequest);

        System.out.println(reloadConfigResponse.getStatus().getErrorMessage());

        channel.shutdownNow();

    }

说明:

  • 动态更新模型是一个全量的模型加载,在发布A模型后想动态发布B模型需要同时传递模型A和B的信息。
  • 再次强调,需要全量更新,全量更新,全量更新!!!


在线模型预测

    public static void doPredict() throws Exception {

        // 1、构建feature
        Map<String, Feature> featureMap = new HashMap<>();
        featureMap.put("match_type", feature(""));
        featureMap.put("position", feature(0.0f));
        featureMap.put("brand_prefer_1d", feature(0.0f));
        featureMap.put("brand_prefer_1m", feature(0.0f));
        featureMap.put("brand_prefer_1w", feature(0.0f));
        featureMap.put("brand_prefer_2w", feature(0.0f));
        featureMap.put("browse_norm_score_1d", feature(0.0f));
        featureMap.put("browse_norm_score_1w", feature(0.0f));
        featureMap.put("browse_norm_score_2w", feature(0.0f));
        featureMap.put("buy_norm_score_1d", feature(0.0f));
        featureMap.put("buy_norm_score_1w", feature(0.0f));
        featureMap.put("buy_norm_score_2w", feature(0.0f));
        featureMap.put("cate1_prefer_1d", feature(0.0f));
        featureMap.put("cate1_prefer_2d", feature(0.0f));
        featureMap.put("cate1_prefer_1m", feature(0.0f));
        featureMap.put("cate1_prefer_1w", feature(0.0f));
        featureMap.put("cate1_prefer_2w", feature(0.0f));
        featureMap.put("cate2_prefer_1d", feature(0.0f));
        featureMap.put("cate2_prefer_1m", feature(0.0f));
        featureMap.put("cate2_prefer_1w", feature(0.0f));
        featureMap.put("cate2_prefer_2w", feature(0.0f));
        featureMap.put("cid_prefer_1d", feature(0.0f));
        featureMap.put("cid_prefer_1m", feature(0.0f));
        featureMap.put("cid_prefer_1w", feature(0.0f));
        featureMap.put("cid_prefer_2w", feature(0.0f));
        featureMap.put("user_buy_rate_1d", feature(0.0f));
        featureMap.put("user_buy_rate_2w", feature(0.0f));
        featureMap.put("user_click_rate_1d", feature(0.0f));
        featureMap.put("user_click_rate_1w", feature(0.0f));

        Features features = Features.newBuilder().putAllFeature(featureMap).build();
        Example example = Example.newBuilder().setFeatures(features).build();

        // 2、构建Predict请求
        Predict.PredictRequest.Builder predictRequestBuilder = Predict.PredictRequest.newBuilder();

        // 3、构建模型请求维度ModelSpec,绑定模型名和预测的签名
        Model.ModelSpec.Builder modelSpecBuilder = Model.ModelSpec.newBuilder();
        modelSpecBuilder.setName("wdl_model");
        modelSpecBuilder.setSignatureName("predict");
        predictRequestBuilder.setModelSpec(modelSpecBuilder);

        // 4、构建预测请求的维度信息DIM对象
        TensorShapeProto.Dim dim = TensorShapeProto.Dim.newBuilder().setSize(300).build();
        TensorShapeProto shapeProto = TensorShapeProto.newBuilder().addDim(dim).build();
        TensorProto.Builder tensor = TensorProto.newBuilder();
        tensor.setTensorShape(shapeProto);
        tensor.setDtype(DataType.DT_STRING);

        // 5、批量绑定预测请求的数据
        for (int i=0; i<300; i++) {
            tensor.addStringVal(example.toByteString());
        }
        predictRequestBuilder.putInputs("examples", tensor.build());

        // 6、构建PredictionServiceBlockingStub对象准备预测
        ManagedChannel channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
        PredictionServiceGrpc.PredictionServiceBlockingStub predictionServiceBlockingStub = 
            PredictionServiceGrpc.newBlockingStub(channel);
        
        // 7、执行预测
        Predict.PredictResponse predictResponse = 
         predictionServiceBlockingStub.predict(predictRequestBuilder.build());
      
        // 8、解析请求结果
        List<Float> floatList = predictResponse
         .getOutputsOrThrow("probabilities")
         .getFloatValList();
    }

说明:

  • TFS的RPC请求过程中设置的参数需要考虑TF模型的数据结构。
  • TFS的RPC请求有同步和异步两种方式,上述只展示同步方式。


TF模型结构

{
    "model_spec": {
        "name": "wdl_model",
        "signature_name": "",
        "version": "4"
    },
    "metadata": {
        "signature_def": {
            "signature_def": {
                "predict": {
                    "inputs": {
                        "examples": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                    "size": "-1",
                                    "name": ""
                                }],
                                "unknown_rank": false
                            },
                            "name": "input_example_tensor:0"
                        }
                    },
                    "outputs": {
                        "logistic": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "1",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/logistic:0"
                        },
                        "class_ids": {
                            "dtype": "DT_INT64",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "1",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/ExpandDims:0"
                        },
                        "probabilities": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/probabilities:0"
                        },
                        "classes": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "1",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/str_classes:0"
                        },
                        "logits": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "1",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "add:0"
                        }
                    },
                    "method_name": "tensorflow/serving/predict"
                },
                "classification": {
                    "inputs": {
                        "inputs": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                    "size": "-1",
                                    "name": ""
                                }],
                                "unknown_rank": false
                            },
                            "name": "input_example_tensor:0"
                        }
                    },
                    "outputs": {
                        "classes": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/Tile:0"
                        },
                        "scores": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/probabilities:0"
                        }
                    },
                    "method_name": "tensorflow/serving/classify"
                },
                "regression": {
                    "inputs": {
                        "inputs": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                    "size": "-1",
                                    "name": ""
                                }],
                                "unknown_rank": false
                            },
                            "name": "input_example_tensor:0"
                        }
                    },
                    "outputs": {
                        "outputs": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "1",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/logistic:0"
                        }
                    },
                    "method_name": "tensorflow/serving/regress"
                },
                "serving_default": {
                    "inputs": {
                        "inputs": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                    "size": "-1",
                                    "name": ""
                                }],
                                "unknown_rank": false
                            },
                            "name": "input_example_tensor:0"
                        }
                    },
                    "outputs": {
                        "classes": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/Tile:0"
                        },
                        "scores": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [{
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "head/predictions/probabilities:0"
                        }
                    },
                    "method_name": "tensorflow/serving/classify"
                }
            }
        }
    }
}
目录
相关文章
|
3月前
|
自然语言处理 前端开发 Java
JBoltAI 框架完整实操案例 在 Java 生态中快速构建大模型应用全流程实战指南
本案例基于JBoltAI框架,展示如何快速构建Java生态中的大模型应用——智能客服系统。系统面向电商平台,具备自动回答常见问题、意图识别、多轮对话理解及复杂问题转接人工等功能。采用Spring Boot+JBoltAI架构,集成向量数据库与大模型(如文心一言或通义千问)。内容涵盖需求分析、环境搭建、代码实现(知识库管理、核心服务、REST API)、前端界面开发及部署测试全流程,助你高效掌握大模型应用开发。
400 5
|
3月前
|
前端开发 JavaScript Java
Java 学习路线规划及项目案例中的技术栈应用解析
内容包括:**Java 17核心特性**(如sealed class、record)与模块化开发;Spring Boot 3 + Spring Cloud微服务架构,涉及响应式编程(WebFlux)、多数据库持久化(JPA、R2DBC、MongoDB);云原生技术**如Docker、Kubernetes及CI/CD流程;性能优化(GraalVM Native Image、JVM调优);以及前后端分离开发(Vue 3、Spring Boot集成)。通过全栈电商平台项目实战,掌握从后端服务(用户、商品、订单)到前端应用(Vue 3、React Native)的全流程开发。
179 9
|
2月前
|
安全 Java API
Java 集合高级应用与实战技巧之高效运用方法及实战案例解析
本课程深入讲解Java集合的高级应用与实战技巧,涵盖Stream API、并行处理、Optional类、现代化Map操作、不可变集合、异步处理及高级排序等核心内容,结合丰富示例,助你掌握Java集合的高效运用,提升代码质量与开发效率。
203 0
|
2月前
|
安全 JavaScript Java
java Web 项目完整案例实操指南包含从搭建到部署的详细步骤及热门长尾关键词解析的实操指南
本项目为一个完整的JavaWeb应用案例,采用Spring Boot 3、Vue 3、MySQL、Redis等最新技术栈,涵盖前后端分离架构设计、RESTful API开发、JWT安全认证、Docker容器化部署等内容,适合掌握企业级Web项目全流程开发与部署。
150 0
|
3月前
|
人工智能 Java 开发者
【Java实例-简易计算机】使用Java实现简单的计算机案例
一个简单的Java案例——“简易计算器”,帮助编程新手快速上手。通过实现用户输入、基本逻辑运算和结果输出,学习者可以掌握变量声明、Scanner对象使用、控制流语句等关键知识点。文章分为设计思路、关键知识点、完整代码和测试运行四个部分。
128 9
【Java实例-简易计算机】使用Java实现简单的计算机案例
|
3月前
|
缓存 算法 NoSQL
校招 Java 面试高频常见知识点深度解析与实战案例详细分享
《2025校招Java面试核心指南》总结了Java技术栈的最新考点,涵盖基础语法、并发编程和云原生技术三大维度: 现代Java特性:重点解析Java 17密封类、Record类型及响应式Stream API,通过电商案例演示函数式数据处理 并发革命:对比传统线程池与Java 21虚拟线程,详解Reactor模式在秒杀系统中的应用及背压机制 云原生实践:提供Spring Boot容器化部署方案,分析Spring WebFlux响应式编程和Redis Cluster缓存策略。
89 0
|
3月前
|
人工智能 Java API
Java 生态大模型应用开发全流程实战案例与技术路径终极对决
在Java生态中开发大模型应用,Spring AI、LangChain4j和JBoltAI是三大主流框架。本文从架构设计、核心功能、开发体验、性能扩展性、生态社区等维度对比三者特点,并结合实例分析选型建议。Spring AI适合已有Spring技术栈团队,LangChain4j灵活性强适用于学术研究,JBoltAI提供开箱即用的企业级解决方案,助力传统系统快速AI化改造。开发者可根据业务场景和技术背景选择最适合的框架。
534 2
|
3月前
|
存储 Java 数据安全/隐私保护
Java技术栈揭秘:Base64加密和解密文件的实战案例
以上就是我们今天关于Java实现Base64编码和解码的实战案例介绍。希望能对你有所帮助。还有更多知识等待你去探索和学习,让我们一同努力,继续前行!
318 5
|
3月前
|
缓存 NoSQL Java
校招 Java 面试常见知识点及实战案例全解析
本文全面解析了Java校招面试中的常见知识点,涵盖Java新特性(如Lambda表达式、、Optional类)、集合框架高级应用(线程安全集合、Map性能优化)、多线程与并发编程(线程池配置)、JVM性能调优(内存溢出排查、垃圾回收器选择)、Spring与微服务实战(Spring Boot自动配置)、数据库与ORM框架(MyBatis高级用法、索引优化)、分布式系统(分布式事务、缓存应用)、性能优化(接口优化、高并发限流)、单元测试与代码质量(JUnit 5、Mockito、JaCoCo)以及项目实战案例(电商秒杀系统、社交消息推送)。资源地址: [https://pan.quark.cn/s
160 4
|
3月前
|
缓存 Java API
Java 集合容器实操技巧与案例详解
本教程基于Java 8+新特性和现代开发实践,深入讲解Java集合容器的实操技巧。通过具体场景演示Stream API数据处理、ConcurrentHashMap并发控制、LinkedHashMap实现LRU缓存、TreeSet自定义排序等高级特性。同时涵盖computeIfAbsent优化操作、EnumMap专用集合使用、集合统计与运算(交集、并集、差集)等内容。代码示例丰富,助力掌握高效编程方法。[点击获取完整代码](https://pan.quark.cn/s/14fcf913bae6)。
62 0

热门文章

最新文章