Returns information about a trained model; most often used to request the training status of a model. Training is an asynchronous process; after invoking training by calling prediction.training.insert() , you must call get() and examine the trainingStatus member of the returned resource to learn the training status.

Important: Only the user who trained a model can call this method.

This method returns a modelInfo.confusionMatrix property that describes a confusion matrix of labels properly and improperly applied to each training entry during training. This is useful for evaluating the accuracy of training over your data; if the matrix indicates that specific values are often confused, you might want to change your training data structure.

Here is an example confusion matrix for a language identification model. In this model, for all entries with the label "French", 12 were properly identified as French and 0.5 were improperly identified as English. You can see the values for items labeled "Spanish" and "English" as well. Numbers can be fractions because they are averaged across multiple training runs. confusionMatrixRowTotals describes the total number of each label applied.

"confusionMatrix": {
   "French": {
    "French": 12.0,
    "English": 0.5
   },
   "Spanish": {
    "Spanish": 6.0,
    "English": 1.0
   },
   "English": {
    "French": 0.5,
    "Spanish": 2.0,
    "English": 20.0
   }
  },
  "confusionMatrixRowTotals": {
   "French": 12.5,
   "Spanish": 7.0,
   "English": 22.5
  }
 }

Note: If you are retraining an existing model, the modelInfo field will show an accuracy value in even if the new training is not complete. This number will be the accuracy of the previously trained model, which is still usable, until the new model has finished training.

GET https://www.googleapis.com/prediction/v1.3/training/bucket%2Fobject

Invoking this method requires the use of a token with access to:
https://www.googleapis.com/auth/prediction

Asynchronous request to train your model.

Invoke training on your data by sending a POST request as described below. Note that each time you call this method, it will clear out any existing model with the same name. After making this request, you must call prediction.training.get() to check training status to determine when training is complete.

You must have read permission on the Google Storage object that holds your training data. By default, a Google Storage object only supports read access to the object creator. See here to learn how to read or modify Google Storage object ACLs.

Request data is a Training resource with the following properties:

• id - The bucket/object name of the model.
• utility [ Optional, categorical models only ] - Assigns a numeric weight to one or more categories in the training data. The purpose of this property is to prevent false positives by assigning a relative weight to specific categories, where the higher the value, the higher the associated cost with mislabeling something that is actually in that category as something else. For example, in a spam identification model, identifying some spam as non-spam is relatively lower cost than identifying some non-spam as spam. Therefore you would include a utility property with the following value (assuming your non-spam examples have the label 'not_spam'): 'utility':[{'not_spam':5.0}] . Unlisted labels receive a default weight of 1.0, so the previous example would assign 'spam' a utility value of 1.0.

Training requests are asynchronous; if successful, the request returns immediately with the following reply, indicating that training has begun. Check training status to learn when training is complete. Training can take up to 10 minutes, depending on the complexity and size of the data, but will typically take less time. A successful response is a simple echo of the data location as shown here:

{
  "kind":"prediction#training",
  "id":"bucket/object",
  "selfLink":"https://www.googleapis.com/prediction/v1.3/URL_of_resource,
}

POST https://www.googleapis.com/prediction/v1.3/training

Invoking this method requires the use of a token with access to:
https://www.googleapis.com/auth/prediction

[ Categorization models only ]  Streaming training: trains a previously trained model against a new example. This is useful if you have a regular stream of new information that you'd like to add to your model as it becomes available, rather than having to recompile, re-upload, and retrain the data with batches of new data. The model is not retrained each time it receives a new example; rather, it retrains after every N new examples have been added, where N is a small number.

Note that the system may weight newer streamed examples more than earlier examples. If you do not want this, you should add the examples to your training data and retrain the system against all the data by calling prediction.training.insert() .

Note: If you retrain a model against its original training data file, all the streamed data will be lost.

The request takes a JSON object with the following parameters:

{
  "classLabel" : my_label
  "csvInstance: [ col1, col2....colN ]
}

classLabel

The category label to assign to this example. Only category examples can be streamed to an existing model.

csvInstance

The example data as an array of columns, in the same format as the CSV file .

PUT https://www.googleapis.com/prediction/v1.3/training/bucket%2Fobject

Invoking this method requires the use of a token with access to:
https://www.googleapis.com/auth/prediction

Deletes a trained model. Only the user who inserted (trained) a model can delete it.

If successful, an empty response is returned. Otherwise, an appropriate HTTP or Prediction API error will be returned.

DELETE https://www.googleapis.com/prediction/v1.3/training/bucket%2Fobject

Invoking this method requires the use of a token with access to:
https://www.googleapis.com/auth/prediction

Run a prediction request against your model.

Input data is an object with the following syntax:

{
  "input":{
    "csvInstance":[ col1_value, col2_value, ... ]
  }
}

Where col1_value , col2_value , and so on are entity features, as described by the hosted model's documentation. Note that string fields must be surrounded by escaped quotes.

Here's an example request to a hosted model that predicts a person's height, if the model expects a string gender ("M" or "F"), two height numbers, and a string country name:

{
  "input":{
    "csvInstance":["M", 1.59, 1.51,"France"]
  }
}

Notes on categorical model response scores:

• Score values range from 0.0–1.0, with 1.0 being the highest. All values should add up to 1.0. Note: if you used an earlier version of the API that used a different range, you must retrain your data model in order for scores to be scaled to 0.0–1.0.
• Consider having a cutoff value above which the categorization is useful and below which you might ignore it. We can't advise a hard cutoff value; instead, try running a few queries for borderline items, and use that as an approximate cutoff value for your categories.
• These values are not probabilities; that is, they are not the confidence that a rating is correct. They are a measure of how closely a category seems to conform to the query item.
• Scores are relative to each other, and do not need to add up to a specific value (for example, to 1.0).
• It is hard to say absolutely what is a significant difference in scores. For example, is 0.33 is "significantly" better than 0.42? Is 0.25 "twice as good" as 0.125? Instead, assume that the highest value is the best fit, and have a cutoff value that, if the best fit is below it, you won't use the data. You'll have to experiment with the system to determine what is a meaningful cutoff value for your data.

POST https://www.googleapis.com/prediction/v1.3/training/mybucket%2Fmyobject/predict

{
  "kind": "prediction#output",
  "id": string,
  "selfLink": string,
  "outputLabel": string,
  "outputMulti": [
    {
      "label": string,
      "score": double
    }
  ],
  "outputValue": double
}

Invoking this method requires the use of a token with access to:
https://www.googleapis.com/auth/prediction