Use DataFrames do BigQuery

O BigQuery DataFrames oferece um DataFrame Pythonic e uma API de aprendizagem automática (AA) com tecnologia do motor do BigQuery. O BigQuery DataFrames é um pacote de código aberto. Pode executar o comando pip install --upgrade bigframes para instalar a versão mais recente.

O BigQuery DataFrames oferece três bibliotecas:

  • bigframes.pandas fornece uma API pandas que pode usar para analisar e manipular dados no BigQuery. Muitas cargas de trabalho podem ser migradas do pandas para o bigframes apenas alterando algumas importações. A API bigframes.pandas é escalável para suportar o processamento de terabytes de dados do BigQuery e usa o motor de consultas do BigQuery para fazer cálculos.
  • bigframes.bigquery oferece muitas funções SQL do BigQuery que podem não ter um equivalente no pandas.
  • A bigframes.ml oferece uma API semelhante à API scikit-learn para ML. As capacidades de ML no BigQuery DataFrames permitem-lhe pré-processar dados e, em seguida, preparar modelos com esses dados. Também pode encadear estas ações para criar pipelines de dados.

Funções necessárias

Para receber as autorizações de que precisa para concluir as tarefas neste documento, peça ao seu administrador que lhe conceda as seguintes funções da IAM no seu projeto:

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Além disso, quando usar funções remotas do BigQuery DataFrames ou modelos remotos do BigQuery DataFrames ML, precisa da função de administrador de IAM do projeto (roles/resourcemanager.projectIamAdmin) se estiver a usar uma associação predefinida do BigQuery ou da função de navegador (roles/browser) se estiver a usar uma associação pré-configurada. Pode evitar este requisito definindo a opção bigframes.pandas.options.bigquery.skip_bq_connection_check como True. Neste caso, a ligação (predefinida ou pré-configurada) é usada tal como está, sem qualquer verificação de existência ou autorização. Se estiver a usar a ligação pré-configurada e a ignorar a verificação da ligação, verifique o seguinte:

  • A associação é criada na localização correta.
  • Se estiver a usar funções remotas de DataFrames do BigQuery, a conta de serviço tem a função Invoker do Cloud Run (roles/run.invoker) no projeto.
  • Se estiver a usar modelos remotos do BigQuery DataFrames ML, a conta de serviço tem a função de utilizador da Vertex AI (roles/aiplatform.user) no projeto.

Quando está a fazer a autenticação do utilizador final num ambiente interativo, como um bloco de notas, o REPL do Python ou a linha de comandos, o BigQuery DataFrames pede a autenticação, se necessário. Caso contrário, veja como configurar as Credenciais padrão da aplicação para vários ambientes.

Configure as opções de instalação

Depois de instalar o BigQuery DataFrames, pode especificar as seguintes opções.

Localização e projeto

Tem de especificar a localização e o projeto no qual quer usar os DataFrames do BigQuery.

Pode definir a localização e o projeto no seu bloco de notas da seguinte forma:

import bigframes.pandas as bpd

PROJECT_ID = "bigframes-dev"  # @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

Localização do tratamento de dados

O BigQuery DataFrames foi concebido para a escala, que consegue mantendo os dados e o processamento no serviço BigQuery. No entanto, pode transferir dados para a memória do seu computador cliente chamando .to_pandas() num objeto DataFrame ou Series. Se optar por fazê-lo, aplica-se a limitação de memória da sua máquina cliente.

Migre para a versão 2.0 dos DataFrames do BigQuery

A versão 2.0 dos DataFrames do BigQuery faz melhorias de segurança e desempenho na API DataFrames do BigQuery, adiciona novas funcionalidades e introduz alterações significativas. Este documento descreve as alterações e fornece orientações de migração. Pode aplicar estas recomendações antes de instalar a versão 2.0 usando a versão 1.x mais recente do BigQuery DataFrames.

A versão 2.0 dos DataFrames do BigQuery tem as seguintes vantagens:

  • As consultas são mais rápidas e são criadas menos tabelas quando executa consultas que devolvem resultados ao cliente, porque allow_large_results tem como predefinição False. Isto pode reduzir os custos de armazenamento, especialmente se usar a faturação por bytes físicos.
  • Segurança melhorada por predefinição nas funções remotas implementadas pelos DataFrames do BigQuery.

Instale a versão 2.0 do BigQuery DataFrames

Para evitar alterações interruptivas, fixe uma versão específica dos DataFrames do BigQuery no ficheiro requirements.txt (por exemplo, bigframes==1.42.0) ou no ficheiro pyproject.toml (por exemplo, dependencies = ["bigframes = 1.42.0"]). Quando estiver tudo pronto para experimentar a versão mais recente, pode executar pip install --upgrade bigframes para instalar a versão mais recente dos DataFrames do BigQuery.

Use a opção allow_large_results

O BigQuery tem um limite máximo de tamanho da resposta para tarefas de consulta. A partir da versão 2.0 do BigQuery DataFrames, o BigQuery DataFrames aplica este limite por predefinição nos métodos que devolvem resultados ao cliente, como peek(), to_pandas() e to_pandas_batches(). Se a sua tarefa devolver resultados grandes, pode definir allow_large_results como True no objeto BigQueryOptions para evitar alterações significativas. Esta opção está definida como False por predefinição na versão 2.0 dos DataFrames do BigQuery.

import bigframes.pandas as bpd

bpd.options.bigquery.allow_large_results = True

Pode substituir a opção allow_large_results através do parâmetro allow_large_results em to_pandas() e outros métodos. Por exemplo:

bf_df = bpd.read_gbq(query)
# ... other operations on bf_df ...
pandas_df = bf_df.to_pandas(allow_large_results=True)

Use o decorador @remote_function

A versão 2.0 dos DataFrames do BigQuery faz algumas alterações ao comportamento predefinido do decorador @remote_function.

Os argumentos de palavras-chave são aplicados para parâmetros ambíguos

Para evitar a transmissão de valores a um parâmetro não pretendido, a versão 2.0 e posteriores dos DataFrames do BigQuery impõe a utilização de argumentos de palavras-chave para os seguintes parâmetros:

  • bigquery_connection
  • reuse
  • name
  • packages
  • cloud_function_service_account
  • cloud_function_kms_key_name
  • cloud_function_docker_repository
  • max_batching_rows
  • cloud_function_timeout
  • cloud_function_max_instances
  • cloud_function_vpc_connector
  • cloud_function_memory_mib
  • cloud_function_ingress_settings

Quando usar estes parâmetros, indique o nome do parâmetro. Por exemplo:

@remote_function(
  name="my_remote_function",
  ...
)
def my_remote_function(parameter: int) -> str:
  return str(parameter)

Defina uma conta de serviço

A partir da versão 2.0, os DataFrames do BigQuery já não usam a conta de serviço do Compute Engine por predefinição para as funções do Cloud Run que implementam. Para limitar as autorizações da função que implementa:

  1. Crie uma conta de serviço com o mínimo de autorizações.
  2. Forneça o email da conta de serviço ao parâmetro cloud_function_service_account do decorador @remote_function.

Por exemplo:

@remote_function(
  cloud_function_service_account="my-service-account@my-project.iam.gserviceaccount.com",
  ...
)
def my_remote_function(parameter: int) -> str:
  return str(parameter)

Se quiser usar a conta de serviço do Compute Engine, pode definir o parâmetro cloud_function_service_account do decorador @remote_function como "default". Por exemplo:

# This usage is discouraged. Use only if you have a specific reason to use the
# default Compute Engine service account.
@remote_function(cloud_function_service_account="default", ...)
def my_remote_function(parameter: int) -> str:
  return str(parameter)

Defina as definições de entrada

A partir da versão 2.0, o BigQuery DataFrames define as definições de entrada das funções do Cloud Run que implementa no "internal-only". Anteriormente, as definições de entrada estavam definidas como "all" por predefinição. Pode alterar as definições de entrada definindo o parâmetro cloud_function_ingress_settings do decorador @remote_function. Por exemplo:

@remote_function(cloud_function_ingress_settings="internal-and-gclb", ...)
def my_remote_function(parameter: int) -> str:
  return str(parameter)

Use pontos finais personalizados

Nas versões do BigQuery DataFrames anteriores à 2.0, se uma região não suportasse endpoints de serviços regionais e bigframes.pandas.options.bigquery.use_regional_endpoints = True, o BigQuery DataFrames recorria a endpoints de localização. A versão 2.0 dos DataFrames do BigQuery remove este comportamento alternativo. Para se ligar a pontos finais de localização na versão 2.0, defina a opção bigframes.pandas.options.bigquery.client_endpoints_override. Por exemplo:

import bigframes.pandas as bpd

bpd.options.bigquery.client_endpoints_override = {
  "bqclient": "https://LOCATION-bigquery.googleapis.com",
  "bqconnectionclient": "LOCATION-bigqueryconnection.googleapis.com",
  "bqstoragereadclient": "LOCATION-bigquerystorage.googleapis.com",
}

Substitua LOCATION pelo nome da localização do BigQuery à qual quer estabelecer ligação.

Use o módulo bigframes.ml.llm

Na versão 2.0 dos DataFrames do BigQuery, o valor predefinido de model_name para GeminiTextGenerator foi atualizado para "gemini-2.0-flash-001". Recomendamos que forneça um model_name diretamente para evitar falhas se o modelo predefinido mudar no futuro.

import bigframes.ml.llm

model = bigframes.ml.llm.GeminiTextGenerator(model_name="gemini-2.0-flash-001")

Manipulação de dados

As secções seguintes descrevem as capacidades de manipulação de dados para os DataFrames do BigQuery. Pode encontrar as funções descritas na biblioteca bigframes.bigquery.

API pandas

Uma funcionalidade notável dos DataFrames do BigQuery é que a bigframes.pandas API foi concebida para ser semelhante às APIs na biblioteca pandas. Este design permite-lhe usar padrões de sintaxe familiares para tarefas de manipulação de dados. As operações definidas através da API BigQuery DataFrames são executadas no lado do servidor, operando diretamente nos dados armazenados no BigQuery e eliminando a necessidade de transferir conjuntos de dados para fora do BigQuery.

Para verificar que APIs pandas são suportadas pelos DataFrames do BigQuery, consulte o artigo APIs pandas suportadas.

Inspecione e manipule dados

Pode usar a API bigframes.pandas para realizar operações de inspeção e cálculo de dados. O seguinte exemplo de código usa a biblioteca bigframes.pandas para inspecionar a coluna body_mass_g, calcular a média de body_mass e calcular a média de 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)
)

Biblioteca do BigQuery

A biblioteca do BigQuery fornece funções SQL do BigQuery que podem não ter um equivalente no pandas. As secções seguintes apresentam alguns exemplos.

Processe valores de matriz

Pode usar a função bigframes.bigquery.array_agg() na biblioteca bigframes.bigquery para agregar valores após uma operação groupby:

import bigframes.bigquery as bbq
import bigframes.pandas as bpd

s = bpd.Series([0, 1, 2, 3, 4, 5])

# Group values by whether they are divisble by 2 and aggregate them into arrays
bbq.array_agg(s.groupby(s % 2 == 0))
# False    [1 3 5]
# True     [0 2 4]
# dtype: list<item: int64>[pyarrow]

Também pode usar as funções de matriz array_length() e array_to_string().

Crie um objeto Series struct

Pode usar a função bigframes.bigquery.struct() na biblioteca bigframes.bigquery para criar um novo objeto Series com subcampos para cada coluna num DataFrame:

import bigframes.bigquery as bbq
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 a new STRUCT Series with subfields for each column in a DataFrames.
lengths = bbq.struct(
    bq_df[["culmen_length_mm", "culmen_depth_mm", "flipper_length_mm"]]
)

lengths.peek()
# 146	{'culmen_length_mm': 51.1, 'culmen_depth_mm': ...
# 278	{'culmen_length_mm': 48.2, 'culmen_depth_mm': ...
# 337	{'culmen_length_mm': 36.4, 'culmen_depth_mm': ...
# 154	{'culmen_length_mm': 46.5, 'culmen_depth_mm': ...
# 185	{'culmen_length_mm': 50.1, 'culmen_depth_mm': ...
# dtype: struct[pyarrow]

Converta indicações de tempo em épocas Unix

Pode usar a função bigframes.bigquery.unix_micros() na biblioteca bigframes.bigquery para converter indicações de tempo em microssegundos Unix:

import pandas as pd

import bigframes.bigquery as bbq
import bigframes.pandas as bpd

# Create a series that consists of three timestamps: [1970-01-01, 1970-01-02, 1970-01-03]
s = bpd.Series(pd.date_range("1970-01-01", periods=3, freq="d", tz="UTC"))

bbq.unix_micros(s)
# 0               0
# 1     86400000000
# 2    172800000000
# dtype: Int64

Também pode usar as funções de tempo unix_seconds() e unix_millis().

Use a função escalar SQL

Pode usar a função bigframes.bigquery.sql_scalar() na biblioteca bigframes.bigquery para aceder a uma sintaxe SQL arbitrária que represente uma expressão de coluna única:

import bigframes.bigquery as bbq
import bigframes.pandas as bpd

# Load data from BigQuery
query_or_table = "bigquery-public-data.ml_datasets.penguins"

# The sql_scalar function can be used to inject SQL syntax that is not supported
# or difficult to express with the bigframes.pandas APIs.
bq_df = bpd.read_gbq(query_or_table)
shortest = bbq.sql_scalar(
    "LEAST({0}, {1}, {2})",
    columns=[
        bq_df["culmen_depth_mm"],
        bq_df["culmen_length_mm"],
        bq_df["flipper_length_mm"],
    ],
)

shortest.peek()
#         0
# 149	18.9
# 33	16.3
# 296	17.2
# 287	17.0
# 307	15.0
# dtype: Float64

Funções Python personalizadas

Os DataFrames do BigQuery permitem-lhe transformar as suas funções Python personalizadas em artefactos do BigQuery que pode executar em objetos DataFrames do BigQuery em grande escala. Este suporte de extensibilidade permite-lhe realizar operações além do que é possível com os DataFrames do BigQuery e as APIs SQL, para que possa tirar partido das bibliotecas de código aberto. As duas variantes deste mecanismo de extensibilidade são descritas nas secções seguintes.

Funções definidas pelo utilizador (FDUs)

Com as FDU (pré-visualização), pode transformar a sua função Python personalizada numa FDU Python. Para ver um exemplo de utilização, consulte o artigo Crie uma UDF persistente do Python.

A criação de uma FDU no BigQuery DataFrames cria uma rotina do BigQuery como a FDU do Python no conjunto de dados especificado. Para ver um conjunto completo de parâmetros suportados, consulte udf.

Limpar

Além de limpar os artefactos da nuvem diretamente na Google Cloud consola ou com outras ferramentas, pode limpar as UDFs de DataFrames do BigQuery que foram criadas com um argumento de nome explícito através do comando bigframes.pandas.get_global_session().bqclient.delete_routine(routine_id).

Requisitos

Para usar uma UDF do BigQuery DataFrames, ative a API BigQuery no seu projeto. Se estiver a fornecer o parâmetro bigquery_connection no seu projeto, também tem de ativar a API BigQuery Connection.

Limitações

  • O código na FDU tem de ser autónomo, ou seja, não pode conter referências a uma importação ou a uma variável definida fora do corpo da função.
  • O código na FDU tem de ser compatível com o Python 3.11, uma vez que é o ambiente no qual o código é executado na nuvem.
  • A nova execução do código de definição da FDU após alterações triviais no código da função, por exemplo, mudar o nome de uma variável ou inserir uma nova linha, faz com que a FDU seja recriada, mesmo que estas alterações não tenham consequências para o comportamento da função.
  • O código do utilizador é visível para os utilizadores com acesso de leitura nas rotinas do BigQuery, pelo que deve incluir conteúdo confidencial apenas com precaução.
  • Um projeto pode ter até 1000 funções do Cloud Run em simultâneo numa localização do BigQuery.

A FDU de DataFrames do BigQuery implementa uma função Python do BigQuery definida pelo utilizador e aplicam-se as limitações relacionadas.

Funções remotas

Os DataFrames do BigQuery permitem-lhe transformar as suas funções escalares personalizadas em funções remotas do BigQuery. Para ver um exemplo de utilização, consulte o artigo Crie uma função remota. Para ver um conjunto completo de parâmetros suportados, consulte a secção remote_function.

A criação de uma função remota no BigQuery DataFrames cria o seguinte:

  • Uma função do Cloud Run.
  • Uma ligação ao BigQuery. Por predefinição, é usada uma associação com o nome bigframes-default-connection. Se preferir, pode usar uma ligação do BigQuery pré-configurada. Neste caso, a criação da ligação é ignorada. A conta de serviço da ligação predefinida tem a função do Cloud Run (roles/run.invoker).
  • Uma função remota do BigQuery que usa a função do Cloud Run criada com a ligação do BigQuery.

As ligações do BigQuery são criadas na mesma localização que a sessão do BigQuery DataFrames, com o nome que fornece na definição da função personalizada. Para ver e gerir associações, faça o seguinte:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. Selecione o projeto no qual criou a função remota.

  3. No painel Explorador, expanda o projeto e, de seguida, expanda Ligações externas.

As funções remotas do BigQuery são criadas no conjunto de dados que especificar ou num conjunto de dados anónimo, que é um tipo de conjunto de dados oculto. Se não definir um nome para uma função remota durante a respetiva criação, os DataFrames do BigQuery aplicam um nome predefinido que começa com o prefixo bigframes. Para ver e gerir funções remotas criadas num conjunto de dados especificado pelo utilizador, faça o seguinte:

  1. Na Google Cloud consola, aceda à página BigQuery.

    Aceda ao BigQuery

  2. Selecione o projeto no qual criou a função remota.

  3. No painel Explorador, expanda o projeto, expanda o conjunto de dados no qual criou a função remota e, de seguida, expanda Rotinas.

Para ver e gerir funções do Cloud Run, faça o seguinte:

  1. Aceda à página Cloud Run.

    Aceda ao Cloud Run

  2. Selecione o projeto no qual criou a função.

  3. Filtre pelo Tipo de implementação de funções na lista de serviços disponíveis.

  4. Para identificar funções criadas por DataFrames do BigQuery, procure nomes de funções com o prefixo bigframes.

Limpar

Além de limpar os artefactos da nuvem diretamente na Google Cloud consola ou com outras ferramentas, pode limpar as funções remotas do BigQuery que foram criadas sem um argumento de nome explícito e as respetivas funções do Cloud Run das seguintes formas:

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

Também pode limpar as funções remotas do BigQuery que foram criadas com um argumento de nome explícito e as respetivas funções do Cloud Run associadas através do comando bigframes.pandas.get_global_session().bqclient.delete_routine(routine_id).

Requisitos

Para usar funções remotas de DataFrames do BigQuery, tem de ativar as seguintes APIs:

Limitações

  • As funções remotas demoram cerca de 90 segundos a ficar utilizáveis quando as cria pela primeira vez. As dependências de pacotes adicionais podem aumentar a latência.
  • A nova execução do código de definição da função remota após alterações triviais no código da função e à volta deste, por exemplo, mudar o nome de uma variável, inserir uma nova linha ou inserir uma nova célula no bloco de notas, pode fazer com que a função remota seja recriada, mesmo que estas alterações não tenham consequências para o comportamento da função.
  • O código do utilizador é visível para os utilizadores com acesso de leitura nas funções do Cloud Run, pelo que deve incluir conteúdo sensível apenas com precaução.
  • Um projeto pode ter até 1000 funções do Cloud Run em simultâneo numa região. Para mais informações, consulte o artigo Quotas.

ML e IA

As secções seguintes descrevem as capacidades de ML e IA para os DataFrames do BigQuery. Estas capacidades usam a biblioteca bigframes.ml.

Localizações de ML

A biblioteca bigframes.ml suporta as mesmas localizações que o BigQuery ML. A previsão de modelos do BigQuery ML e outras funções de ML são suportadas em todas as regiões do BigQuery. O suporte para a preparação de modelos varia consoante a região. Para mais informações, consulte o artigo Localizações do BigQuery ML.

Pré-processe dados

Crie transformadores para preparar os dados para utilização em estimadores (modelos) através do módulo bigframes.ml.preprocessing e do módulo bigframes.ml.compose. O BigQuery DataFrames 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 as etiquetas de destino como valores inteiros.

  • Use a classe MaxAbsScaler no módulo bigframes.ml.preprocessing para dimensionar cada caraterística para o intervalo [-1, 1] pelo respetivo valor absoluto máximo.

  • Use a classe MinMaxScaler no módulo bigframes.ml.preprocessing para padronizar as funcionalidades dimensionando cada funcionalidade para o intervalo [0, 1].

  • Use a classe StandardScaler no módulo bigframes.ml.preprocessing para padronizar as caraterísticas removendo a média e dimensionando para a variância unitária.

  • 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 de DataFrames.

Prepare modelos

Pode criar estimadores para formar modelos em DataFrames do BigQuery.

Modelos de clustering

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

  • Use a classe KMeans para criar modelos de agrupamento K-means. Use estes modelos para a segmentação de dados. Por exemplo, identificar segmentos de clientes. O K-means é uma técnica de aprendizagem não supervisionada, pelo que a preparação do modelo não requer etiquetas nem dados divididos para preparação ou avaliação.

Pode usar o módulo bigframes.ml.cluster para criar estimadores para modelos de agrupamento.

O exemplo de código seguinte mostra a utilização da classe bigframes.ml.cluster KMeans para criar um modelo de clustering k-means para a 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

Pode criar estimadores para modelos de decomposição usando o módulo bigframes.ml.decomposition.

  • Use a classe PCA para criar modelos de análise de componentes principais (PCA). Use estes modelos para calcular os componentes principais e usá-los para realizar uma mudança de base nos dados. Isto oferece uma redução da dimensionalidade projetando cada ponto de dados apenas nos primeiros componentes principais para obter dados de menor dimensionalidade, ao mesmo tempo que preserva o máximo possível da variação dos dados.

Modelos de conjunto

Pode criar estimadores para modelos de conjunto usando o módulo bigframes.ml.ensemble.

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

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

  • Use a classe XGBClassifier para criar modelos de classificador de árvores com reforço de gradiente. Use estes modelos para construir de forma aditiva várias árvores de decisão do método de aprendizagem para classificação.

  • Use a classe XGBRegressor para criar modelos de regressão de árvores com reforço de gradiente. Use estes modelos para construir de forma aditiva várias árvores de decisão do método de aprendizagem para regressão.

Modelos de previsão

Pode criar estimadores para modelos de previsão usando o módulo bigframes.ml.forecasting.

  • Use a classe ARIMAPlus para criar modelos de previsão de séries cronológicas.

Modelos importados

Pode criar 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 estes modelos para fazer previsões. Por exemplo, prever as vendas de um artigo num determinado dia.

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

O exemplo de código seguinte mostra a utilização de bigframes.ml para fazer o seguinte:

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)

Grandes modelos de linguagem

Pode criar estimadores para MDIs/CEs usando o módulo bigframes.ml.llm.

Use a classe GeminiTextGenerator para criar modelos de gerador de texto do Gemini. Use estes modelos para tarefas de geração de texto.

Use o módulo bigframes.ml.llm para criar estimadores para grandes modelos de linguagem (GMLs) remotos.
O exemplo de código seguinte mostra a utilização da 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, model_name="gemini-2.0-flash-001"
)

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 de comandos

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

A criação de um modelo remoto no BigQuery DataFrames cria uma ligação do BigQuery. Por predefinição, é usada uma associação com o nome bigframes-default-connection. Se preferir, pode usar uma ligação do BigQuery pré-configurada. Nesse caso, a criação da ligação é ignorada. A conta de serviço para a ligação predefinida tem a função de utilizador do Vertex AI (roles/aiplatform.user) no projeto.

Crie pipelines

Pode criar pipelines de ML usando o módulo bigframes.ml.pipeline. Os pipelines permitem-lhe reunir vários passos de ML para serem validados de forma cruzada em conjunto enquanto define diferentes parâmetros. Isto simplifica o código e permite implementar passos de pré-processamento de dados e um estimador em conjunto.

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

Selecionar modelos

Use o módulo bigframes.ml.model_selection para dividir os conjuntos de dados de preparação e teste, e selecionar os melhores modelos:

  • Use a função train_test_split para dividir os dados em conjuntos de preparação e testes (avaliação), conforme mostrado no seguinte exemplo de código:

    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

  • Use a classe KFold e o método KFold.split para criar conjuntos de preparação e testes com várias dobras para preparar e avaliar modelos, como mostrado no exemplo de código seguinte. Esta funcionalidade é útil para pequenos conjuntos de dados.

    kf = KFold(n_splits=5)
for i, (X_train, X_test, y_train, y_test) in enumerate(kf.split(X, y)):
# Train and evaluate models with training and testing sets

  • Use a função cross_validate para criar automaticamente conjuntos de preparação e testes com várias dobras, preparar e avaliar o modelo e obter o resultado de cada dobra, conforme mostrado no seguinte exemplo de código:

    scores = cross_validate(model, X, y, cv=5)

O que se segue?