Utiliser le ML et l'IA avec BigQuery DataFrames

BigQuery DataFrames fournit des fonctionnalités de ML et d'IA pour BigQuery DataFrames à l'aide de la bibliothèque bigframes.ml.

Vous pouvez prétraiter des données, créer des estimateurs pour entraîner des modèles dans BigQuery DataFrames, créer des pipelines de ML et diviser les ensembles de données d'entraînement et de test.

Rôles requis

Pour obtenir les autorisations nécessaires pour effectuer les tâches décrites dans ce document, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Emplacements de ML

La bibliothèque bigframes.ml est disponible dans les mêmes emplacements que BigQuery ML. La prédiction de modèle BigQuery ML et d'autres fonctions de ML sont acceptées dans toutes les régions BigQuery. La compatibilité de l'entraînement de modèle varie selon les régions. Pour en savoir plus, consultez la page Emplacements BigQuery ML.

Procéder au prétraitement des données

Créez des transformateurs pour préparer les données à utiliser dans des estimateurs (modèles) en utilisant le bigframes.ml.preprocessing module et le bigframes.ml.compose module. BigQuery DataFrames propose les transformations suivantes :

  • Pour regrouper des données continues en intervalles, utilisez la KBinsDiscretizer classe dans le bigframes.ml.preprocessing module.

  • Pour normaliser les étiquettes cibles sous forme de valeurs entières, utilisez la LabelEncoder classe dans le bigframes.ml.preprocessing module.

  • Pour adapter chaque caractéristique à la plage [-1, 1] en fonction de sa valeur absolue maximale, utilisez la MaxAbsScaler classe dans le module bigframes.ml.preprocessing.

  • Pour standardiser les caractéristiques en les ajustant à la plage [0, 1], utilisez la MinMaxScaler classe dans le bigframes.ml.preprocessing module.

  • Pour standardiser les caractéristiques en supprimant la moyenne et en effectuant un scaling à la hausse de la variance unitaire, utilisez la StandardScaler classe dans le module bigframes.ml.preprocessing.

  • Pour transformer des valeurs catégorielles au format numérique, utilisez la OneHotEncoder classe dans le bigframes.ml.preprocessing module.

  • Pour appliquer des transformateurs aux colonnes DataFrames, utilisez la ColumnTransformer classe dans le bigframes.ml.compose module.

Entraîner des modèles

Vous pouvez créer des estimateurs pour entraîner des modèles dans BigQuery DataFrames.

Modèles de clustering

Vous pouvez créer des estimateurs pour les modèles de clustering à l'aide du bigframes.ml.cluster module. Pour créer des modèles de clustering en k-moyennes, utilisez la KMeans classe. Utilisez ces modèles pour la segmentation des données. Par exemple, pour identifier des segments de clientèle. Les k-moyennes étant une technique d'apprentissage non supervisée, l'entraînement de modèle ne nécessite pas d'étiquettes ni de données fractionnées pour l'entraînement ou l'évaluation.

Vous pouvez utiliser le module bigframes.ml.cluster pour créer des estimateurs pour les modèles de clustering.

L'exemple de code suivant montre comment utiliser la classe bigframes.ml.cluster KMeans pour créer un modèle de clustering en k-moyennes pour la segmentation des données :

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)

Modèles de décomposition

Vous pouvez créer des estimateurs pour les modèles de décomposition à l'aide du bigframes.ml.decomposition module. Pour créer des modèles d'analyse des composants principaux (ACP), utilisez la PCA classe. Utilisez ces modèles pour calculer les composants principaux et les utiliser afin d'effectuer un changement de base sur les données. L'utilisation de la classe PCA permet de réduire la dimensionnalité en ne projetant chaque point de données que sur les premiers composants principaux afin d'obtenir des données de dimension inférieure tout en conservant autant que possible les variations de données.

Modèles ensemblistes

Vous pouvez créer des estimateurs pour les modèles ensemblistes à l'aide du bigframes.ml.ensemble module.

  • Pour créer des modèles de classificateur de forêt d'arbres décisionnels, utilisez la RandomForestClassifier classe. Utilisez ces modèles pour construire plusieurs arbres de décision de méthodes d'apprentissage pour la classification.

  • Pour créer des modèles de régression de forêt d'arbres décisionnels, utilisez la RandomForestRegressor classe. Utilisez ces modèles pour construire plusieurs arbres de décision de méthodes d'apprentissage pour la régression.

  • Pour créer des modèles de classificateur d'arbre de décision à boosting de gradient, utilisez la XGBClassifier classe. Utilisez ces modèles pour créer de manière additive plusieurs arbres de décision de méthode d'apprentissage pour la classification.

  • Pour créer des modèles de régression d'arbre de décision à boosting de gradient, utilisez la XGBRegressor classe. Utilisez ces modèles pour construire de manière additive plusieurs arbres de décision de méthode d'apprentissage pour la régression.

Modèles de prévision

Vous pouvez créer des estimateurs pour les modèles de prévision à l'aide du bigframes.ml.forecasting module. Pour créer des modèles de prévision de séries temporelles, utilisez la ARIMAPlus classe.

Modèles importés

Vous pouvez créer des estimateurs pour les modèles importés à l'aide du bigframes.ml.imported module.

Modèles linéaires

Créez des estimateurs pour les modèles linéaires à l'aide du bigframes.ml.linear_model module.

  • Pour créer des modèles de régression linéaire, utilisez la LinearRegression classe. Utilisez ces modèles pour la prévision, par exemple pour prévoir les ventes d'un article un jour donné.

  • Pour créer des modèles de régression logistique, utilisez la LogisticRegression classe. Utilisez ces modèles pour la classification d'au moins deux valeurs possibles, par exemple si une entrée est low-value, medium-value ou high-value.

L'exemple de code suivant montre comment utiliser bigframes.ml pour effectuer les opérations suivantes :

  • Charger des données à partir de BigQuery.
  • Nettoyer et préparer les données d'entraînement.
  • Créer et appliquer un bigframes.ml.LinearRegression.
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)

Grands modèles de langage

Vous pouvez créer des estimateurs pour les LLM à l'aide du bigframes.ml.llm module.

  • Pour créer des modèles génératifs de texte Gemini, utilisez la GeminiTextGenerator classe. Utilisez ces modèles pour les tâches de génération de texte.

  • Pour créer des estimateurs pour les grands modèles de langage (LLM) distants, utilisez le bigframes.ml.llm module.

L'exemple de code suivant montre comment utiliser la bigframes.ml.llm GeminiTextGenerator classe pour créer un modèle Gemini pour la génération de code :

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)

Modèles distants

Pour utiliser des modèles distants BigQuery DataFrames ML (bigframes.ml.remote ou bigframes.ml.llm), vous devez activer les API suivantes :

Lorsque vous utilisez des modèles distants BigQuery DataFrames ML, vous avez besoin du rôle Administrateur IAM du projet (roles/resourcemanager.projectIamAdmin) si vous utilisez une connexion BigQuery par défaut, ou du rôle Navigateur (roles/browser) si vous utilisez une connexion préconfigurée. Vous pouvez éviter cette exigence en définissant l'option bigframes.pandas.options.bigquery.skip_bq_connection_check sur True. Dans ce cas, la connexion (par défaut ou préconfigurée) est utilisée telle quelle, sans aucune vérification d'existence ni d'autorisation. Si vous utilisez la connexion préconfigurée et que vous ignorez la vérification de connexion, vérifiez les points suivants :

  • La connexion est créée au bon endroit.
  • Si vous utilisez des modèles distants de BigQuery DataFrames ML, le compte de service dispose du rôle Utilisateur Vertex AI (roles/aiplatform.user) sur le projet.

La création d'un modèle distant dans BigQuery DataFrames crée une connexion BigQuery. Par défaut, une connexion nommée bigframes-default-connection est utilisée. Si vous préférez, vous pouvez utiliser une connexion BigQuery préconfigurée. Dans ce cas, la création de la connexion est ignorée. Le compte de service pour la connexion par défaut se voit attribuer le rôle Utilisateur Vertex AI (roles/aiplatform.user) sur le projet.

Créer des pipelines

Vous pouvez créer des pipelines de ML à l'aide du bigframes.ml.pipeline module. Les pipelines vous permettent de combiner plusieurs étapes de ML pour qu'elles puissent faire l'objet d'une validation croisée tout en définissant différents paramètres. Cela simplifie votre code et vous permet de déployer ensemble les étapes de prétraitement des données et un estimateur.

Pour créer un pipeline de transformations avec un estimateur final, utilisez la Pipeline classe.

Sélectionner des modèles

Pour diviser vos ensembles de données d'entraînement et de test, et sélectionner les meilleurs modèles, utilisez le bigframes.ml.model_selection module module :

  • Pour diviser les données en ensembles d'entraînement et de test (ensembles d'évaluation), comme illustré dans le exemple de code suivant, utilisez la train_test_split fonction :

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

  • Pour créer des ensembles d'entraînement et de test à plusieurs plis afin d'entraîner et d'évaluer des modèles, comme illustré dans l'exemple de code suivant, utilisez la KFold classe et la KFold.split méthode. Cette fonctionnalité est utile pour les petits ensembles de données.

    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

  • Pour créer automatiquement des ensembles d'entraînement et de test à plusieurs plis, entraîner et évaluer le modèle, et obtenir le résultat de chaque pli, comme illustré dans l'exemple de code suivant, utilisez la cross_validate fonction :

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

Étape suivante