Utiliser BigQuery DataFrames

Preview

Ce produit ou cette fonctionnalité est soumis aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les produits et fonctionnalités pré-DG sont disponibles "en l'état" et peuvent bénéficier d'une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Pour obtenir de l'aide pendant la version preview, envoyez un e-mail à [e-mail].

Ce document explique comment utiliser BigQuery DataFrames pour analyser et manipuler des données dans un notebook BigQuery.

BigQuery DataFrames est une bibliothèque cliente Python que vous pouvez utiliser pour analyser des données et effectuer des tâches de machine learning dans des notebooks BigQuery.

BigQuery DataFrames comprend les éléments suivants :

• bigframes.pandas met en œuvre une API de type Pandas en plus de BigQuery.
• bigframes.ml met en œuvre une API de type scikit-learn en plus de BigQuery ML.

Avant de commencer

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

4. Make sure that billing is enabled for your Google Cloud project.

5. Vérifiez que l'API BigQuery est activée.

   Activer l'API

   Si vous avez créé un nouveau projet, l'API BigQuery est automatiquement activée.

Autorisations requises

Pour utiliser BigQuery DataFrames dans un notebook BigQuery, vous devez disposer des rôles IAM (Identity and Access Management) suivants :

• Utilisateur BigQuery (roles/bigquery.user)
• Utilisateur de l'environnement d'exécution de notebook (roles/aiplatform.notebookRuntimeUser)
• Créateur de code (roles/dataform.codeCreator)

Créer un notebook

Suivez les instructions de la section Créer un notebook à partir de l'éditeur BigQuery pour créer un notebook.

Configurer les options BigQuery DataFrames

Après l'installation, vous devez spécifier l'emplacement et le projet dans lesquels vous souhaitez utiliser BigQuery DataFrames.

Vous pouvez définir l'emplacement et le projet dans votre notebook de la manière suivante :

import bigframes.pandas as bpd

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

# Set BigQuery DataFrames options
bpd.options.bigquery.project = PROJECT_ID
bpd.options.bigquery.location = REGION

Utiliser "bigframes.pandas"

L'API bigframes.pandas fournit une API de type pandas que vous pouvez utiliser pour analyser et manipuler des données dans BigQuery. L'API bigframes.pandas est évolutive afin de traiter des téraoctets de données BigQuery. Elle utilise le moteur de requête de BigQuery pour effectuer des calculs.

L'API bigframes.pandas offre les fonctionnalités suivantes :

Entrées et sorties

Vous pouvez accéder aux données à partir de diverses sources, y compris les fichiers CSV locaux, les fichiers Cloud Storage, les objets DataFrame pandas, les modèles BigQuery et les fonctions BigQuery, puis les charger dans un fichier BigQuery DataFrame. Vous pouvez également créer des tables BigQuery à partir de BigQuery DataFrames.

Manipulation de données

Vous pouvez utiliser Python au lieu de SQL pour votre développement. Vous pouvez développer toutes les manipulations de données BigQuery dans Python, ce qui élimine le besoin de basculer entre les langages et d'essayer de capturer les instructions SQL sous forme de chaînes de texte. L'API bigframes.pandas offre plus de 250 fonctions pandas.

Écosystème et visualisations Python

L'API bigframes.pandas est une passerelle vers l'écosystème complet d'outils Python. L'API accepte les opérations statistiques avancées et vous pouvez visualiser les agrégations générées à partir de BigQuery DataFrames. Vous pouvez également passer d'un objet BigQuery DataFrame à un objet DataFrame pandas avec des opérations d'échantillonnage intégrées.

Fonctions Python personnalisées

Vous pouvez utiliser des fonctions et des packages Python personnalisés. Avec bigframes.pandas, vous pouvez déployer des fonctions distantes exécutant des fonctions Python scalaires à l'échelle de BigQuery. Vous pouvez conserver ces fonctions dans BigQuery en tant que routines SQL et les utiliser comme des fonctions SQL.

Charger des données à partir d'une table ou d'une requête BigQuery

Vous pouvez créer un objet DataFrame à partir d'une table ou d'une requête BigQuery de la manière suivante :

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

Charger des données à partir d'un fichier CSV

Vous pouvez créer un DataFrame à partir d'un fichier CSV local ou Cloud Storage de la manière suivante :

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

Inspecter et manipuler des données

Vous pouvez utiliser bigframes.pandas pour effectuer des opérations d'inspection et de calcul de données.

L'exemple de code suivant montre comment utiliser bigframes.pandas pour inspecter la colonne body_mass_g, calculer la moyenne body_mass et calculer la moyenne body_mass par 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)
)

Utiliser "bigframes.ml"

L'API de type scikit-learn bigframes.ml vous permet de créer plusieurs types de modèles de machine learning.

Régression

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 modèle de régression 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)

Clustering

Le module bigframes.ml.cluster vous permet de créer des Estimators 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 distants LLM

Vous pouvez utiliser le module bigframes.ml.llm pour créer des estimators pour les modèles MLL (Large Language Models) distants.

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

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

# Create the LLM model
session = bpd.get_global_session()
connection = f"{PROJECT_ID}.{REGION}.{CONN_NAME}"
model = PaLM2TextGenerator(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)

Tarification

BigQuery DataFrames est une bibliothèque Python Open Source. Vous pouvez afficher et télécharger le code source via GitHub. Vous pouvez installer la bibliothèque à partir de PyPI. La bibliothèque peut également être disponible sur d'autres gestionnaires de packages gérés par la communauté.

BigQuery DataFrames utilise BigQuery, Cloud Functions, Vertex AI et d'autres services Google Cloud, qui entraînent leurs propres coûts. En cas d'utilisation normale, la bibliothèque stocke les données dans des tables BigQuery intermédiaires, dont la durée par défaut est de sept jours.

Étapes suivantes

• Pour apprendre à effectuer des tâches d’analyse et de machine learning à l’aide des objets BigQuery DataFrames dans un notebook BigQuery, consultez le guide de démarrage rapide sur BigQuery DataFrames.

• Pour explorer BigQuery DataFrames, consultez la documentation de référence sur les bibliothèques BigQuery DataFrames.

• Pour explorer le code source, consultez la section Code source de BigQuery DataFrames dans GitHub.