当前位置: 首页 > 知识库问答 >
问题:

Tensorflow服务预测REST API“未为base64数据正确格式化”错误

衡玄裳
2023-03-14

我保存了一个Tensorflow模型,并使用Tensorflow Service(Tensorflow/Service:1.12.0和Tensorflow/Service:1.12.0-GPU)为其提供服务。

我想使用Predict REST API,但调用失败,出现“未正确格式化for base64数据”错误。

POST/V1/模型/工资欺诈:预测

{
  "inputs": [
    {
      "payFraudInput": [[44.26, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]]
    }
  ]
}

回应:

400

{
    "error": "JSON Value: {\n    \"payFraudInput\": [\n        [\n            44.26,\n            0,\n            0,\n            0,\n            0,\n            1,\n            0,\n            0,\n            0,\n            0,\n            0,\n            0,\n            0,\n            0\n        ]\n    ]\n} not formatted correctly for base64 data"
}
{
    "model_spec": {
        "name": "payfraud",
        "signature_name": "",
        "version": "1"
    },
    "metadata": {
        "signature_def": {
            "signature_def": {
                "predict_fraud": {
                    "inputs": {
                        "payFraudInput": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "15",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "payFraudInput:0"
                        }
                    },
                    "outputs": {
                        "payFraudOutput": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "payFraudOutput:0"
                        }
                    },
                    "method_name": "tensorflow/serving/predict"
                },
                "serving_default": {
                    "inputs": {
                        "inputs": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [],
                                "unknown_rank": true
                            },
                            "name": "tf_example:0"
                        }
                    },
                    "outputs": {
                        "classes": {
                            "dtype": "DT_STRING",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "index_to_string_Lookup:0"
                        },
                        "scores": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "TopKV2:0"
                        }
                    },
                    "method_name": "tensorflow/serving/classify"
                }
            }
        }
    }
}
    prediction_signature = (
      tf.saved_model.signature_def_utils.build_signature_def(
          inputs={"payFraudInput": tensor_info_x},
          outputs={"payFraudOutput": tensor_info_y},
          method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME))

    classification_signature = (
       tf.saved_model.signature_def_utils.build_signature_def(
          inputs={
              tf.saved_model.signature_constants.CLASSIFY_INPUTS:
                  classification_inputs
          },
          outputs={
              tf.saved_model.signature_constants.CLASSIFY_OUTPUT_CLASSES:
                  classification_outputs_classes,
              tf.saved_model.signature_constants.CLASSIFY_OUTPUT_SCORES:
                  classification_outputs_scores
          },
          method_name=tf.saved_model.signature_constants.CLASSIFY_METHOD_NAME))

    export_path = os.path.join(tf.compat.as_bytes(export_dir), tf.compat.as_bytes("1"))
    print('Exporting trained model to ', export_path)
    builder = tf.saved_model.builder.SavedModelBuilder(export_path)
    builder.add_meta_graph_and_variables( sess, [tf.saved_model.tag_constants.SERVING],
        signature_def_map={
            'predict_fraud':
                 prediction_signature,
             tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
                 classification_signature,
        },
        main_op=tf.tables_initializer(),
        strip_default_attrs=True)

    builder.save()
    print('Done exporting!')
{
  "inputs": [
    {
      "payFraudInput":{"b64":"NDQuMjYsIDAsIDAsIDAsIDAsIDEsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDA="}
    }
  ]
}
{
    "error": "JSON Value: {\n    \"payFraudInput\": {\n        \"b64\": \"NDQuMjYsIDAsIDAsIDAsIDAsIDEsIDAsIDAsIDAsIDAsIDAsIDAsIDAsIDA=\"\n    }\n} not formatted correctly for base64 data"
}

共有1个答案

晋弘义
2023-03-14

在清理和简化训练脚本的模型保存部分之后,我得到了一个预测响应。

现在的保存如下所示:

    export_path = os.path.join(tf.compat.as_bytes(export_dir), tf.compat.as_bytes("1"))
    builder = tf.saved_model.builder.SavedModelBuilder(export_path)

    predict_signature_def = (
        tf.saved_model.signature_def_utils.predict_signature_def({"x": X}, {"y": Y_hat}))
    signature_def_map = {
        tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY:
            predict_signature_def
    }
    sess.run(tf.global_variables_initializer())
    builder.add_meta_graph_and_variables(
        sess, [tf.saved_model.tag_constants.SERVING],
        signature_def_map=signature_def_map)
    builder.save()

我可以从Tensorflow获得有效的响应:

{
  "inputs": [[44.26, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
}
{
    "outputs": [
        [
            0.5,
            0.5
        ]
    ]
}

获取/v1/models/payfraud/versions/1/metadata

{
    "model_spec": {
        "name": "payfraud",
        "signature_name": "",
        "version": "1"
    },
    "metadata": {
        "signature_def": {
            "signature_def": {
                "serving_default": {
                    "inputs": {
                        "x": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "15",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "x:0"
                        }
                    },
                    "outputs": {
                        "y": {
                            "dtype": "DT_FLOAT",
                            "tensor_shape": {
                                "dim": [
                                    {
                                        "size": "-1",
                                        "name": ""
                                    },
                                    {
                                        "size": "2",
                                        "name": ""
                                    }
                                ],
                                "unknown_rank": false
                            },
                            "name": "y:0"
                        }
                    },
                    "method_name": "tensorflow/serving/predict"
                }
            }
        }
    }
}
 类似资料:
  • 我正在测试SpringREST服务,特别是POST方法 以下是我的控制器的代码片段: 员工类别: 我在pom.xml中也包含了jackson库的依赖 pom.xml 当我提交请求时,我的状态为:415不支持的媒体类型 这是我收到的错误消息:服务器拒绝了此请求,因为请求实体的格式不受请求方法的请求资源的支持。 请说明我做错了什么?

  • 我正在使用spring Boot1.5.9编写一个小型rest服务器。我刚开始使用初始化代码,就被这种奇怪的行为卡住了。 我有个小测试- 最初,Application.Properties被忽略。在我添加了@SpringBootTest注释之后,application.properties被读取,但开始出现以下错误。 配置bean如下所示- 而且 我确实使用@EnableAutoConfigura

  • 我不明白为什么我一直收到这个错误消息: 在此行中找到多个注释: < li >文档中根元素后面的标记必须格式良好。 < li >错误:解析XML时出错:文档元素后的垃圾信息 该错误在下面的开头找到: XML:

  • 我有XML数据在数据库(不是文件),我需要解析它,以提供可能写测试来验证数据在XML xml(内容数据): [致命错误]:14:2:根元素后面的文档中的标记必须格式良好。org.xml.sax.SaxParseException;亚麻编号:14;专栏编号:2;根元素后面的文档中的标记必须格式良好。位于com.sun.org.apache.xerces.internal.parsers.dompar

  • v-charts 提供对数据格式的设置的能力,一个常见的设置数据格式的方式如下所示: <template> <ve-line :data="chartData" :settings="chartSettings"></ve-line> </template> <script> export default { data () { this.chartSettings = { metr