Usa BigQuery DataFrames

BigQuery DataFrames proporciona un DataFrame de Python y una API de aprendizaje automático (AA) con la tecnología del motor de BigQuery. BigQuery DataFrames es un paquete de código abierto. Puedes ejecutar pip install --upgrade bigframes para instalar la versión más reciente.

BigQuery DataFrames proporciona tres bibliotecas:

  • bigframes.pandas proporciona una API de pandas que puedes usar para analizar y manipular datos en BigQuery. Muchas cargas de trabajo se pueden migrar de pandas a bigframes con solo cambiar algunas importaciones. La API de bigframes.pandas es escalable para admitir el procesamiento de terabytes de datos de BigQuery y usa el motor de consulta de BigQuery para realizar cálculos.
  • bigframes.bigquery proporciona muchas funciones de SQL de BigQuery que tal vez no tengan un equivalente en pandas.
  • bigframes.ml proporciona una API similar a la API de scikit-learn para el AA. Las capacidades de AA en BigQuery DataFrames te permiten procesar previamente los datos y, luego, entrenar modelos en esos datos. También puedes encadenar estas acciones para crear canalizaciones de datos.

Roles requeridos

Para obtener los permisos que necesitas para completar las tareas de este documento, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Además, cuando usas funciones remotas de BigQuery DataFrames o modelos remotos de AA de BigQuery DataFrames, necesitas el rol de administrador de IAM del proyecto (roles/resourcemanager.projectIamAdmin) si usas una conexión predeterminada de BigQuery, o el rol de navegador (roles/browser) si usas una conexión preconfigurada. Este requisito se puede evitar si se configura la opción bigframes.pandas.options.bigquery.skip_bq_connection_check en True, en cuyo caso la conexión (predeterminada o preconfigurada) se usa tal como está sin ninguna existencia o permiso. Si usas la conexión preconfigurada y omites la verificación de conexión, verifica lo siguiente:

  • La conexión se crea en la ubicación correcta.
  • Si usas las funciones remotas de BigQuery DataFrames, la cuenta de servicio tiene el rol de invocador de Cloud Run (roles/run.invoker) en el proyecto.
  • Si usas modelos remotos de AA de BigQuery DataFrames, la cuenta de servicio tiene el rol de usuario de Vertex AI (roles/aiplatform.user) en el proyecto.

Cuando realizas la autenticación de usuario final en un entorno interactivo como un notebook, el REPL de Python o la línea de comandos, BigQuery DataFrames solicita la autenticación, si es necesario. De lo contrario, consulta cómo configurar las credenciales predeterminadas de la aplicación para varios entornos.

Configura las opciones de instalación

Después de instalar BigQuery DataFrames, puedes especificar las siguientes opciones.

Ubicación y proyecto

Debes especificar la ubicación y el proyecto en los que deseas usar BigQuery DataFrames.

Puedes definir la ubicación y el proyecto en tu notebook de la siguiente manera:

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

Ubicación del procesamiento de datos

BigQuery DataFrames está diseñado para el escalamiento, lo que logra a través de la conservación de los datos y el procesamiento en el servicio de BigQuery. Sin embargo, puedes incorporar datos a la memoria de tu máquina cliente si llamas a .to_pandas() en un objeto de DataFrame oSeries. Si eliges hacerlo, se aplica la limitación de memoria de tu máquina cliente.

Migra a la versión 2.0 de BigQuery DataFrames

La versión 2.0 de BigQuery DataFrames incluye mejoras de seguridad y rendimiento en la API de BigQuery DataFrames, agrega funciones nuevas y presenta cambios rotundos. En este documento, se describen los cambios y se proporcionan instrucciones para la migración. Puedes aplicar estas recomendaciones antes de instalar la versión 2.0 con la versión 1.x más reciente de BigQuery DataFrames.

La versión 2.0 de BigQuery DataFrames ofrece los siguientes beneficios:

  • Cuando ejecutas consultas que devuelven resultados al cliente, se crean consultas más rápidas y menos tablas, ya que allow_large_results se establece de forma predeterminada en False. Esto puede reducir los costos de almacenamiento, en especial si usas la facturación de bytes físicos.
  • Seguridad mejorada de forma predeterminada en las funciones remotas implementadas por BigQuery DataFrames.

Instala la versión 2.0 de BigQuery DataFrames

Para evitar cambios breaking, fija una versión específica de BigQuery DataFrames en tu archivo requirements.txt (por ejemplo, bigframes==1.42.0) o en tu archivo pyproject.toml (por ejemplo, dependencies = ["bigframes = 1.42.0"]). Cuando esté todo listo para probar la versión más reciente, puedes ejecutar pip install --upgrade bigframes para instalar la versión más reciente de BigQuery DataFrames.

Usa la opción allow_large_results

BigQuery tiene un límite de tamaño máximo de respuesta para los trabajos de consulta. A partir de la versión 2.0 de BigQuery DataFrames, BigQuery DataFrames aplica este límite de forma predeterminada en los métodos que devuelven resultados al cliente, como peek(), to_pandas() y to_pandas_batches(). Si tu trabajo devuelve resultados grandes, puedes configurar allow_large_results en True en tu objeto BigQueryOptions para evitar cambios que generen errores. Esta opción se establece en False de forma predeterminada en la versión 2.0 de BigQuery DataFrames.

import bigframes.pandas as bpd

bpd.options.bigquery.allow_large_results = True

Puedes anular la opción allow_large_results con el parámetro allow_large_results en to_pandas() y otros métodos. Por ejemplo:

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

Usa el decorador @remote_function

La versión 2.0 de BigQuery DataFrames realiza algunos cambios en el comportamiento predeterminado del decorador @remote_function.

Los argumentos de palabras clave se aplican de forma obligatoria para los parámetros ambiguos

Para evitar pasar valores a un parámetro no deseado, BigQuery DataFrames versión 2.0 y versiones posteriores exigen el uso de argumentos de palabras clave para los siguientes 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

Cuando uses estos parámetros, proporciona el nombre del parámetro. Por ejemplo:

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

Configura una cuenta de servicio

A partir de la versión 2.0, BigQuery DataFrames ya no usa la cuenta de servicio de Compute Engine de forma predeterminada para las funciones de Cloud Run que implementa. Para limitar los permisos de la función que implementas, haz lo siguiente:

  1. Crea una cuenta de servicio con permisos mínimos.
  2. Proporciona el correo electrónico de la cuenta de servicio al parámetro cloud_function_service_account del decorador @remote_function.

Por ejemplo:

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

Si deseas usar la cuenta de servicio de Compute Engine, puedes establecer el parámetro cloud_function_service_account del decorador @remote_function en "default". Por ejemplo:

# 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)

Cómo establecer la configuración de entrada

A partir de la versión 2.0, BigQuery DataFrames establece la configuración de entrada de las funciones de Cloud Run que implementa en "internal-only". Anteriormente, la configuración de entrada se establecía en "all" de forma predeterminada. Puedes cambiar la configuración de entrada estableciendo el parámetro cloud_function_ingress_settings del decorador @remote_function. Por ejemplo:

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

Cómo usar extremos personalizados

En las versiones de BigQuery DataFrames anteriores a la 2.0, si una región no admitía endpoints de servicio regionales ni bigframes.pandas.options.bigquery.use_regional_endpoints = True, BigQuery DataFrames recurría a los endpoints de ubicación. La versión 2.0 de BigQuery DataFrames quita este comportamiento de resguardo. Para conectarte a extremos de ubicación en la versión 2.0, configura la opción bigframes.pandas.options.bigquery.client_endpoints_override. Por ejemplo:

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",
}

Reemplaza LOCATION por el nombre de la ubicación de BigQuery a la que deseas conectarte.

Usa el módulo bigframes.ml.llm

En la versión 2.0 de BigQuery DataFrames, el valor predeterminado de model_name para GeminiTextGenerator se actualizó a "gemini-2.0-flash-001". Te recomendamos que proporciones un model_name directamente para evitar interrupciones si el modelo predeterminado cambia en el futuro.

import bigframes.ml.llm

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

Manipulación de datos

En las siguientes secciones, se describen las capacidades de manipulación de datos para los DataFrames de BigQuery. Puedes encontrar las funciones que se describen en la biblioteca bigframes.bigquery.

API de pandas

Una característica destacada de BigQuery DataFrames es que la API de bigframes.pandas está diseñada para ser similar a las APIs de la biblioteca de Pandas. Este diseño te permite emplear patrones de sintaxis conocidos para las tareas de manipulación de datos. Las operaciones definidas a través de la API de BigQuery DataFrames se ejecutan del lado del servidor y operan directamente en los datos almacenados en BigQuery, lo que elimina la necesidad de transferir conjuntos de datos fuera de BigQuery.

Para verificar qué APIs de pandas son compatibles con BigQuery DataFrames, consulta APIs de pandas compatibles.

Inspecciona y manipula datos

Puedes usar la API de bigframes.pandas para realizar operaciones de inspección y cálculo de datos. En el siguiente muestra de código, se usa la biblioteca bigframes.pandas para inspeccionar la columna body_mass_g, calcular la media body_mass y calcular la media 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 de BigQuery

La biblioteca de BigQuery proporciona funciones de SQL de BigQuery que podrían no tener un equivalente en pandas. En las siguientes secciones, se presentan algunos ejemplos.

Procesa valores de arreglos

Puedes usar la función bigframes.bigquery.array_agg() en la biblioteca bigframes.bigquery para agregar valores después de una operación 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]

También puedes usar las funciones de array array_length() y array_to_string().

Crea un objeto Series struct

Puedes usar la función bigframes.bigquery.struct() en la biblioteca bigframes.bigquery para crear un nuevo objeto Series struct con subcampos para cada columna en un 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]

Cómo convertir marcas de tiempo en épocas de Unix

Puedes usar la función bigframes.bigquery.unix_micros() en la biblioteca bigframes.bigquery para convertir marcas de tiempo en microsegundos de 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

También puedes usar las funciones de tiempo unix_seconds() y unix_millis().

Usa la función escalar de SQL

Puedes usar la función bigframes.bigquery.sql_scalar() en la biblioteca bigframes.bigquery para acceder a la sintaxis de SQL arbitraria que representa una sola expresión de columna:

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

Funciones personalizadas de Python

BigQuery DataFrames te permite convertir tus funciones personalizadas de Python en artefactos de BigQuery que puedes ejecutar a gran escala en objetos de BigQuery DataFrames. Esta compatibilidad con la extensibilidad te permite realizar operaciones más allá de lo que es posible con las APIs de BigQuery DataFrames y SQL, por lo que puedes aprovechar las bibliotecas de código abierto. Las dos variantes de este mecanismo de extensibilidad se describen en las siguientes secciones.

Funciones definidas por el usuario (UDF)

Con las UDF (versión preliminar), puedes convertir tu función personalizada de Python en una UDF de Python. Para ver un ejemplo de uso, consulta Crea una UDF persistente en Python.

Cuando se crea una UDF en BigQuery DataFrames, se crea una rutina de BigQuery como la UDF de Python en el conjunto de datos especificado. Para obtener un conjunto completo de parámetros admitidos, consulta udf.

Limpia

Además de limpiar los artefactos de la nube directamente en la consola de Google Cloud o con otras herramientas, puedes limpiar las UDF de BigQuery DataFrames que se crearon con un argumento de nombre explícito usando el comandobigframes.pandas.get_global_session().bqclient.delete_routine(routine_id).

Requisitos

Para usar una UDF de BigQuery DataFrames, habilita la API de BigQuery en tu proyecto. Si proporcionas el parámetro bigquery_connection en tu proyecto, también debes habilitar la API de BigQuery Connection.

Limitaciones

  • El código de la UDF debe ser independiente, es decir, no debe contener referencias a una importación o variable definida fuera del cuerpo de la función.
  • El código de la UDF debe ser compatible con Python 3.11, ya que ese es el entorno en el que se ejecuta el código en la nube.
  • Volver a ejecutar el código de definición de la UDF después de realizar cambios triviales en el código de la función (por ejemplo, cambiar el nombre de una variable o insertar una línea nueva) provoca que se vuelva a crear la UDF, incluso si estos cambios no son importantes para el comportamiento de la función.
  • El código del usuario es visible para los usuarios con acceso de lectura en las rutinas de BigQuery, por lo que debes incluir contenido sensible con precaución.
  • Un proyecto puede tener hasta 1,000 funciones de Cloud Run a la vez en una ubicación de BigQuery.

La UDF de BigQuery DataFrames implementa una función de Python de BigQuery definida por el usuario, y se aplican las limitaciones relacionadas.

Funciones remotas

BigQuery DataFrames te permite convertir tus funciones escalares personalizadas en funciones remotas de BigQuery. Para ver un ejemplo de uso, consulta Crea una función remota. Para obtener un conjunto completo de parámetros admitidos, consulta remote_function.

Cuando se crea una función remota en BigQuery DataFrames, se crea lo siguiente:

  • Una función de Cloud Run.
  • Una conexión de BigQuery. De forma predeterminada, se usa una conexión llamada bigframes-default-connection. Si lo prefieres, puedes usar una conexión de BigQuery preconfigurada, en cuyo caso se omite la creación de la conexión. A la cuenta de servicio para la conexión predeterminada se le otorga el rol de Cloud Run (roles/run.invoker).
  • Una función remota de BigQuery que usa la función de Cloud Run que se creó con la conexión de BigQuery.

Las conexiones de BigQuery se crean en la misma ubicación que la sesión de BigQuery DataFrames, con el nombre que proporcionas en la definición de la función personalizada. Para ver y administrar conexiones, haz lo siguiente:

  1. En la consola de Google Cloud , ve a la página BigQuery.

    Ir a BigQuery

  2. Selecciona el proyecto en el que creaste la función remota.

  3. En el panel Explorador, expande el proyecto y, luego, Conexiones externas.

Las funciones remotas de BigQuery se crean en el conjunto de datos que especificas o en un conjunto de datos anónimo, que es un tipo de conjunto de datos oculto. Si no estableces un nombre para una función remota durante su creación, BigQuery DataFrames aplica un nombre predeterminado que comienza con el prefijo bigframes. Para ver y administrar funciones remotas creadas en un conjunto de datos especificado por el usuario, haz lo siguiente:

  1. En la consola de Google Cloud , ve a la página BigQuery.

    Ir a BigQuery

  2. Selecciona el proyecto en el que creaste la función remota.

  3. En el panel Explorador, expande el proyecto, expande el conjunto de datos en el que creaste la función remota y, luego, expande Rutinas.

Para ver y administrar las funciones de Cloud Run, haz lo siguiente:

  1. Ir a la página Cloud Run.

    Ir a Cloud Run

  2. Selecciona el proyecto en el que creaste la función.

  3. Filtra por el Tipo de implementación de la función en la lista de servicios disponibles.

  4. Para identificar las funciones creadas por BigQuery DataFrames, busca nombres de funciones con el prefijo bigframes.

Limpia

Además de limpiar los artefactos de Cloud directamente en la consola de Google Cloud o con otras herramientas, puedes limpiar las funciones remotas de BigQuery que se crearon sin un argumento de nombre explícito y sus funciones asociadas de Cloud Run de las siguientes maneras:

  • Para una sesión de BigQuery DataFrames, usa el comando session.close().
  • Para la sesión predeterminada de BigQuery DataFrames, usa el comando bigframes.pandas.close_session().
  • Para una sesión anterior con session_id, usa el comando bigframes.pandas.clean_up_by_session_id(session_id).

También puedes limpiar las funciones remotas de BigQuery que se crearon con un argumento de nombre explícito y sus funciones asociadas de Cloud Run con el comando bigframes.pandas.get_global_session().bqclient.delete_routine(routine_id).

Requisitos

Para usar las funciones remotas de BigQuery DataFrames, debes habilitar las siguientes APIs:

Limitaciones

  • Las funciones remotas tardan unos 90 segundos en estar disponibles cuando las creas por primera vez. Las dependencias de paquetes adicionales pueden aumentar la latencia.
  • Volver a ejecutar el código de definición de la función remota después de realizar cambios triviales en el código de la función y a su alrededor (por ejemplo, cambiar el nombre de una variable, insertar una línea nueva o insertar una celda nueva en el notebook) puede provocar que se vuelva a crear la función remota, incluso si estos cambios no son importantes para el comportamiento de la función.
  • El código del usuario es visible para los usuarios con acceso de lectura en las funciones de Cloud Run, por lo que debes incluir contenido sensible con precaución.
  • Un proyecto puede tener hasta 1,000 funciones de Cloud Run a la vez en una región. Para obtener más información, consulta Cuotas.

IA y AA

En las siguientes secciones, se describen las capacidades de IA y AA para los DataFrames de BigQuery. Estas capacidades usan la biblioteca bigframes.ml.

Ubicaciones de AA

La biblioteca de bigframes.ml admite las mismas ubicaciones que BigQuery ML. La predicción de modelos de BigQuery ML y otras funciones del AA son compatibles con todas las regiones de BigQuery. La compatibilidad de la entrenamiento de modelos varía según la región. Para obtener más información, consulta Ubicaciones de BigQuery ML.

Preprocesar datos

Crear transformadores para preparar datos para usar en estimadores (modelos) con el módulo bigframes.ml.preprocessing y el módulo bigframes.ml.compose BigQuery DataFrames ofrece las siguientes transformaciones:

  • Usa la clase KBinsDiscretizer en el módulo bigframes.ml.preprocessing para agrupar datos continuos en intervalos.

  • Usa la clase LabelEncoder en el módulo bigframes.ml.preprocessing para normalizar las etiquetas de destino como valores de números enteros.

  • Usa la clase MaxAbsScaler en el módulo bigframes.ml.preprocessing para escalar cada atributo al rango [-1, 1] según su valor absoluto máximo.

  • Usa la clase MinMaxScaler en el módulo bigframes.ml.preprocessing para estandarizar atributos escalando cada atributo al rango [0, 1].

  • Usa la clase StandardScaler en el módulo bigframes.ml.preprocessing para estandarizar atributos quitando la media y escalando a la varianza de unidades.

  • Usa la clase OneHotEncoder en el módulo bigframes.ml.preprocessing para transformar los valores categóricos en formato numérico.

  • Usa la clase ColumnTransformer en el módulo bigframes.ml.compose para aplicar transformadores a las columnas de DataFrames.

Entrenar modelos

Puedes crear estimadores para entrenar modelos en BigQuery DataFrames.

Agrupa modelos en clústeres

Puedes crear estimadores para los modelos de agrupamiento en clústeres con el módulo bigframes.ml.cluster.

  • Usa la clase KMeans para crear modelos de agrupamiento en clústeres de K-means. Usa estos modelos para la segmentación de datos. Por ejemplo, identificar segmentos de clientes. K-means es una técnica de aprendizaje no supervisada, por lo que el entrenamiento de modelos no requiere etiquetas ni datos divididos para el entrenamiento o la evaluación.

Puedes usar el módulo bigframes.ml.cluster para crear estimadores para los modelos de agrupamiento en clústeres.

En la siguiente muestra de código, se usa la clase bigframes.ml.cluster KMeans para crear un modelo de agrupamiento en clústeres de k-means para la segmentación de datos:

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 descomposición

Puedes crear estimadores para los modelos de descomposición con el módulo bigframes.ml.decomposition.

  • Usa la clase PCA para crear modelos de análisis de componentes principales (PCA). Usa estos modelos para calcular los componentes principales y usarlos a fin de realizar un cambio de base en los datos. Esto proporciona una reducción de la dimensionalidad mediante la proyección de cada dato a los primeros componentes principales para obtener datos de menor dimensión y, al mismo tiempo, conservar la mayor variación posible de los datos.

Ensamblar modelos

Puedes crear estimadores para modelos de ensamble con el módulo bigframes.ml.ensemble.

  • Usa la clase RandomForestClassifier para crear modelos clasificadores de bosque aleatorios. Usa estos modelos para construir varios árboles de decisión de métodos de aprendizaje para la clasificación.

  • Usa la clase RandomForestRegressor para crear modelos de regresión de bosque aleatorios. Usa estos modelos para construir varios árboles de decisión de métodos de aprendizaje para la regresión.

  • Usa la clase XGBClassifier para crear modelos clasificadores de árbol mejorado con gradiente. Usa estos modelos para construir de forma aditiva varios árboles de decisión de métodos de aprendizaje para la clasificación.

  • Usa la clase XGBRegressor para crear modelos de regresión de árbol mejorado con gradiente. Usa estos modelos para construir de forma aditiva varios árboles de decisión de métodos de aprendizaje para la regresión.

Modelos de previsión

Puedes crear estimadores para los modelos de previsión con el módulo bigframes.ml.forecasting.

  • Usa la clase ARIMAPlus para crear modelos de previsión de series temporales.

Modelos importados

Puedes crear estimadores para modelos importados con el módulo bigframes.ml.imported.

Modelos lineales

Crea estimadores para modelos lineales con el módulo bigframes.ml.linear_model.

  • Usa la clase LinearRegression para crear modelos de regresión lineal. Usa estos modelos para la previsión. Por ejemplo, la previsión de las ventas de un artículo en un día determinado.

  • Usa la clase LogisticRegression para crear modelos de regresión logística. Usa estos modelos para la clasificación de dos o más valores posibles, por ejemplo, si una entrada es low-value, medium-value o high-value.

En la siguiente muestra de código, se usa bigframes.ml para hacer lo siguiente:

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 lenguaje grandes

Puedes crear estimadores para LLMs con el módulo bigframes.ml.llm.

Usa la clase GeminiTextGenerator para crear modelos de generador de texto de Gemini. Usa estos modelos para tareas de generación de texto.

Usa el módulo bigframes.ml.llm para crear estimadores para modelos remotos de lenguaje grande (LLM).
En la siguiente muestra de código, se usa la clase bigframes.ml.llm GeminiTextGenerator para crear un modelo de Gemini para la generación 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 remotos

Para usar los modelos remotos de AA de BigQuery DataFrames (bigframes.ml.remote o bigframes.ml.llm), debes habilitar las siguientes APIs:

Cuando se crea un modelo remoto en BigQuery DataFrames, se crea una conexión de BigQuery. De forma predeterminada, se usa una conexión con el nombre bigframes-default-connection. Si lo prefieres, puedes usar una conexión de BigQuery preconfigurada, en cuyo caso se omite la creación de la conexión. A la cuenta de servicio de la conexión predeterminada se le otorga el rol de usuario de Vertex AI (roles/aiplatform.user) en el proyecto.

Crear canalizaciones

Puedes crear canalizaciones de AA con el módulo bigframes.ml.pipeline. Las canalizaciones te permiten ensamblar varios pasos del AA para realizar una validación cruzada mientras se configuran diferentes parámetros. Esto simplifica tu código y te permite implementar pasos de procesamiento previo de datos y un estimador juntos.

Usa la clase Pipeline para crear una canalización de transformaciones con un estimador final.

Selecciona modelos

Usa el módulo bigframes.ml.model_selection para dividir tus conjuntos de datos de entrenamiento y prueba, y seleccionar los mejores modelos:

  • Usa la función train_test_split para dividir los datos en conjuntos de entrenamiento y prueba (evaluación), como se muestra en el siguiente muestra de código:

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

  • Usa la clase KFold y el método KFold.split para crear conjuntos de entrenamiento y prueba de varios pliegues para entrenar y evaluar modelos, como se muestra en la siguiente muestra de código. Esta función es valiosa para los conjuntos de datos pequeños.

    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

  • Usa la función cross_validate para crear automáticamente conjuntos de entrenamiento y prueba de varios pliegues, entrenar y evaluar el modelo, y obtener el resultado de cada pliegue, como se muestra en el siguiente muestra de código:

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

¿Qué sigue?