Usa el AA y la IA con BigQuery DataFrames

La biblioteca bigframes.ml en BigQuery DataFrames te permite integrar capacidades de IA y aprendizaje automático (AA) en tus flujos de trabajo de análisis de datos. El procesamiento previo de datos, el entrenamiento de modelos y la creación de canalizaciones de AA directamente en BigQuery te permiten escalar tus análisis sin extraer conjuntos de datos de tu almacén de datos.

Roles obligatorios

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.

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:

  • Para agrupar datos continuos en intervalos, usa la clase KBinsDiscretizer en el módulo bigframes.ml.preprocessing.

  • Para normalizar las etiquetas de destino como valores de números enteros, usa la clase LabelEncoder 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 MaxAbsScaler en el módulo bigframes.ml.preprocessing.

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

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

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

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

Entrena modelos

Puedes crear estimadores para entrenar modelos en BigQuery DataFrames.

Modelos de agrupamiento,

Puedes crear estimadores para los modelos de agrupamiento en clústeres con el módulo bigframes.ml.cluster. Para crear modelos de agrupamiento en clústeres de k-means, usa la clase KMeans. Usa estos modelos para la segmentación de datos. Por ejemplo, identificar segmentos de clientes. K-means es una técnica de aprendizaje no supervisado, 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. Para crear modelos de análisis de componentes principales (PCA), usa la clase PCA. Usa estos modelos para calcular los componentes principales y usarlos para realizar un cambio de base en los datos. El uso de la clase PCA 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.

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

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

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

  • Para crear modelos de regresión de árbol con potenciación del gradiente, usa la clase XGBRegressor. 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. Para crear modelos de previsión de series temporales, usa la clase ARIMAPlus.

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.

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

  • Para crear modelos de regresión logística, usa la clase LogisticRegression. 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 LLM con el módulo bigframes.ml.llm.

  • Para crear modelos generativos de texto de Gemini, usa la clase GeminiTextGenerator. Usa estos modelos para tareas de generación de texto.

  • Para crear estimadores para modelos de lenguaje grande (LLM) remotos, usa el módulo bigframes.ml.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 usas 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. Para evitar este requisito, configura la opción bigframes.pandas.options.bigquery.skip_bq_connection_check como True, en cuyo caso la conexión (predeterminada o preconfigurada) se usa tal como está sin verificar su existencia o sus permisos. 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 modelos remotos de AA de BigQuery DataFrames, la cuenta de servicio tiene el rol de usuario de Agent Platform (roles/aiplatform.user) en el proyecto.

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 para la conexión predeterminada se le otorga el rol de usuario de Agent Platform (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.

Para crear una canalización de transformaciones con un estimador final, usa la clase Pipeline.

Seleccionar modelos

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

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

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

  • Para crear conjuntos de entrenamiento y prueba de varios pliegues con el objetivo de entrenar y evaluar modelos, como se muestra en la siguiente muestra de código, usa la clase KFold y el método KFold.split. Esta función es valiosa para 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

  • 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 la siguiente muestra de código, usa la función cross_validate:

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

¿Qué sigue?