|
|
|
|
@ -17,6 +17,7 @@ syntax = "proto3"; |
|
|
|
|
package google.cloud.ml.v1beta1; |
|
|
|
|
|
|
|
|
|
import "google/api/annotations.proto"; |
|
|
|
|
import "google/api/httpbody.proto"; |
|
|
|
|
|
|
|
|
|
option java_multiple_files = true; |
|
|
|
|
option java_outer_classname = "PredictionServiceProto"; |
|
|
|
|
@ -36,41 +37,47 @@ service OnlinePredictionService { |
|
|
|
|
// Responses are very similar to requests. There are two top-level fields, |
|
|
|
|
// each of which are JSON lists: |
|
|
|
|
// |
|
|
|
|
// * `predictions`: The list of predictions for each of the inputs |
|
|
|
|
// in the request. |
|
|
|
|
// * `error`: An error message if any instance produced an error. |
|
|
|
|
// <dl> |
|
|
|
|
// <dt>predictions</dt> |
|
|
|
|
// <dd>The list of predictions, one per instance in the request.</dd> |
|
|
|
|
// <dt>error</dt> |
|
|
|
|
// <dd>An error message returned instead of a prediction list if any |
|
|
|
|
// instance produced an error.</dd> |
|
|
|
|
// </dl> |
|
|
|
|
// |
|
|
|
|
// There is a one-to-one correspondence between the predictions and the |
|
|
|
|
// instances in the request. Each individual prediction takes the same form |
|
|
|
|
// as an instance in the request, namely JSON strings, numbers, booleans, |
|
|
|
|
// or lists thereof. If your model has more than one output tensor, each |
|
|
|
|
// prediction will be a JSON object with the keys being the output aliases |
|
|
|
|
// in the graph. |
|
|
|
|
// If the call is successful, the response body will contain one prediction |
|
|
|
|
// entry per instance in the request body. If prediction fails for any |
|
|
|
|
// instance, the response body will contain no predictions and will contian |
|
|
|
|
// a single error entry instead. |
|
|
|
|
// |
|
|
|
|
// If there is an error processing any single instance, no predictions |
|
|
|
|
// are returned and the `error` field is populated with the error message. |
|
|
|
|
// Even though there is one prediction per instance, the format of a |
|
|
|
|
// prediction is not directly related to the format of an instance. |
|
|
|
|
// Predictions take whatever format is specified in the outputs collection |
|
|
|
|
// defined in the model. The collection of predictions is returned in a JSON |
|
|
|
|
// list. Each member of the list can be a simple value, a list, or a JSON |
|
|
|
|
// object of any complexity. If your model has more than one output tensor, |
|
|
|
|
// each prediction will be a JSON object containing a name/value pair for each |
|
|
|
|
// output. The names identify the output aliases in the graph. |
|
|
|
|
// |
|
|
|
|
// Examples: |
|
|
|
|
// The following examples show some possible responses: |
|
|
|
|
// |
|
|
|
|
// A simple set of predictions for three input instances, where each |
|
|
|
|
// prediction is an integer value: |
|
|
|
|
// <pre> |
|
|
|
|
// # Predictions for three input instances, predictions are an integer label, |
|
|
|
|
// |
|
|
|
|
// # e.g., a digit in digit recognition |
|
|
|
|
// |
|
|
|
|
// {"predictions": [5, 4, 3]} |
|
|
|
|
// |
|
|
|
|
// # Predictions for two input instances in a two-class classification |
|
|
|
|
// |
|
|
|
|
// # problem. The labels are strings and scores are the probability of |
|
|
|
|
// |
|
|
|
|
// # "car" and "beach". |
|
|
|
|
// |
|
|
|
|
// </pre> |
|
|
|
|
// A more complex set of predictions, each containing two named values that |
|
|
|
|
// correspond to output tensors, named **label** and **scores** respectively. |
|
|
|
|
// The value of **label** is the predicted category ("car" or "beach") and |
|
|
|
|
// **scores** contains a list of probabilities for that instance across the |
|
|
|
|
// possible categories. |
|
|
|
|
// <pre> |
|
|
|
|
// {"predictions": [{"label": "beach", "scores": [0.1, 0.9]}, |
|
|
|
|
// {"label": "car", "scores": [0.75, 0.25]}]} |
|
|
|
|
// |
|
|
|
|
// # An error: |
|
|
|
|
// |
|
|
|
|
// {"error": "Divide by zero"} |
|
|
|
|
// </pre> |
|
|
|
|
// A response when there is an error processing an input instance: |
|
|
|
|
// <pre> |
|
|
|
|
// {"error": "Divide by zero"} |
|
|
|
|
// </pre> |
|
|
|
|
rpc Predict(PredictRequest) returns (google.api.HttpBody) { |
|
|
|
|
option (google.api.http) = { post: "/v1beta1/{name=projects/**}:predict" body: "*" }; |
|
|
|
|
@ -79,128 +86,99 @@ service OnlinePredictionService { |
|
|
|
|
|
|
|
|
|
// Request for predictions to be issued against a trained model. |
|
|
|
|
// |
|
|
|
|
// The body of the request consists of a single JSON object with a single |
|
|
|
|
// top-level field: |
|
|
|
|
// The body of the request is a single JSON object with a single top-level |
|
|
|
|
// field: |
|
|
|
|
// |
|
|
|
|
// * `instances`: a list of JSON values representing the instances to use for |
|
|
|
|
// prediction. |
|
|
|
|
// <dl> |
|
|
|
|
// <dt>instances</dt> |
|
|
|
|
// <dd>A JSON array containing values representing the instances to use for |
|
|
|
|
// prediction.</dd> |
|
|
|
|
// </dl> |
|
|
|
|
// |
|
|
|
|
// The structure of each element of the instances list is the type of data |
|
|
|
|
// your model expects to work on. There are two types of instances: those |
|
|
|
|
// that include named inputs and those that do not. |
|
|
|
|
// The structure of each element of the instances list is determined by your |
|
|
|
|
// model's input definition. Instances can include named inputs or can contain |
|
|
|
|
// only unlabeled values. |
|
|
|
|
// |
|
|
|
|
// Most data does not include named inputs. In this case, each instance will |
|
|
|
|
// be a JSON boolean, number, string, or (possibly deeply nested) list of |
|
|
|
|
// any of the above. For instance, if your model accepts rows of CSV data, |
|
|
|
|
// then each element is a string; if each data instance is a vector of ints |
|
|
|
|
// or floats, use a JSON list of numbers, etc. More examples are as follows: |
|
|
|
|
// Most data does not include named inputs. Some instances will be simple |
|
|
|
|
// JSON values (boolean, number, or string). However, instances are often lists |
|
|
|
|
// of simple values, or complex nested lists. Here are some examples of request |
|
|
|
|
// bodies: |
|
|
|
|
// |
|
|
|
|
// CSV data with each row encoded as a string value: |
|
|
|
|
// <pre> |
|
|
|
|
// # CSV data |
|
|
|
|
// |
|
|
|
|
// {"instances": ["1.0,true,\\"x\\"", "-2.0,false,\\"y\\""]} |
|
|
|
|
// |
|
|
|
|
// # Text |
|
|
|
|
// |
|
|
|
|
// </pre> |
|
|
|
|
// Plain text: |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": ["the quick brown fox", "la bruja le dio"]} |
|
|
|
|
// |
|
|
|
|
// # Sentences, each a list of words (vectors of strings). |
|
|
|
|
// |
|
|
|
|
// </pre> |
|
|
|
|
// Sentences encoded as lists of words (vectors of strings): |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [["the","quick","brown"], ["la","bruja","le"]]} |
|
|
|
|
// |
|
|
|
|
// # Three instances, each a floating point scalar, e.g., to compute f(x). |
|
|
|
|
// |
|
|
|
|
// {"instances": [0.0, 1.1, 2.2]} # 3 instances (integer scalars) |
|
|
|
|
// |
|
|
|
|
// # Two instances, each a 3 element vecor of ints. |
|
|
|
|
// |
|
|
|
|
// {"instances": [[0,1,2], [3,4,5],...]} |
|
|
|
|
// |
|
|
|
|
// # A single instance, which is 2x3 matrix of ints. |
|
|
|
|
// |
|
|
|
|
// {"instances": [[[0,1,2], [3,4,5]], ...]} |
|
|
|
|
// |
|
|
|
|
// # A single image represented as a 3-dimensional list with dimesions: |
|
|
|
|
// |
|
|
|
|
// # height, width, and channels (3). |
|
|
|
|
// |
|
|
|
|
// {"instances": [[[[0,1,2], [3,4,5], …]]]]} |
|
|
|
|
// </pre> |
|
|
|
|
// |
|
|
|
|
// Importantly, if your data is not UTF-8 (the only currently supported |
|
|
|
|
// character set), you will need to base64 encode the data and mark it as |
|
|
|
|
// binary. The latter is accomplished by using a JSON object of the form: |
|
|
|
|
// Floating point scalar values: |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [0.0, 1.1, 2.2]} |
|
|
|
|
// </pre> |
|
|
|
|
// Vectors of integers: |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [[0, 1, 2], [3, 4, 5],...]} |
|
|
|
|
// </pre> |
|
|
|
|
// Tensors (in this case, two-dimensional tensors): |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [[[0, 1, 2], [3, 4, 5]], ...]} |
|
|
|
|
// </pre> |
|
|
|
|
// Images represented as a three-dimensional list. In this encoding scheme the |
|
|
|
|
// first two dimensions represent the rows and columns of the image, and the |
|
|
|
|
// third contains the R, G, and B values for each pixel. |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [[[[138, 30, 66], [130, 20, 56], ...]]]]} |
|
|
|
|
// </pre> |
|
|
|
|
// Data must be encoded as UTF-8. If your data uses another character encoding, |
|
|
|
|
// you must base64 encode the data and mark it as binary. To mark a JSON string |
|
|
|
|
// as binary, replace it with an object with a single attribute named `b`: |
|
|
|
|
// <pre>{"b": "..."} </pre> |
|
|
|
|
// in place of any JSON string that is base64 encoded. For example: |
|
|
|
|
// For example: |
|
|
|
|
// |
|
|
|
|
// Two Serialized tf.Examples (fake data, for illustrative purposes only): |
|
|
|
|
// <pre> |
|
|
|
|
// # Two Serialized tf.Examples (fake data, for illustrative purposes only) |
|
|
|
|
// |
|
|
|
|
// {"instances": [{"b": "X5ad6u"}, {"b": "IA9j4nx"}]} |
|
|
|
|
// |
|
|
|
|
// # Two JPEG image byte strings (fake data, for illustrative purposes only) |
|
|
|
|
// |
|
|
|
|
// {"instances": [{"b": "ASa8asdf"}, {"b": "JLK7ljk3"}]} |
|
|
|
|
// {"instances": [{"b64": "X5ad6u"}, {"b64": "IA9j4nx"}]} |
|
|
|
|
// </pre> |
|
|
|
|
// |
|
|
|
|
// In the case that your data includes named references, you will send a |
|
|
|
|
// JSON object with the named references as the keys. For instance, if |
|
|
|
|
// you used Cloud ML's preprocessing library and used the JSON key-value |
|
|
|
|
// pair data format, you would send instances as follows: |
|
|
|
|
// |
|
|
|
|
// Two JPEG image byte strings (fake data, for illustrative purposes only): |
|
|
|
|
// <pre> |
|
|
|
|
// # JSON input data to be preprocessed. |
|
|
|
|
// {"instances": [{"b64": "ASa8asdf"}, {"b64": "JLK7ljk3"}]} |
|
|
|
|
// </pre> |
|
|
|
|
// If your data includes named references, format each instance as a JSON object |
|
|
|
|
// with the named references as the keys: |
|
|
|
|
// |
|
|
|
|
// JSON input data to be preprocessed: |
|
|
|
|
// <pre> |
|
|
|
|
// {"instances": [{"a": 1.0, "b": true, "c": "x"}, |
|
|
|
|
// {"a": -2.0, "b": false, "c": "y"}]} |
|
|
|
|
// </pre> |
|
|
|
|
// Some models have an underlying TensorFlow graph that accepts multiple input |
|
|
|
|
// tensors. In this case, you should use the names of JSON name/value pairs to |
|
|
|
|
// identify the input tensors, as shown in the following exmaples: |
|
|
|
|
// |
|
|
|
|
// Another use case is if your underlying TensorFlow graph contains multiple |
|
|
|
|
// input tensors, then the keys would be the aliases to the input tensors, e.g., |
|
|
|
|
// |
|
|
|
|
// For a graph with input tensor aliases "tag" (string) and "image" |
|
|
|
|
// (base64-encoded string): |
|
|
|
|
// <pre> |
|
|
|
|
// # Graph with input tensor aliases "tag" (string) and "image" (base64 |
|
|
|
|
// |
|
|
|
|
// # encoded string). |
|
|
|
|
// |
|
|
|
|
// {"instances": [{"tag": "beach", "image": {"b": "ASa8asdf"}}, |
|
|
|
|
// {"tag": "car", "image": {"b": "JLK7ljk3"}}]} |
|
|
|
|
// |
|
|
|
|
// # Graph with input tensor aliases "tag" (string) and "image" |
|
|
|
|
// |
|
|
|
|
// # (3-dimensional array of 8-bit ints). |
|
|
|
|
// |
|
|
|
|
// {"instances": [{"tag": "beach", "image": [[[263,1,10], [262,2,11], ...]]}, |
|
|
|
|
// {"tag": "car", "image": [[[10,11,24], [23,10,15], ...]]}]} |
|
|
|
|
// {"instances": [{"tag": "beach", "image": {"b64": "ASa8asdf"}}, |
|
|
|
|
// {"tag": "car", "image": {"b64": "JLK7ljk3"}}]} |
|
|
|
|
// </pre> |
|
|
|
|
// |
|
|
|
|
// There is a one-to-one correspondence between the predictions and the |
|
|
|
|
// instances in the request. Each individual prediction takes the same form |
|
|
|
|
// as an instance in the request, namely JSON strings, numbers, booleans, or |
|
|
|
|
// lists thereof. If your model has more than one output tensor, each |
|
|
|
|
// prediction will be a JSON object with the keys being the output aliases |
|
|
|
|
// in the graph. |
|
|
|
|
// |
|
|
|
|
// Examples: |
|
|
|
|
// |
|
|
|
|
// For a graph with input tensor aliases "tag" (string) and "image" |
|
|
|
|
// (3-dimensional array of 8-bit ints): |
|
|
|
|
// <pre> |
|
|
|
|
// # Predictions for three input instances, predictions are an integer label, |
|
|
|
|
// |
|
|
|
|
// # e.g., a digit in digit recognition |
|
|
|
|
// |
|
|
|
|
// {"predictions": [5, 4, 3]} |
|
|
|
|
// |
|
|
|
|
// # Predictions for two input instances in a two-class classification |
|
|
|
|
// |
|
|
|
|
// # problem. The labels are strings and scores are the probability of "car" |
|
|
|
|
// |
|
|
|
|
// # and "beach". |
|
|
|
|
// |
|
|
|
|
// {"predictions": [{"label": "beach", "scores": [0.1, 0.9]}, |
|
|
|
|
// {"label": "car", "scores": [0.75, 0.25]}]} |
|
|
|
|
// {"instances": [{"tag": "beach", "image": [[[263, 1, 10], [262, 2, 11], ...]]}, |
|
|
|
|
// {"tag": "car", "image": [[[10, 11, 24], [23, 10, 15], ...]]}]} |
|
|
|
|
// </pre> |
|
|
|
|
// If the call is successful, the response body will contain one prediction |
|
|
|
|
// entry per instance in the request body. If prediction fails for any |
|
|
|
|
// instance, the response body will contain no predictions and will contian |
|
|
|
|
// a single error entry instead. |
|
|
|
|
message PredictRequest { |
|
|
|
|
// Required. The resource name of a model or a version. |
|
|
|
|
// |
|
|
|
|
// Authorization: requires `Viewer` role on the parent project. |
|
|
|
|
string name = 1; |
|
|
|
|
|
|
|
|
|
|
Jacob Geiger
9 years ago