Study guide
9.1 Organizing & Ingesting Training Data from Cloud Storage & BigQuery
Google Cloud Professional Machine Learning Engineer PMLE
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Exam Overview & the Agent Platform Map
1.1 PMLE Exam Facts, Policies & the June 2026 Blueprint 1.2 From Vertex AI to Gemini Enterprise Agent Platform: The Product Name Map
2 Chapter 2: Low-Code ML with BigQuery ML
2.1 Choosing, Training & Predicting with BigQuery ML Models 2.2 Feature Engineering & Feature Selection in BigQuery ML 2.3 Fine-Tuning & Evaluating Gemini Models from BigQuery
3 Chapter 3: AutoML & Google Cloud AI APIs
3.1 Training Models with Agent Platform AutoML 3.2 Building with Document AI, Vision, Translation & Other AI APIs
4 Chapter 4: Foundation Models in Model Garden
4.1 Evaluating & Selecting Models in Model Garden 4.2 Building & Tuning Solutions with Gemini, Imagen, Veo & MaaS 4.3 Optimizing Gemini Applications for Cost, Latency & Availability
5 Chapter 5: Exploring, Preprocessing & Protecting Data
5.1 Organizing & Exploring Tabular, Text & Image Data 5.2 Choosing a Preprocessing Tool: BigQuery, Dataflow, Spark or Python 5.3 Creating & Consolidating Features in Agent Platform Feature Store 5.4 Protecting PII & Sensitive Data in ML Workflows
6 Chapter 6: Notebooks, Prototyping & Experiment Tracking
6.1 Workbench vs. Colab Enterprise: Secure, Collaborative Notebooks 6.2 Prototyping with PyTorch, scikit-learn, JAX & Model Garden in Notebooks 6.3 Experiment Environments, Tracking & Lineage with Experiments and ML Metadata
7 Chapter 7: Evaluating Predictive & Generative AI Solutions
7.1 Evaluation Metrics for Predictive Models 7.2 Evaluating Gen AI: Computation Metrics, Rubrics & LLM-as-a-Judge
8 Chapter 8: Choosing the Modeling Approach
8.1 Choosing the Model Type: ARIMA, Trees, DNNs & LLMs 8.2 Choosing the Product & Deployment Strategy 8.3 Modeling Techniques for Interpretability Requirements
9 Chapter 9: Training Data & Training SDKs
9.1 Organizing & Ingesting Training Data from Cloud Storage & BigQuery 9.2 Custom Training on Agent Platform: Containers, Jobs & Worker Pools 9.3 Kubeflow on GKE, AutoML & Tabular Workflows as Training Choices
10 Chapter 10: Troubleshooting, Hyperparameter Tuning & Fine-Tuning
10.1 Troubleshooting ML Training Failures 10.2 Hyperparameter Tuning on Agent Platform 10.3 Fine-Tuning Foundation Models & When to Tune
11 Chapter 11: Training Hardware & Distributed Training
11.1 Choosing CPUs, GPUs & TPUs for Training 11.2 Distributed Training: Data & Model Parallelism
12 Chapter 12: Deploying Models for Inference
12.1 Batch vs. Online Inference on Agent Platform 12.2 Serving Beyond Agent Platform Endpoints: Model Garden, Cloud Run & GKE 12.3 Prebuilt & Custom Serving Containers
13 Chapter 13: Model Versions, Rollouts & Inference Logic
13.1 Organizing & Versioning Models in Model Registry 13.2 Rollout Strategies: A/B Tests, Canaries & Traffic Splits 13.3 Inference Preprocessing & Postprocessing
14 Chapter 14: Scaling Online Serving
14.1 Serving Features Online with Feature Store 14.2 Public, Dedicated & Private Endpoints 14.3 Serving Hardware & Autoscaling for Throughput 14.4 Tuning Models for Production Training & Serving
15 Chapter 15: End-to-End ML Pipelines
15.1 Validating Data & Models in Pipelines 15.2 Agent Platform Pipelines with KFP: Components, Templates & Caching 15.3 Ensuring Consistent Preprocessing Between Training & Serving
16 Chapter 16: Orchestration with Managed Airflow & Ray
16.1 Orchestrating ML Workflows with Managed Service for Apache Airflow 16.2 Ray on Agent Platform for Distributed ML Workloads
17 Chapter 17: Automating Retraining & CI/CD/CT
17.1 Choosing a Retraining Policy 17.2 CI/CD/CT for ML with Cloud Build
18 Chapter 18: Securing AI Systems, Responsible AI & Explainability
18.1 Protecting AI Systems from Data & Model Exfiltration 18.2 Defending Gen AI Apps: Safety Filters, Model Armor & Regex Guardrails 18.3 Responsible AI: Detecting & Monitoring Bias 18.4 Model Explainability on Agent Platform
19 Chapter 19: Monitoring AI Solutions
19.1 Configuring Model Monitoring on Agent Platform 19.2 Training-Serving Skew, Data Drift, Concept Drift & Attribution Drift 19.3 Monitoring, Testing & Evaluating Gen AI Solutions in Production
9.1 Organizing & Ingesting Training Data from Cloud Storage & BigQuery
Key Takeaways Explain This Topic AI
Serverless training jobs can read and write Cloud Storage buckets as local paths under the /gcs root through Cloud Storage FUSE.
When a custom training job uses a managed dataset, Agent Platform sets AIP_DATA_FORMAT to jsonl, csv, or bigquery and passes split locations in AIP_TRAINING_DATA_URI, AIP_VALIDATION_DATA_URI, and AIP_TEST_DATA_URI.
Sharded binary formats such as TFRecord, or columnar formats such as Parquet, load faster at scale than millions of small individual files.
By default, a serverless training job can access Cloud Storage buckets in its own project through the Custom Code Service Agent; a custom service account narrows that access.
Organize unstructured training data with import manifests (JSON Lines or CSV) that map Cloud Storage file URIs to labels.
Last updated: September 2026
Section 3.2 of the exam guide starts with organizing training data (tabular, text, speech, images, and videos) on Google Cloud (for example, Cloud Storage and BigQuery) and ingesting structured and unstructured data from various sources into training pipelines . Chapter 5 covered exploration and preprocessing. This section is about getting prepared data into training jobs efficiently and repeatably.
Organizing Training Data by Type
Data type Recommended layout Label storage
Tabular BigQuery tables partitioned by date, one row per example. Or Parquet/CSV exports in Cloud Storage for frameworks that read files Label column in the same table
Text Short text in BigQuery columns. Long documents as files in Cloud Storage. Tuning data as JSON Lines Label column, or JSONL fields (for example, prompt and response)
Speech / audio Audio files (WAV, FLAC) in Cloud Storage, organized by source and date Manifest (JSONL or CSV) mapping gs:// URIs to transcripts or labels
Images Image files in Cloud Storage Import file (JSONL or CSV) mapping URIs to labels or bounding boxes
Video Video files in Cloud Storage. Long videos split into segments when needed Manifest with URIs, time segments, and labels
Principles:
Keep raw , processed , and training-ready data in separate, versioned locations, such as gs://bucket/datasets/claims/v12/train/ .
Never overwrite a dataset version a model was trained on. Lineage and audits depend on it (Chapter 6).
Put data in the same region as training compute.
Keep manifests (import files) as the source of truth for which files belong to which split and label.
File Formats for Scale
Format Strengths Typical use
TFRecord Sequential binary records, easy sharding, fast with tf.data TensorFlow and JAX training on images or serialized examples
- Parquet Columnar, compressed, schema-aware Large tabular data read with Spark, pandas, or PyArrow
- Avro Row-based with schema, good for streaming exports Data pipeline interchange
- CSV Simple and human-readable Small datasets and AutoML imports. Slower and schema-less at scale
- JSON Lines One JSON object per line Gemini tuning and batch inference inputs, import manifests
Sharding: split large datasets into many medium-sized shards, not one giant file and not millions of tiny ones, so distributed workers read in parallel. Shuffle across shards and within buffers.
- Reading Data into Training Code
- From Cloud Storage
Cloud Storage FUSE: serverless training jobs see buckets under /gcs/ . For example, gs://example-bucket/data.csv is read as /gcs/example-bucket/data.csv . Data is streamed , not downloaded to every replica, which speeds startup and suits large files and distributed training.
Framework loaders: tf.data.TFRecordDataset with parallel reads and prefetch , PyTorch DataLoader with multiple workers over FUSE paths, or WebDataset-style shard readers.
NFS shares for workloads that need POSIX semantics or very low-latency shared file access.
From BigQuery
Read directly with the BigQuery Storage Read API through client libraries and framework connectors. This streams rows in parallel without exporting to CSV first.
For very large one-off training sets, export a query result to sharded Parquet or Avro in Cloud Storage, then train from files.
Use BigQuery DataFrames during development to sample and inspect before training.
From managed datasets
When a custom training job uses a managed dataset, Agent Platform exports the splits and sets:
- Variable Meaning
- AIP_DATA_FORMAT jsonl , csv , or bigquery
- AIP_TRAINING_DATA_URI Training split location (Cloud Storage wildcard URI or BigQuery table)
- AIP_VALIDATION_DATA_URI Validation split location
- AIP_TEST_DATA_URI Test split location
Code that reads these variables works with any dataset version, with no hard-coded paths.
Ingesting from Various Sources
Source Ingestion path into training-ready storage
Operational databases (Cloud SQL, AlloyDB, Spanner) Scheduled exports or federated queries into BigQuery, then training tables
- Event streams (Pub/Sub) Dataflow streaming into BigQuery (tables) or Cloud Storage (files)
- On-premises files Storage Transfer Service, or gcloud storage for smaller loads, into Cloud Storage
- SaaS and marketing platforms BigQuery Data Transfer Service into BigQuery
- Other clouds Storage Transfer Service, or BigQuery external tables over open formats
Documents and media Upload to Cloud Storage, extract with Document AI or Speech-to-Text, store outputs in BigQuery
Make ingestion a pipeline step (BigQuery, Dataflow, or Managed Spark components in Agent Platform Pipelines) so every training run records which data snapshot it used.
Access and Security for Training Data
By default, a serverless training job reads Cloud Storage buckets in the same project through the Custom Code Service Agent . Assign a custom service account to limit the job to exactly the buckets and tables it needs.
Grant the Agent Platform Service Agent access to buckets or tables in other projects that managed datasets use.
Keep training data inside VPC Service Controls perimeters when exfiltration is a concern (Chapter 18).
Diagnosing Slow Input Pipelines
If GPUs sit idle between steps, the input pipeline is the bottleneck. Common fixes:
Replace many small files with sharded TFRecord or Parquet.
Read in parallel (interleave shards, multiple loader workers).
Prefetch batches so the accelerator never waits.
Cache decoded data when it fits in memory or local SSD.
Move heavy preprocessing out of the training loop into an offline Dataflow or BigQuery step.
Use the TensorBoard profiler to confirm where time goes.