Usar DataFrames do BigQuery

O DataFrames do BigQuery fornece um DataFrame e uma API de machine learning (ML) em Python com tecnologia do mecanismo do BigQuery. O DataFrames do BigQuery é um pacote de código aberto. Execute pip install --upgrade bigframes para instalar a versão mais recente.

O DataFrames do BigQuery oferece duas bibliotecas:

  • bigframes.pandas, que fornece uma API compatível com pandas para análise.

  • bigframes.ml, que fornece uma API semelhante ao scikit-learn para machine learning (ML).

Permissões necessárias

Opções

Após a instalação, é preciso especificar o local e o projeto em que você quer usar o BigQuery DataFrames. É possível definir o local e o projeto no notebook da seguinte maneira: 
import bigframes.pandas as bpd

PROJECT_ID = "bigframes-dec"  # @param {type:"string"}
REGION = "US"  # @param {type:"string"}

# Set BigQuery DataFrames options
# Note: The project option is not required in all environments.
# On BigQuery Studio, the project ID is automatically detected.
bpd.options.bigquery.project = PROJECT_ID

# Note: The location option is not required.
# It defaults to the location of the first table or query
# passed to read_gbq(). For APIs where a location can't be
# auto-detected, the location defaults to the "US" location.
bpd.options.bigquery.location = REGION

Se bf.options.bigquery.project não estiver definido, a variável de ambiente $GOOGLE_CLOUD_PROJECT será usada. Ela é definida no ambiente de execução do notebook que veicula os notebooks do BigQuery Studio e da Vertex AI.

Local de processamento dos dados

O DataFrames do BigQuery foi projetado para escalonar, o que é alcançado mantendo os dados e o processamento no serviço BigQuery. No entanto, é possível transferir dados para a memória da máquina cliente chamando .to_pandas() em um objeto DataFrame ou Series. Nesse caso, a limitação de memória da máquina cliente será aplicada.

Local da sessão

O DataFrames do BigQuery usa um objeto de sessão local para gerenciar metadados internamente. Essa sessão está vinculada a um local. O DataFrames do BigQuery usa a multirregião US como o local padrão, mas é possível usar session_options.location para definir um local diferente. Cada consulta em uma sessão é executada no local em que a sessão foi criada. Se o usuário começar com read_gbq/read_gbq_table/read_gbq_query() e especificar uma tabela, diretamente ou em uma instrução SQL, o DataFrames do BigQuery preencherá automaticamente bf.options.bigquery.location com o local da tabela.

Caso queira redefinir o local dos objetos DataFrame ou Series criados, encerre a sessão executando bigframes.pandas.close_session(). Depois disso, você poderá reutilizar bigframes.pandas.options.bigquery.location para especificar outro local.

read_gbq() requer que você especifique um local se o conjunto de dados que você está consultando não estiver na multirregião US. Se você tentar ler uma tabela de outro local, será gerada uma exceção NotFound.

Tipos de dados

O DataFrames do BigQuery oferece suporte aos seguintes dtypes numpy e pandas:

BigQuery DataFrames do BigQuery e pandas
ARRAY pandas.ArrowDtype(pa.list_())
BOOL pandas.BooleanDtype()
DATE pandas.ArrowDtype(pa.date32())
DATETIME pandas.ArrowDtype(pa.timestamp("us"))
FLOAT64 pandas.Float64Dtype()
GEOGRAPHY

geopandas.array.GeometryDtype()

Suporte para to_pandas() only
INT64 pandas.Int64Dtype()
STRING pandas.StringDtype(storage="pyarrow")
STRUCT pandas.ArrowDtype(pa.struct())
TIME pandas.ArrowDtype(pa.time64("us"))
TIMESTAMP pandas.ArrowDtype(pa.timestamp("us", tz="UTC"))

O DataFrames do BigQuery não oferece suporte aos seguintes tipos de dados do BigQuery:

  • NUMERIC

  • BIGNUMERIC

  • INTERVAL

  • RANGE

  • JSON

Todos os outros tipos de dados do BigQuery são mostrados como o tipo de objeto.

Modo de ordenação parcial

O DataFrames do BigQuery oferece um recurso de modo de ordenação. Defina o ordering_mode como partial para gerar consultas mais eficientes.

O modo de ordenação partial contrasta com o modo strict padrão, que cria uma ordenação total em todas as linhas. Uma ordenação total torna os DataFrames do BigQuery mais compatíveis com o pandas, fornecendo acesso baseado em ordem às linhas com a propriedade DataFrame.iloc. No entanto, a ordenação total e o índice sequencial padrão sobre essa ordenação significam que nem os filtros de coluna nem os de linha reduzem o número de bytes verificados, a menos que esses filtros sejam aplicados como parâmetros às funções read_gbq e read_gbq_table. Para fornecer uma ordenação total de todas as linhas no DataFrame, o BigQuery DataFrames cria um hash de todas as linhas. Isso pode resultar em uma verificação de dados completa que ignora os filtros de linha e coluna.

Definir a propriedade ordering_mode como partial impede que os DataFrames do BigQuery gerem uma ordenação total em todas as linhas. O modo de ordenação parcial também desativa recursos que exigem uma ordenação total em todas as linhas, como a propriedade DataFrame.iloc. O modo de ordenação parcial define o DefaultIndexKind como um índice nulo, em vez de um índice sequencial sobre a ordenação.

Ao filtrar um DataFrame com ordering_mode definido como partial, os DataFrames do BigQuery não precisam mais calcular quais linhas estão ausentes no índice sequencial. Assim, ele gera consultas mais rápidas e eficientes. A API BigQuery DataFrames ainda é semelhante ao pandas, assim como a experiência padrão com o modo de ordenação estrita. No entanto, o modo de ordenação parcial é diferente do comportamento comum do pandas. Por exemplo, o modo de ordenação parcial não realiza mesclagens implícitas por índice.

Com os modos de ordenação parcial e estrito, você paga pelos recursos do BigQuery que usa. No entanto, o uso do modo de ordenação parcial pode reduzir os custos ao trabalhar com tabelas grandes, agrupadas e/ou particionadas, porque os filtros de linha em colunas de cluster e partição reduzem o número de bytes processados.

Uso

Para usar a ordenação parcial, defina ordering_mode como partial antes de realizar qualquer outra operação com os DataFrames do BigQuery, conforme mostrado no exemplo de código abaixo:

import bigframes.pandas as bpd

bpd.options.bigquery.ordering_mode = "partial"

Como não há um índice sequencial com o modo de ordenação parcial, os DataFrames do BigQuery não relacionados não são mesclados implicitamente. Em vez disso, é necessário chamar explicitamente o método DataFrame.merge para mesclar dois DataFrames do BigQuery que derivam de diferentes expressões de tabela.

Os recursos Series.unique() e Series.drop_duplicates() não são compatíveis com o modo de ordenação parcial. Em vez disso, use o método groupby para encontrar valores exclusivos desta forma:

# Avoid order dependency by using groupby instead of drop_duplicates.
unique_col = df.groupby(["column"], as_index=False).size().drop(columns="size")

Com o modo de ordenação parcial, não é garantido que a saída das funções DataFrame.head(n) e Series.head(n) seja idempotente em todas as invocações. Para fazer o download de uma amostra pequena e arbitrária dos dados, use os métodos DataFrame.peek() ou Series.peek().

Para conferir um tutorial detalhado em que você usa a propriedade ordering_mode = "partial", consulte este notebook do BigQuery DataFrames que demonstra o uso do modo de ordenação parcial.

Solução de problemas

Erro de pedido obrigatório

Alguns recursos exigem uma ordenação, como as funções DataFrame.head() e DataFrame.iloc. Para conferir uma lista de recursos que exigem ordenação, consulte a coluna Requires ordering em APIs pandas compatíveis.

Quando não há ordenação no objeto, a operação falha com uma mensagem OrderRequiredError como esta:

OrderRequiredError: Op iloc requires an ordering. Use .sort_values or .sort_index to provide an ordering.

Conforme descrito na mensagem de erro, é possível fornecer uma ordenação usando o método DataFrame.sort_values() para classificar por uma ou mais colunas. Outras operações, como a DataFrame.groupby(), fornecem implicitamente uma ordenação total sobre o grupo por chaves.

Se não for possível determinar se a ordenação é totalmente estável em todas as linhas, as operações subsequentes poderão avisar você com uma mensagem AmbiguousWindowWarning como esta:

AmbiguousWindowWarning: Window ordering may be ambiguous, this can cause unstable results.

Se a sua carga de trabalho puder acomodar resultados não determinísticos ou se você puder verificar manualmente se a ordenação fornecida é uma ordenação total, filtre a mensagem AmbiguousWindowWarning desta forma:

import warnings

import bigframes.exceptions

warnings.simplefilter(
    "ignore", category=bigframes.exceptions.AmbiguousWindowWarning
)

Erro de índice nulo

Alguns recursos exigem um índice, como as propriedades DataFrame.unstack() e Series.interpolate().Para conferir uma lista de recursos que exigem um índice, consulte a coluna Requer índice em APIs pandas com suporte.

Quando você usa uma operação que exige um índice com o modo de ordenação parcial, a operação gera uma mensagem NullIndexError semelhante a esta:

NullIndexError: DataFrame cannot perform interpolate as it has no index. Set an index using set_index.

Conforme descrito na mensagem de erro, é possível fornecer um índice usando o método DataFrame.set_index() para classificar por uma ou mais colunas. Outras operações, como a DataFrame.groupby(), fornecem implicitamente um índice sobre o grupo por chaves, a menos que o parâmetro as_index=False seja definido.

Como usar a biblioteca bigframes.pandas

A biblioteca bigframes.pandas fornece uma API semelhante a pandas que pode ser usada para analisar e manipular dados no BigQuery. A API bigframes.pandas é escalonável para permitir o processamento de terabytes de dados do BigQuery e usa o mecanismo de consulta do BigQuery para realizar cálculos. Para mais informações, consulte APIs pandas compatíveis.

A API bigframes.pandas oferece os seguintes recursos:

Entrada e saída

É possível acessar dados de várias fontes, incluindo arquivos CSV locais, arquivos do Cloud Storage, pandas DataFrames, modelos do BigQuery e funções do BigQuery, e carregá-los em um BigQuery DataFrames DataFrame. Também é possível criar tabelas do BigQuery pelo BigQuery DataFrames.

Manipulação de dados

É possível usar o Python no lugar do SQL para o desenvolvimento. É possível desenvolver todas as manipulações de dados do BigQuery em Python, eliminando a necessidade de alternar entre linguagens e tentar capturar instruções SQL como strings de texto. A API bigframes.pandas oferece mais de 750 funções pandas.

Ecossistema e visualizações em Python

A API bigframes.pandas é um gateway para o ecossistema completo de ferramentas em Python. A API permite operações estatísticas avançadas, e é possível ver as agregações geradas pelo BigQuery DataFrames. Também é possível alternar de um DataFrame do BigQuery DataFrames para um pandas com operações de amostragem integradas.

Funções personalizadas do Python

Com o BigQuery DataFrames, é possível transformar as funções escalares personalizadas em funções remotas do BigQuery. Ao criar uma função remota no DataFrames do BigQuery, você cria o seguinte:

  1. Uma função do Cloud Run (2ª geração).

  2. Uma conexão com o BigQuery Por padrão, uma conexão com o nome bigframes-default-connection é usada. Se preferir, use uma conexão pré-configurada do BigQuery. Nesse caso, a criação da conexão é ignorada.

    A conta de serviço da conexão padrão recebe o papel do IAM de Invocador do Cloud Run (roles/run.invoker).

  3. Uma função remota do BigQuery que usa a função do Cloud (1) usando a conexão do BigQuery (2).

Por exemplo, consulte Criar uma função remota.

As conexões do BigQuery são criadas no mesmo local que a sessão do DataFrames do BigQuery, usando o nome que você informou na definição da função personalizada. Para visualizar e gerenciar conexões, faça o seguinte:

  1. Acesse o BigQuery no console do Google Cloud.

  2. Selecione o projeto em que você criou a função remota.

  3. No painel Explorer, expanda o projeto e, em seguida, as Conexões externas.

As funções remotas do BigQuery são criadas no conjunto de dados que você especifica ou em um conjunto de dados anônimo, um tipo de conjunto de dados oculto. Se você não definir um nome para uma função remota durante a criação, os DataFrames do BigQuery vão aplicar um nome padrão que começa com o prefixo bigframes. Para visualizar e gerenciar funções remotas criadas em um conjunto de dados especificado pelo usuário, faça o seguinte:

  1. Acesse o BigQuery no console do Google Cloud.

  2. Selecione o projeto em que você criou a função remota.

  3. No painel Explorer, expanda esse projeto, expanda o conjunto de dados em que você criou a função remota e, em seguida, expanda Rotinas.

Para conferir e gerenciar as funções do Cloud Run functions, use a página Functions e o seletor de projeto para selecionar o projeto em que você criou a função. Para facilitar a identificação, os nomes das funções criadas pelo DataFrames do BigQuery são prefixados por bigframes.

É possível limpar funções remotas do BigQuery sem nome e as funções do Cloud Run associadas a elas da seguinte maneira:

  • Para um session do BigQuery DataFrames, use session.close().
  • Para a sessão padrão do BigQuery DataFrames, use bigframes.pandas.close_session().
  • Para uma sessão anterior com session_id, use bigframes.pandas.clean_up_by_session_id(session_id).

Requisitos

Para usar as funções remotas do DataFrames do BigQuery, ative as seguintes APIs:

Para usar as funções remotas do DataFrames do BigQuery, você precisa receber os seguintes papéis do IAM no projeto:

  • Editor de dados do BigQuery (roles/bigquery.dataEditor)

  • Administrador de conexão do BigQuery (roles/bigquery.connectionAdmin)

  • Desenvolvedor do Cloud Functions (roles/cloudfunctions.developer)

  • Usuário da conta de serviço (roles/iam.serviceAccountUser)

  • Leitor de objetos do Storage (roles/storage.objectViewer)

  • Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin) se estiver usando a conexão padrão do BigQuery, ou o navegador (papéis/navegador) se estiver usando uma conexão pré-configurada. Para evitar esse requisito, defina a opção bigframes.pandas.options.bigquery.skip_bq_connection_check como True. Nesse caso, a conexão (padrão ou pré-configurada) seria usada no estado em que se encontra, sem qualquer existência ou verificação de permissão. Se você estiver usando a conexão pré-configurada e pulando a verificação de conexão, confirme se a conexão foi criada no local certo e se a conta de serviço tem o papel do chamador do Cloud Run (roles/run.invoker) no projeto.

Limitações

  • As funções remotas levam cerca de 90 segundos para ficar disponíveis quando você as cria pela primeira vez.

  • Alterações triviais no notebook, como inserir uma nova célula ou renomear uma variável, podem fazer com que a função remota seja recriada, mesmo que essas alterações não estejam relacionadas ao código da função remota.

  • O BigQuery DataFrames não diferencia os dados pessoais incluídos no código de função remota. O código da função remota é serializado como uma caixa opaca para implantá-lo como uma função do Cloud Run.

  • As funções do Cloud Run (2ª geração), conexões do BigQuery e funções remotas do BigQuery criadas pelos DataFrames do BigQuery persistem no Google Cloud. Se não quiser manter esses recursos, exclua-os separadamente usando uma interface apropriada do Cloud Run Functions ou do BigQuery.

  • Um projeto pode ter até 1.000 funções do Cloud Run (2ª geração) por vez. Consulte todos os limites em Cotas das funções do Cloud Run.

Exemplos de bigframes.pandas

Os exemplos a seguir mostram maneiras comuns de usar bigframes.pandas.

Carregar dados de uma tabela ou consulta do BigQuery

É possível criar um DataFrame com base em uma tabela ou consulta do BigQuery da seguinte maneira:

# Create a DataFrame from a BigQuery table:
import bigframes.pandas as bpd

query_or_table = "bigquery-public-data.ml_datasets.penguins"
bq_df = bpd.read_gbq(query_or_table)

Carregar dados de um arquivo CSV

É possível criar um DataFrame com base em um arquivo CSV local ou do Cloud Storage da seguinte maneira:

import bigframes.pandas as bpd

filepath_or_buffer = "gs://cloud-samples-data/bigquery/us-states/us-states.csv"
df_from_gcs = bpd.read_csv(filepath_or_buffer)
# Display the first few rows of the DataFrame:
df_from_gcs.head()

Inspecionar e manipular dados

É possível usar bigframes.pandas para realizar operações de inspeção e cálculo de dados.
O exemplo de código a seguir mostra o uso de bigframes.pandas para inspecionar a coluna body_mass_g, calcular a média body_mass e calcular a média body_mass por species:

import bigframes.pandas as bpd

# Load data from BigQuery
query_or_table = "bigquery-public-data.ml_datasets.penguins"
bq_df = bpd.read_gbq(query_or_table)

# Inspect one of the columns (or series) of the DataFrame:
bq_df["body_mass_g"]

# Compute the mean of this series:
average_body_mass = bq_df["body_mass_g"].mean()
print(f"average_body_mass: {average_body_mass}")

# Find the heaviest species using the groupby operation to calculate the
# mean body_mass_g:
(
    bq_df["body_mass_g"]
    .groupby(by=bq_df["species"])
    .mean()
    .sort_values(ascending=False)
    .head(10)
)

Como usar a biblioteca bigframes.ml

Com os recursos de ML do DataFrames do BigQuery, é possível pré-processar dados e treinar modelos neles. Você também pode encadear essas ações para criar pipelines de dados.

Locais ML

bigframes.ml oferece suporte aos mesmos locais que o BigQuery ML. A previsão do modelo do BigQuery ML e outras funções de ML são aceitas em todas as regiões do BigQuery. O suporte para o treinamento do modelo varia de acordo com a região: Para mais informações, consulte Locais do BigQuery ML.

Pré-processar dados

Criar transformadores a fim de preparar dados para uso em estimadores (modelos) usando o módulo bigframes.ml.preprocessing e bigframes.ml.compose. O DataFrames do BigQuery oferece as seguintes transformações:

  • Use a classe KBinsDiscretizer no módulo bigframes.ml.preprocessing para agrupar dados contínuos em intervalos.

  • Use a classe LabelEncoder no módulo bigframes.ml.preprocessing para normalizar os rótulos de destino como valores inteiros.

  • Use a classe MaxAbsScaler no módulo bigframes.ml.preprocessing para dimensionar cada recurso para o intervalo [-1, 1] de acordo com o valor absoluto máximo.

  • Use a classe MinMaxScaler no módulo bigframes.ml.preprocessing para padronizar recursos escalonando cada recurso para o intervalo [0, 1].

  • Use a classe StandardScaler no módulo bigframes.ml.preprocessing para padronizar recursos removendo a média e o dimensionamento para a variância da unidade.

  • Use a classe OneHotEncoder no módulo bigframes.ml.preprocessing para transformar valores categóricos em formato numérico.

  • Use a classe ColumnTransformer no módulo bigframes.ml.compose para aplicar transformadores a colunas do DataFrames.

Treinar modelos

Criar estimadores para treinar modelos nos DataFrames do BigQuery.

Modelos de clustering

Crie estimadores para modelos de clustering usando o módulo bigframes.ml.cluster.

  • Use a classe KMeans (link em inglês) para criar modelos de clustering K-means. Use esses modelos para segmentação de dados. Por exemplo, identificar segmentos de clientes. K-means é uma técnica de aprendizado não supervisionada, portanto, o treinamento do modelo não requer rótulos ou dados de divisão para treinamento ou avaliação.

Use o módulo bigframes.ml.cluster para criar estimadores para modelos de clustering.

O exemplo de código a seguir mostra o uso da classe bigframes.ml.cluster KMeans para criar um modelo de clustering K-means para segmentação de dados:

from bigframes.ml.cluster import KMeans
import bigframes.pandas as bpd

# Load data from BigQuery
query_or_table = "bigquery-public-data.ml_datasets.penguins"
bq_df = bpd.read_gbq(query_or_table)

# Create the KMeans model
cluster_model = KMeans(n_clusters=10)
cluster_model.fit(bq_df["culmen_length_mm"], bq_df["sex"])

# Predict using the model
result = cluster_model.predict(bq_df)
# Score the model
score = cluster_model.score(bq_df)

Modelos de decomposição

Crie estimadores para modelos de decomposição usando o módulo bigframes.ml.decomposition (em inglês).

  • Use a classe PCA para criar modelos de análise de componentes principais (PCA, na sigla em inglês). Use esses modelos para calcular os componentes principais e usá-los para realizar uma alteração de base nos dados. Isso reduz a dimensionalidade, projetando cada ponto de dados apenas nos primeiros componentes principais. Assim, você consegue dados de dimensões menores, preservando o máximo possível da variação deles.

Modelos do conjunto

Criar estimadores para modelos de conjunto usando o módulo bigframes.ml.ensemble (em inglês).

  • Use a classe RandomForestClassifier para criar modelos de classificador de floresta aleatória. Use esses modelos para construir várias árvores de decisão de método de aprendizado para classificação.

  • Use a classe RandomForestRegressor para criar modelos de regressão de floresta aleatória. Use esses modelos para construir várias árvores de decisão de método de aprendizado para regressão.

  • Use a classe XGBClassifier para criar modelos de classificador de árvore otimizados com gradiente. Use esses modelos para construir aditivamente várias árvores de decisão de método de aprendizado para classificação.

  • Use a classe XGBRegressor para criar modelos de regressão de árvore otimizada com gradiente. Use esses modelos para construir aditivamente várias árvores de decisão de método de aprendizado para regressão.

Modelos de previsão

Crie estimadores para modelos de previsão usando o módulo bigframes.ml.predictioning.

Modelos importados

Crie estimadores para modelos importados usando o módulo bigframes.ml.imported.

Modelos lineares

Crie estimadores para modelos lineares usando o módulo bigframes.ml.linear_model.

  • Use a classe LinearRegression para criar modelos de regressão linear. Use esses modelos para previsão. Por exemplo, a previsão das vendas de um item em um determinado dia.

  • Use a classe LogisticRegression para criar modelos de regressão logística. Use esses modelos para a classificação de dois ou mais valores possíveis, por exemplo, se uma entrada é low-value, medium-value ou high-value.

O exemplo de código abaixo mostra o uso de bigframes.ml para realizar as seguintes ações:

from bigframes.ml.linear_model import LinearRegression
import bigframes.pandas as bpd

# Load data from BigQuery
query_or_table = "bigquery-public-data.ml_datasets.penguins"
bq_df = bpd.read_gbq(query_or_table)

# Filter down to the data to the Adelie Penguin species
adelie_data = bq_df[bq_df.species == "Adelie Penguin (Pygoscelis adeliae)"]

# Drop the species column
adelie_data = adelie_data.drop(columns=["species"])

# Drop rows with nulls to get training data
training_data = adelie_data.dropna()

# Specify your feature (or input) columns and the label (or output) column:
feature_columns = training_data[
    ["island", "culmen_length_mm", "culmen_depth_mm", "flipper_length_mm", "sex"]
]
label_columns = training_data[["body_mass_g"]]

test_data = adelie_data[adelie_data.body_mass_g.isnull()]

# Create the linear model
model = LinearRegression()
model.fit(feature_columns, label_columns)

# Score the model
score = model.score(feature_columns, label_columns)

# Predict using the model
result = model.predict(test_data)

Modelos de linguagem grande

Criar estimadores para LLMs usando o módulo bigframes.ml.llm.

  • Use a classe GenminiTextGenerator para criar modelos geradores de texto do Gemini. Use esses modelos para tarefas de geração de texto.

  • Use a classe PaLM2TextGenerator para criar modelos geradores de texto do PaLM2. Use esses modelos para tarefas de geração de texto.

  • Use a classe PaLM2TextEmbeddingGenerator para criar modelos geradores de embedding de texto do PaLM2. Use esses modelos para tarefas de geração de embedding de texto.

É possível usar o módulo bigframes.ml.llm para criar estimadores para modelos de linguagem grandes (LLMs) remotos.
O exemplo de código a seguir mostra como usar a classe bigframes.ml.llm GeminiTextGenerator para criar um modelo do Gemini para geração de código:

from bigframes.ml.llm import GeminiTextGenerator
import bigframes.pandas as bpd

# Create the Gemini LLM model
session = bpd.get_global_session()
connection = f"{PROJECT_ID}.{REGION}.{CONN_NAME}"
model = GeminiTextGenerator(session=session, connection_name=connection)

df_api = bpd.read_csv("gs://cloud-samples-data/vertex-ai/bigframe/df.csv")

# Prepare the prompts and send them to the LLM model for prediction
df_prompt_prefix = "Generate Pandas sample code for DataFrame."
df_prompt = df_prompt_prefix + df_api["API"]

# Predict using the model
df_pred = model.predict(df_prompt.to_frame(), max_output_tokens=1024)

Modelos remotos

Para usar modelos remotos de ML do DataFrames do BigQuery (bigframes.ml.remote ou bigframes.ml.llm), ative as seguintes APIs:

Você também precisa receber os seguintes papéis do IAM no projeto:

  • Administrador de conexão do BigQuery (roles/bigquery.connectionAdmin)
  • Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin) se estiver usando a conexão padrão do BigQuery, ou o navegador (papéis/navegador) se estiver usando uma conexão pré-configurada. Para evitar esse requisito, defina a opção bigframes.pandas.options.bigquery.skip_bq_connection_check como True. Nesse caso, a conexão (padrão ou pré-configurada) seria usada no estado em que se encontra, sem qualquer existência ou verificação de permissão. Se você estiver usando a conexão pré-configurada e pulando a verificação de conexão, confirme se a conexão foi criada no local correto e se a conta de serviço tem o papel de usuário da Vertex AI (roles/aiplatform.user) no projeto.

A criação de um modelo remoto no DataFrames do BigQuery cria uma conexão com o BigQuery. Por padrão, uma conexão com o nome bigframes-default-connection é usada. Se preferir, use uma conexão pré-configurada do BigQuery. Nesse caso, a criação da conexão é ignorada. A conta de serviço da conexão padrão recebe o papel do IAM de Usuário da Vertex AI (roles/aiplatform.user).

Criar pipelines

Criar pipelines de ML usando o módulo bigframes.ml.pipeline. Os pipelines permitem montar várias etapas de ML para validação cruzada ao definir parâmetros diferentes. Isso simplifica o código e permite implantar etapas de pré-processamento de dados e um estimador juntos.

Use a classe Pipeline para criar um pipeline de transformações com um estimador final.

A seguir