google_api_machine_learning v0.0.1 API Reference

Modules

API calls for all endpoints tagged Projects

Handle Tesla connections for GoogleApi.MachineLearning.V1

Helper functions for deserializing responses into models

Message that represents an arbitrary HTTP body. It should only be used for payload formats that can't be represented as JSON, such as raw binary or an HTML page. This message can be used both in streaming and non-streaming API methods in the request as well as the response. It can be used as a top-level request field, which is convenient if one wants to extract parameters from either the URL or HTTP template into the request fields and also want access to the raw HTTP body. Example: message GetResourceRequest { // A unique request id. string request_id = 1; // The raw HTTP body is bound to this field. google.api.HttpBody http_body = 2; } service ResourceService { rpc GetResource(GetResourceRequest) returns (google.api.HttpBody); rpc UpdateResource(google.api.HttpBody) returns (google.protobuf.Empty); } Example with streaming methods: service CaldavService { rpc GetCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); rpc UpdateCalendar(stream google.api.HttpBody) returns (stream google.api.HttpBody); } Use of this type only changes how the request and response bodies are handled, all other features will continue to work unchanged

Options for automatically scaling a model

Returns service account information associated with a project

Represents the result of a single hyperparameter tuning trial from a training job. The TrainingOutput object that is returned on successful completion of a training job with hyperparameter tuning includes a list of HyperparameterOutput objects, one for each successful trial

Represents a set of hyperparameters to optimize

Represents a training or prediction job. Next ID: 16

Represents a machine learning solution. A model can have multiple versions, each of which is a deployed, trained model ready to receive prediction requests. The model itself is just a container. Next ID: 8

Represents the metadata of the long-running operation. Next ID: 9

Represents a single hyperparameter to optimize

Request for predictions to be issued against a trained model. The body of the request is a single JSON object with a single top-level field: <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 determined by your model's input definition. Instances can include named inputs or can contain only unlabeled values. Not all data includes 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> {"instances": ["1.0,true,\"x\"", "-2.0,false,\"y\""]} </pre> Plain text: <pre> {"instances": ["the quick brown fox", "la bruja le dio"]} </pre> Sentences encoded as lists of words (vectors of strings): <pre> { "instances": [ ["the","quick","brown"], ["la","bruja","le"], … ] } </pre> 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 can be represented different ways. In this encoding scheme the first two dimensions represent the rows and columns of the image, and the third contains lists (vectors) of the R, G, and B values for each pixel. <pre> { "instances": [ [ [ [138, 30, 66], [130, 20, 56], … ], [ [126, 38, 61], [122, 24, 57], … ], … ], … ] } </pre> JSON strings must be encoded as UTF-8. To send binary data, you must base64-encode the data and mark it as binary. To mark a JSON string as binary, replace it with a JSON object with a single attribute named `b64`: <pre>{"b64": "…"} </pre> For example: Two Serialized tf.Examples (fake data, for illustrative purposes only): <pre> {"instances": [{"b64": "X5ad6u"}, {"b64": "IA9j4nx"}]} </pre> Two JPEG image byte strings (fake data, for illustrative purposes only): <pre> {"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: For a graph with input tensor aliases "tag" (string) and "image" (base64-encoded string): <pre> { "instances": [ { "tag": "beach", "image": {"b64": "ASa8asdf"} }, { "tag": "car", "image": {"b64": "JLK7ljk3"} } ] } </pre> For a graph with input tensor aliases "tag" (string) and "image" (3-dimensional array of 8-bit ints): <pre> { "instances": [ { "tag": "beach", "image": [ [ [138, 30, 66], [130, 20, 56], … ], [ [126, 38, 61], [122, 24, 57], … ], … ] }, { "tag": "car", "image": [ [ [255, 0, 102], [255, 0, 97], … ], [ [254, 1, 101], [254, 2, 93], … ], … ] }, … ] } </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

Represents input parameters for a prediction job

Request message for the SetDefaultVersion request

Represents input parameters for a training job

Represents results of a training job. Output only

Represents a version of the model. Each version is a trained model deployed in the cloud, ready to handle prediction requests. A model can have multiple versions. You can get information about all of the versions of a given model by calling projects.models.versions.list. Next ID: 18

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. At present the only supported field names are - "iam_principal", corresponding to IAMContext.principal; - "" (empty string), resulting in one aggretated counter with no field. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/backend_debug_access_count {iam_principal=[value of IAMContext.principal]} At this time we do not support: multiple field names (though this may be supported in the future) decrementing the counter * incrementing it by anything other than 1

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices" "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:foo@gmail.com" ] }, { "log_type": "DATA_WRITE", }, { "log_type": "ADMIN_READ", } ] }, { "service": "fooservice.googleapis.com" "audit_log_configs": [ { "log_type": "DATA_READ", }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:bar@gmail.com" ] } ] } ] } For fooservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts foo@gmail.com from DATA_READ logging, and bar@gmail.com from DATA_WRITE logging

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:foo@gmail.com" ] }, { "log_type": "DATA_WRITE", } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting foo@gmail.com from DATA_READ logging

Associates `members` with a `role`

Specifies what kind of log the caller must write

Defines an Identity and Access Management (IAM) policy. It is used to specify access control policies for Cloud Platform resources. A `Policy` consists of a list of `bindings`. A `Binding` binds a list of `members` to a `role`, where the members can be user accounts, Google groups, Google domains, and service accounts. A `role` is a named list of permissions defined by IAM. Example { "bindings": [ { "role": "roles/owner", "members": [ "user:mike@example.com", "group:admins@example.com", "domain:google.com", "serviceAccount:my-other-app@appspot.gserviceaccount.com", ] }, { "role": "roles/viewer", "members": ["user:sean@example.com"] } ] } For a description of IAM and its features, see the IAM developer's guide

A rule to be applied in a Policy

Request message for `TestIamPermissions` method

Response message for `TestIamPermissions` method

The response message for Operations.ListOperations

This resource represents a long-running operation that is the result of a network API call

A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance: service Foo { rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON representation for `Empty` is empty JSON object `{}`

The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by gRPC. The error model is designed to be: - Simple to use and understand for most users - Flexible enough to meet unexpected needs # Overview The `Status` message contains three pieces of data: error code, error message, and error details. The error code should be an enum value of google.rpc.Code, but it may accept additional error codes if needed. The error message should be a developer-facing English message that helps developers understand and resolve the error. If a localized user-facing error message is needed, put the localized message in the error details or localize it in the client. The optional error details may contain arbitrary information about the error. There is a predefined set of error detail types in the package `google.rpc` that can be used for common error conditions. # Language mapping The `Status` message is the logical representation of the error model, but it is not necessarily the actual wire format. When the `Status` message is exposed in different client libraries and different wire protocols, it can be mapped differently. For example, it will likely be mapped to some exceptions in Java, but more likely mapped to some error codes in C. # Other uses The error model and the `Status` message can be used in a variety of environments, either with or without APIs, to provide a consistent developer experience across different environments. Example uses of this error model include: - Partial errors. If a service needs to return partial errors to the client, it may embed the `Status` in the normal response to indicate the partial errors. - Workflow errors. A typical workflow has multiple steps. Each step may have a `Status` message for error reporting. - Batch operations. If a client uses batch request and batch response, the `Status` message should be used directly inside batch response, one for each error sub-response. - Asynchronous operations. If an API call embeds asynchronous operation results in its response, the status of those operations should be represented directly using the `Status` message. - Logging. If some API errors are stored in logs, the message `Status` could be used directly after any stripping needed for security/privacy reasons

Represents an expression text. Example: title: "User account presence" description: "Determines whether the request has a user account" expression: "size(request.user) > 0"

Helper functions for building Tesla requests