Como listar modelos

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Visão geral

Nesta página, você verá como listar modelos do BigQuery ML em um conjunto de dados. É possível fazer isso:

  • Usando o Console do Google Cloud.
  • use o comando bq ls na ferramenta de linha de comando bq.
  • chamando o método da API models.list diretamente ou usando as bibliotecas de cliente.

Permissões necessárias

Para listar modelos em um conjunto de dados, você deve receber o papel READER no conjunto de dados ou um papel IAM para envolvidos no projeto que inclua permissões bigquery.models.list. Se você receber as permissões bigquery.models.list para envolvidos no projeto, poderá listar modelos em qualquer conjunto de dados no projeto. Os seguintes papéis predefinidos do IAM para envolvidos no projeto incluem permissões bigquery.models.list:

  • bigquery.dataViewer
  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.metadataViewer
  • bigquery.user
  • bigquery.admin

Para informações sobre papéis e permissões do IAM no BigQuery ML, consulte Controle de acesso. Para mais informações sobre papéis no nível do conjunto de dados, consulte Papéis básicos para conjuntos de dados na documentação do BigQuery.

Como listar modelos

Para listar modelos em um conjunto de dados:

Console

  1. No console do Google Cloud, acesse a página do BigQuery.

    Acesse a página do BigQuery

  2. Na seção Recursos do painel de navegação, clique no nome do projeto.

  3. À medida que você expande cada um dos conjuntos de dados em um projeto, os modelos são listados junto a outros recursos do BigQuery nos conjuntos de dados. Os modelos são indicados pelo ícone do modelo: ícone do modelo .

bq

Emita o comando bq ls com a sinalização --models ou -m. A sinalização --format pode ser usada para controlar a saída. Se estiver listando modelos em um projeto diferente do projeto padrão, adicione a ID do projeto ao conjunto de dados no seguinte formato: [PROJECT_ID]:[DATASET].

bq ls -m --format=pretty [PROJECT_ID]:[DATASET]

Em que:

  • [PROJECT_ID] é o ID do projeto;
  • [DATASET] é o nome do conjunto de dados.

A resposta ao comando será semelhante à seguinte quando a sinalização --format=pretty for usada. --format=pretty produz saída de tabela formatada. A coluna Model Type exibe o tipo de modelo, por exemplo, KMEANS.

+-------------------------+------------+--------+-----------------+
|           Id            | Model Type | Labels |  Creation Time  |
+-------------------------+------------+--------+-----------------+
| mymodel                 | KMEANS     |        | 03 May 03:02:27 |
+-------------------------+------------+--------+-----------------+

Exemplos:

Digite o comando a seguir para listar modelos no conjunto de dados mydataset no seu projeto padrão.

bq ls --models --format=pretty mydataset

Digite o comando a seguir para listar modelos no conjunto de dados mydataset em myotherproject. Esse comando usa o atalho -m para fazer a listagem.

bq ls -m --format=pretty myotherproject:mydataset

API

Para listar modelos usando a API, chame o método models.list e forneça projectId e datasetId.

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// listModels demonstrates iterating through the collection of ML models in a dataset
// and printing a basic identifier of the model.
func listModels(w io.Writer, projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	fmt.Fprintf(w, "Models contained in dataset %q\n", datasetID)
	it := client.Dataset(datasetID).Models(ctx)
	for {
		m, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "Model: %s\n", m.FullyQualifiedName())
	}
	return nil
}

Java 

import com.google.api.gax.paging.Page;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQuery.ModelListOption;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Model;

public class ListModels {

  public static void runListModels() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    listModels(datasetName);
  }

  public static void listModels(String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Page<Model> models = bigquery.listModels(datasetName, ModelListOption.pageSize(100));
      if (models == null) {
        System.out.println("Dataset does not contain any models.");
        return;
      }
      models
          .iterateAll()
          .forEach(model -> System.out.printf("Success! Model ID: %s", model.getModelId()));
    } catch (BigQueryException e) {
      System.out.println("Models not listed in dataset due to error: \n" + e.toString());
    }
  }
}

Node.js 


// Import the Google Cloud client library
const {BigQuery} = require('@google-cloud/bigquery');
const bigquery = new BigQuery();

async function listModels() {
  // Lists all existing models in the dataset.

  /**
   * TODO(developer): Uncomment the following lines before running the sample.
   */
  // const datasetId = "my_dataset";

  const dataset = bigquery.dataset(datasetId);

  dataset.getModels().then(data => {
    const models = data[0];
    console.log('Models:');
    models.forEach(model => console.log(model.metadata));
  });
}

Python 


from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset that contains
#                  the models you are listing.
# dataset_id = 'your-project.your_dataset'

models = client.list_models(dataset_id)  # Make an API request.

print("Models contained in '{}':".format(dataset_id))
for model in models:
    full_model_id = "{}.{}.{}".format(
        model.project, model.dataset_id, model.model_id
    )
    friendly_name = model.friendly_name
    print("{}: friendly_name='{}'".format(full_model_id, friendly_name))

A seguir