Apache Iceberg और BigLake की मदद से, एआई के लिए यूनिफ़ाइड डेटा लेकहाउस बनाना

1. परिचय

इस कोडलैब में, आपको Google Cloud पर मौजूद यूनिफ़ाइड डेटा लेकहाउस की सुविधाओं के बारे में जानने को मिलेगा. इसमें आपको BigLake पर Apache Iceberg REST Catalog के ज़रिए उपलब्ध कराए गए सार्वजनिक डेटासेट के साथ इंटरैक्ट करने का मौका मिलेगा. इसके बाद, आपको स्ट्रक्चर्ड और अनस्ट्रक्चर्ड, दोनों तरह के डेटा पर Google Cloud की एआई सुविधाओं को लागू करने का तरीका जानने को मिलेगा.

इसमें आपको Apache Iceberg का इस्तेमाल करके, NYC Taxi के क्लासिक डेटासेट के लिए क्वेरी करने, डेटा में हुए बदलावों की ऑडिटिंग के लिए टाइम ट्रैवल की सुविधा का इस्तेमाल करने, और अपने डेटा पर एआई मॉडल चलाने के लिए BigQuery ML और Gemini का इस्तेमाल करने का तरीका जानने को मिलेगा.

आपको क्या करना होगा

• BigLake पर होस्ट किए गए Apache Iceberg के सार्वजनिक डेटासेट के लिए क्वेरी करने के लिए, Apache Spark के लिए Google Cloud Serverless का इस्तेमाल करना.
• Apache Iceberg फ़ॉर्मैट में स्ट्रक्चर्ड डेटा के लिए क्वेरी करना.
• Apache Iceberg में टाइम ट्रैवल की सुविधा का इस्तेमाल करके दिखाना.
• स्ट्रक्चर्ड डेटा पर अनुमान लगाने वाला मॉडल ट्रेन करने के लिए, BigQuery ML का इस्तेमाल करना.
• BigLake ऑब्जेक्ट टेबल (अनस्ट्रक्चर्ड डेटा) बनाना और इमेज का विश्लेषण करने के लिए Gemini का इस्तेमाल करना.

आपको किन चीज़ों की ज़रूरत होगी

• Chrome जैसे वेब ब्राउज़र की.
• बिलिंग की सुविधा वाले Google Cloud प्रोजेक्ट की.

अनुमानित लागत और समय

• पूरा होने में लगने वाला समय: ~45 मिनट.
• अनुमानित लागत: < 2.00 डॉलर. लागत कम रखने के लिए, हम सार्वजनिक डेटासेट और सर्वरलेस क्वेरी का इस्तेमाल करते हैं.

2. सेटअप और ज़रूरी शर्तें

इस चरण में, आपको अपना एनवायरमेंट तैयार करना होगा और ज़रूरी एपीआई चालू करने होंगे.

Cloud Shell शुरू करना

ज़्यादातर कमांड, Google Cloud Shell से चलाए जाएंगे.

1. Google Cloud कंसोल में सबसे ऊपर मौजूद, Cloud Shell चालू करें पर क्लिक करें.
2. पुष्टि की प्रक्रिया की जांच करें:

   gcloud auth list
   

3. अपने प्रोजेक्ट की पुष्टि करें:

   gcloud config get project
   

4. अगर प्रोजेक्ट सेट नहीं है, तो अपने प्रोजेक्ट आईडी का इस्तेमाल करके इसे सेट करें:

   gcloud config set project <YOUR_PROJECT_ID>
   

एपीआई चालू करें

BigQuery, Cloud Resource Manager, और Vertex AI के लिए ज़रूरी एपीआई चालू करने के लिए, यह कमांड चलाएं:

gcloud services enable \
  bigquery.googleapis.com \
  aiplatform.googleapis.com \
  cloudresourcemanager.googleapis.com

एनवायरमेंट कॉन्फ़िगर करना और डिपेंडेंसी बकेट बनाना

1. अपने टर्मिनल में एनवायरमेंट वैरिएबल सेट करें:

   export PROJECT_ID=$(gcloud config get project)
   export REGION=us-central1
   export DEPS_BUCKET=$PROJECT_ID-deps-bucket
   

2. डिपेंडेंसी Cloud Storage बकेट बनाएं. जॉब सबमिट करने के समय, PySpark स्क्रिप्ट यहां अपलोड की जाती हैं:

   gcloud storage buckets create gs://$DEPS_BUCKET --location=$REGION
   

3. Apache Iceberg के सार्वजनिक कैटलॉग से कनेक्ट करना

इस चरण में, आपको Google Cloud के BigLake पर होस्ट किए गए, प्रोडक्शन-ग्रेड के लाइव Apache Iceberg कैटलॉग से कनेक्ट करना होगा.

Apache Spark बैच सीएलआई के लिए सर्वरलेस की मदद से Spark SQL चलाना

हम इन्फ़्रास्ट्रक्चर को मैनेज किए बिना, PySpark जॉब चलाने के लिए Apache Spark के लिए Google Cloud Serverless का इस्तेमाल करेंगे. हम इसे सार्वजनिक BigLake REST Catalog की ओर पॉइंट करने के लिए कॉन्फ़िगर करेंगे.

1. BigLake REST Catalog की प्रॉपर्टी तय करें, ताकि उन्हें बार-बार दोहराना न पड़े.इस कॉन्फ़िगरेशन से Spark को यह जानकारी मिलती है:
   • iceberg-spark-runttime और iceberg-gcp-bundle लाइब्रेरी का इस्तेमाल करना.
   • BigLake REST Catalog के एंडपॉइंट का इस्तेमाल करके, my_catalog नाम का कैटलॉग कॉन्फ़िगर करना.
   • डिफ़ॉल्ट लोकल फ़ाइल सिस्टम के बजाय, डेटा फ़ाइलें पढ़ने के लिए Google Cloud Storage (GCS) का इस्तेमाल करना.
   • अपने सेशन के लिए, इस my_catalog कैटलॉग को डिफ़ॉल्ट के तौर पर सेट करना.
   • बेहतर सुरक्षा और डेटा को आसानी से ऐक्सेस करने के लिए, वेंडर के क्रेडेंशियल का इस्तेमाल करना.

   export METASTORE_PROPERTIES="^|^spark.jars.packages=org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:1.10.0,org.apache.iceberg:iceberg-gcp-bundle:1.10.0|\
   spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog|\
   spark.sql.catalog.my_catalog.type=rest|\
   spark.sql.catalog.my_catalog.uri=https://biglake.googleapis.com/iceberg/v1/restcatalog|\
   spark.sql.catalog.my_catalog.warehouse=gs://biglake-public-nyc-taxi-iceberg|\
   spark.sql.catalog.my_catalog.io-impl=org.apache.iceberg.gcp.gcs.GCSFileIO|\
   spark.sql.catalog.my_catalog.header.x-goog-user-project=$PROJECT_ID|\
   spark.sql.catalog.my_catalog.header.X-Iceberg-Access-Delegation=vended-credentials|\
   spark.sql.catalog.my_catalog.rest.auth.type=org.apache.iceberg.gcp.auth.GoogleAuthManager|\
   spark.sql.defaultCatalog=my_catalog|\
   spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions|\
   spark.log.level=ERROR"
   

2. टेस्ट के लिए एक सामान्य क्वेरी फ़ाइल बनाना:

   cat <<EOF > test.py
   from pyspark.sql import SparkSession
   
   spark = SparkSession.builder.getOrCreate()
   
   spark.sql("SHOW TABLES IN public_data").show()
   EOF
   

3. बैच जॉब सबमिट करना:

   gcloud dataproc batches submit pyspark \
     --project=$PROJECT_ID \
     --region=$REGION \
     --version=2.3 \
     --properties="$METASTORE_PROPERTIES" \
     --deps-bucket=gs://$DEPS_BUCKET \
     test.py
   

   आपको ऐसा आउटपुट दिखेगा:

   +-----------+----------------+-----------+
   |  namespace|       tableName|isTemporary|
   +-----------+----------------+-----------+
   |public_data|     nyc_taxicab|      false|
   |public_data|nyc_taxicab_2021|      false|
   +-----------+----------------+-----------+
   

4. Iceberg के स्ट्रक्चर्ड डेटा के लिए क्वेरी करना

कनेक्ट होने के बाद, आपके पास डेटासेट को ऐक्सेस करने के लिए, SQL की पूरी सुविधा होती है. हम NYC Taxi के डेटासेट के लिए क्वेरी करेंगे. इसे Iceberg टेबल के तौर पर मॉडल किया गया है.

एग्रीगेशन के लिए स्टैंडर्ड क्वेरी चलाना

query.py नाम की एक फ़ाइल बनाएं:

cat <<EOF > query.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

query = """
SELECT
  passenger_count,
  COUNT(1) AS num_trips,
  ROUND(AVG(total_amount), 2) AS avg_fare,
  ROUND(AVG(trip_distance), 2) AS avg_distance
FROM public_data.nyc_taxicab
WHERE data_file_year = 2021 AND passenger_count > 0
GROUP BY passenger_count
ORDER BY num_trips DESC
"""

spark.sql(query).show()
EOF

इसे Apache Spark के लिए सर्वरलेस का इस्तेमाल करके सबमिट करें:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  query.py

आपको अपने कंसोल में ऐसा आउटपुट दिखेगा:

+---------------+---------+--------+------------+
|passenger_count|num_trips|avg_fare|avg_distance|
+---------------+---------+--------+------------+
|              1| 21508009|   18.82|        3.03|
|              2|  4424746|   20.22|        3.40|
|              3|  1164846|   19.84|        3.27|
|              5|   718282|   18.88|        3.07|
|              4|   466485|   20.61|        3.44|
|              6|   452467|   18.97|        3.11|
|              7|       78|   65.24|        3.71|
|              8|       49|   57.39|        5.88|
|              9|       35|   73.26|        6.20|
|             96|        1|   17.00|        2.00|
|            112|        1|   15.00|        2.00|
+---------------+---------+--------+------------+

यहां Apache Iceberg का इस्तेमाल क्यों करें?

• पार्टिशन प्रूनिंग: क्वेरी, data_file_year = 2021 पर फ़िल्टर करती है. Iceberg की मदद से, इंजन पूरी तरह से दूसरे सालों के डेटा को स्कैन नहीं करता.
• इंजन की सुविधा: इसे Spark, Trino या BigQuery में, डेटा कॉपी किए बिना चलाया जा सकता है!

5. Apache Iceberg में टाइम ट्रैवल की सुविधा

टाइम ट्रैवल की सुविधा, Iceberg की सबसे दमदार सुविधाओं में से एक है. इसकी मदद से, किसी पिछले वर्शन या स्नैपशॉट में मौजूद डेटा के लिए क्वेरी की जा सकती है.

टेबल का इतिहास देखना

history.py नाम की एक फ़ाइल बनाएं:

cat <<EOF > history.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

spark.sql("SELECT * FROM public_data.nyc_taxicab.history").show()
EOF

इसे सबमिट करें:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  history.py

आपको अपने कंसोल में ऐसा आउटपुट दिखेगा:

+--------------------+-------------------+-------------------+-------------------+
|     made_current_at|        snapshot_id|          parent_id|is_current_ancestor|
+--------------------+-------------------+-------------------+-------------------+
|2026-01-07 21:32:...|6333415779680505547|               NULL|               true|
|2026-01-07 21:34:...|1840345522877675925|6333415779680505547|               true|
|2026-01-07 21:36:...|7203554539964460256|1840345522877675925|               true|
|2026-01-07 21:38:...|4573466015237516024|7203554539964460256|               true|
|2026-01-07 21:40:...|3353190952148867790|4573466015237516024|               true|
|2026-01-07 21:42:...|1335547378580631681|3353190952148867790|               true|
|2026-01-07 21:44:...|8203141258229894239|1335547378580631681|               true|
|2026-01-07 21:46:...|1597048231706307813|8203141258229894239|               true|
|2026-01-07 21:48:...|6247811509231462655|1597048231706307813|               true|
|2026-01-07 21:50:...|2527184310045633322|6247811509231462655|               true|
|2026-01-07 21:52:...|2512764101237223642|2527184310045633322|               true|
|2026-01-07 21:52:...|7045957533358062548|2512764101237223642|               true|
|2026-01-07 21:53:...| 531753237516076726|7045957533358062548|               true|
|2026-01-07 21:53:...|4184653573199718274| 531753237516076726|               true|
|2026-01-07 21:54:...|5125223829492177301|4184653573199718274|               true|
|2026-01-07 21:54:...|6844673237417600305|5125223829492177301|               true|
|2026-01-07 21:54:...|6634828203344518093|6844673237417600305|               true|
|2026-01-07 21:55:...|7637728273407236194|6634828203344518093|               true|
|2026-01-07 21:55:...|3424071684958740192|7637728273407236194|               true|
|2026-01-07 21:55:...|1743746294196424254|3424071684958740192|               true|
+--------------------+-------------------+-------------------+-------------------+

आपको अलग-अलग स्नैपशॉट आईडी और उनके कमिट होने का समय दिखाने वाली लाइनें दिखेंगी.

लाइन की मौजूदा संख्या की तुलना पिछली संख्या से करना

timetravel.py नाम की एक फ़ाइल बनाएं:

cat <<EOF > timetravel.py
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

query = """
SELECT 'Current State' AS version, COUNT(*) AS count FROM public_data.nyc_taxicab
UNION ALL
SELECT 'Past State' AS version, COUNT(*) AS count FROM public_data.nyc_taxicab VERSION AS OF 4573466015237516024
"""

spark.sql(query).show()
EOF

इसे सबमिट करें:

gcloud dataproc batches submit pyspark \
  --project=$PROJECT_ID \
  --region=$REGION \
  --version=2.3 \
  --properties="$METASTORE_PROPERTIES" \
  --deps-bucket=gs://$DEPS_BUCKET \
  timetravel.py

आपको अपने कंसोल में ऐसा आउटपुट दिखेगा:

+-------------+----------+
|      version|     count|
+-------------+----------+
|Current State|1293069366|
|   Past State|  72878594|
+-------------+----------+

इससे यह पक्का होता है कि समय के साथ-साथ डेटा में हुए बदलावों की ऑडिटिंग की जा सकती है.

6. BigQuery ML की मदद से स्ट्रक्चर्ड डेटा के लिए एआई का इस्तेमाल करना

अब आपने Iceberg के डेटा के बारे में जान लिया है, तो आइए BigQuery की एआई सुविधाओं का इस्तेमाल करें! सार्वजनिक Iceberg कैटलॉग, सिर्फ़ पढ़ने के लिए उपलब्ध है. इसलिए, हम सार्वजनिक टेबल से पढ़कर, अपने Workspace में किसी मॉडल को ट्रेन करने के लिए BigQuery का इस्तेमाल कर सकते हैं.

लोकल डेटासेट बनाना

सबसे पहले, अपने प्रोजेक्ट में एक डेटासेट बनाएं, ताकि bq सीएलआई का इस्तेमाल करके एआई मॉडल को स्टोर किया जा सके:

bq mk --location=$REGION --project_id=$PROJECT_ID iceberg_ai

लीनियर रिग्रेशन मॉडल को ट्रेन करना

अब आपको सार्वजनिक BigLake Iceberg टेबल का इस्तेमाल करके, लीनियर रिग्रेशन मॉडल को ट्रेन करना होगा.

क्वेरी फ़ाइल बनाएं और bq query का इस्तेमाल करके मॉडल को ट्रेन करें:

cat <<'EOF' > train_model.sql
CREATE OR REPLACE MODEL `iceberg_ai.predict_fare`
OPTIONS(model_type='LINEAR_REG', input_label_cols=['fare_amount']) AS
SELECT fare_amount, passenger_count, CAST(trip_distance AS FLOAT64) AS trip_distance
FROM `bigquery-public-data`.`biglake-public-nyc-taxi-iceberg`.public_data.nyc_taxicab
WHERE fare_amount > 0 AND trip_distance > 0 AND RAND() < 0.01; -- Using 1% of data to downsample
EOF

bq query --location=$REGION --use_legacy_sql=false < train_model.sql

RAND() < 0.01 एक डाउनस्केलिंग तकनीक है. इसकी मदद से, संसाधनों का इस्तेमाल कम रखते हुए, मॉडल को तेज़ी से ट्रेन किया जा सकता है!

आपको यह चेतावनी मिल सकती है कि passenger_count कॉलम में NULL वैल्यू मौजूद हैं. BigQuery ML, ट्रेनिंग के दौरान NULL वैल्यू को अपने-आप मैनेज करता है. इसके लिए, वह वैल्यू को इनपुट करता है. इसलिए, आपको चिंता करने की ज़रूरत नहीं है. ज़्यादा जानकारी के लिए, BigQuery ML में वैल्यू इनपुट करना लेख पढ़ें.

मॉडल का इस्तेमाल करके अनुमान लगाना

मॉडल को ट्रेन करने के बाद, ML.PREDICT का इस्तेमाल करके, नई यात्राओं के लिए किराये की रकम का अनुमान लगाया जा सकता है.

क्वेरी फ़ाइल बनाएं और bq query का इस्तेमाल करके अनुमान लगाएं:

cat <<'EOF' > predict_fare.sql
SELECT
  predicted_fare_amount, passenger_count, trip_distance
FROM
  ML.PREDICT(MODEL `iceberg_ai.predict_fare`,
    (
    SELECT 2 AS passenger_count, 5.0 AS trip_distance
    )
  );
EOF

bq query --location=$REGION --use_legacy_sql=false < predict_fare.sql

आपको ऐसा आउटपुट दिखेगा:

+-----------------------+-----------------+---------------+
| predicted_fare_amount | passenger_count | trip_distance |
+-----------------------+-----------------+---------------+
|     14.12252095150709 |               2 |           5.0 |
+-----------------------+-----------------+---------------+

7. BigLake की मदद से अनस्ट्रक्चर्ड डेटा के लिए एआई का इस्तेमाल करना

डेटा सिर्फ़ लाइनें और कॉलम नहीं होता. यूनिफ़ाइड डेटा लेकहाउस, अनस्ट्रक्चर्ड डेटा (इमेज, पीडीएफ़) को भी मैनेज करते हैं. अनस्ट्रक्चर्ड डेटा के लिए क्वेरी करने के लिए, ऑब्जेक्ट टेबल और ऑब्जेक्ट रेफ़रंस का इस्तेमाल करें.

ऑब्जेक्ट टेबल, BigQuery में सिर्फ़ पढ़ने के लिए उपलब्ध बाहरी टेबल होती हैं. इनमें Cloud Storage के पाथ में मौजूद ऑब्जेक्ट की सूची होती है. हर लाइन एक फ़ाइल को दिखाती है. इसमें मेटाडेटा के लिए कॉलम होते हैं. जैसे, uri, size. इसके अलावा, इसमें ObjectRef वाला एक खास ref कॉलम होता है.

ऑब्जेक्ट रेफ़रंस (ObjectRef), किसी एक फ़ाइल के असली डेटा की ओर पॉइंट करता है. BigQuery ML के नए फ़ंक्शन (जैसे, AI.GENERATE या AI.AGG), फ़ाइल के कॉन्टेंट (इमेज, ऑडियो या टेक्स्ट) को पढ़ने के लिए ObjectRef का इस्तेमाल करते हैं. इसके लिए, बाइट को स्टैंडर्ड टेबल में लोड करने की ज़रूरत नहीं होती.

अनस्ट्रक्चर्ड डेटा के लिए एआई के लिए डेटासेट बनाना

सबसे पहले, अपने प्रोजेक्ट में दूसरा डेटासेट बनाएं, ताकि US मल्टी-रीजन में bq सीएलआई का इस्तेमाल करके, ऑब्जेक्ट टेबल को स्टोर किया जा सके:

bq mk --location=US --project_id=$PROJECT_ID iceberg_object_ai

बाहरी कनेक्शन बनाना

Cloud Storage (ऑब्जेक्ट टेबल और अनस्ट्रक्चर्ड डेटा, दोनों) में सेव किए गए डेटा के लिए BigQuery से क्वेरी करने के लिए, आपको एक बाहरी कनेक्शन बनाना होगा.

Cloud Resource कनेक्शन बनाने के लिए, Cloud Shell में यह कमांड चलाएं:

bq mk --connection --project_id=$PROJECT_ID --location=US --connection_type=CLOUD_RESOURCE my-conn

अपने कनेक्शन के लिए बनाया गया सर्विस खाता आईडी ढूंढें:

CONNECTION_SA=$(bq show --format=json --project_id=$PROJECT_ID --connection $PROJECT_ID.us.my-conn | jq -r '.serviceAccountId // .cloudResource.serviceAccountId')

सर्विस खाते को Vertex AI User और Storage Object Viewer की भूमिकाएं असाइन करें, ताकि वह Gemini मॉडल को कॉल कर सके और GCS डेटा पढ़ सके:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CONNECTION_SA" \
  --role="roles/aiplatform.user"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CONNECTION_SA" \
  --role="roles/storage.objectViewer"

ऑब्जेक्ट टेबल बनाना

अनस्ट्रक्चर्ड डेटा को ऐक्सेस करने के लिए, हम पिछले सेक्शन में बनाए गए बाहरी कनेक्शन my-conn का इस्तेमाल करेंगे. क्वेरी फ़ाइल बनाएं और bq query का इस्तेमाल करके ऑब्जेक्ट टेबल बनाएं:

cat <<'EOF' > create_object_table.sql
CREATE EXTERNAL TABLE `iceberg_object_ai.sample_images`
WITH CONNECTION `us.my-conn`
OPTIONS (
  object_metadata = 'SIMPLE',
  uris = ['gs://cloud-samples-data/vision/landmark/*']
);
EOF

bq query --use_legacy_sql=false < create_object_table.sql

ऑब्जेक्ट डेटा पर Gemini का इस्तेमाल करना

अब इमेज को डाउनलोड किए बिना उनका आकलन करने के लिए, Gemini का इस्तेमाल करके क्वेरी चलाएं!

bq query के ज़रिए, स्टैंडर्ड SQL का इस्तेमाल करके इमेज के लिए क्वेरी करें:

cat <<EOF > query_images.sql
SELECT
  uri,
  image_analysis.description
FROM (
  SELECT
    uri,
    AI.GENERATE(
      (
        'Identify what is happening in the image.',
        ref
      ),
      connection_id => 'us.my-conn',
      endpoint => 'gemini-2.5-flash-lite',
      output_schema => 'event STRING, severity STRING, description STRING'
    ) AS image_analysis
  FROM
    iceberg_object_ai.sample_images
);
EOF

bq query --use_legacy_sql=false < query_images.sql

आउटपुट का सैंपल:

+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                           uri                            |                                                                                                                                                                                                                             description                                                                                                                                                                                                                             |
+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| gs://cloud-samples-data/vision/landmark/eiffel_tower.jpg | The Eiffel Tower stands tall against a cloudy sky, overlooking the Seine River in Paris. Boats are docked along the riverbank, and trees line the opposite shore, with bridges and buildings visible in the distance.                                                                                                                                                                                                                                               |
| gs://cloud-samples-data/vision/landmark/pofa.jpg         | A wide shot shows the Palace of Fine Arts, a monumental structure in San Francisco, California. The building features a large rotunda with a dome, surrounded by colonnades. In front of the rotunda is a lagoon. Several people are walking around the grounds. The sky is blue with a few scattered clouds.                                                                                                                                                       |
| gs://cloud-samples-data/vision/landmark/st_basils.jpeg   | A monument stands in front of Saint Basil's Cathedral in Moscow under a bright blue sky with scattered white clouds. The cathedral features distinctive onion domes in various colors and patterns, including red, blue and white stripes, green and beige stripes, and red and blue diamonds. A large green tree partially obscures the left side of the cathedral. People are visible in the foreground near the base of the monument and the cathedral entrance. |
+----------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

ObjectRef को सीधे तौर पर एक्सप्लोर करना: भावनाओं का विश्लेषण

ऑब्जेक्ट टेबल, फ़ाइल रेफ़रंस को अपने-आप मैनेज करती हैं. हालांकि, सिंगल फ़ाइलों पर तुरंत विश्लेषण करने के लिए, BigQuery ऑब्जेक्ट रेफ़रंस का इस्तेमाल करके, इन ऑब्जेक्ट के साथ सीधे इंटरैक्ट किया जा सकता है.

उदाहरण के लिए, अपने GCS बकेट में सेव की गई किसी छोटी टेक्स्ट फ़ाइल का इस्तेमाल किया जा सकता है. इसके लिए, पहले बनाया गया $DEPS_BUCKET वैरिएबल इस्तेमाल करें. इसके बाद, bq query के साथ OBJ.MAKE_REF का इस्तेमाल करके, उसका विश्लेषण करें.

सबसे पहले, एक छोटी टेक्स्ट फ़ाइल बनाएं और उसे अपने बकेट में अपलोड करें:

cat <<'EOF' > review.txt
This product is fantastic! It exceeded my expectations. The quality is top-notch. I highly recommend it to everyone!
EOF

gcloud storage cp review.txt gs://${DEPS_BUCKET}/review.txt

अब स्टैंडर्ड SQL में OBJ.MAKE_REF का इस्तेमाल करके, फ़ाइल के लिए क्वेरी करें:

cat <<EOF > sentiment_analysis.sql
SELECT
  AI.GENERATE(
    (
      'Analyze the sentiment of this text file. Is it positive, negative, or neutral? Explain why.',
      OBJ.MAKE_REF('gs://${DEPS_BUCKET}/review.txt', 'us.my-conn')
    ),
    connection_id => 'us.my-conn',
    endpoint => 'gemini-2.5-flash-lite'
  ).result AS ml_generate_text_result;
EOF

bq query --use_legacy_sql=false < sentiment_analysis.sql

आउटपुट का सैंपल:

+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|                                                                                 ml_generate_text_result                                                                                  |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| This text file has a **strongly positive** sentiment.                                                                                                                                    |
|                                                                                                                                                                                          |
| Here's why:                                                                                                                                                                              |
|                                                                                                                                                                                          |
| *   **Positive Keywords:** The text is filled with unequivocally positive words and phrases:                                                                                             |
|     *   "fantastic"                                                                                                                                                                      |
|     *   "exceeded my expectations"                                                                                                                                                       |
|     *   "top-notch"                                                                                                                                                                      |
|     *   "highly recommend"                                                                                                                                                               |
|                                                                                                                                                                                          |
| *   **Enthusiastic Language:** The use of exclamation marks ("!") further amplifies the positive tone, indicating excitement and strong approval.                                        |
|                                                                                                                                                                                          |
| *   **Lack of Negative or Neutral Elements:** There are no words, phrases, or implications that suggest any dissatisfaction, criticism, or even indifference.                            |
|                                                                                                                                                                                          |
| In summary, the author's language is enthusiastic and uses multiple strong positive descriptors, leaving no room for doubt that their opinion of the product is overwhelmingly positive. |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

8. व्यवस्थित करें

अपने Google Cloud खाते पर लगातार लगने वाले शुल्क से बचने के लिए, इस कोडलैब के दौरान बनाए गए संसाधन मिटाएं.

डेटासेट और कनेक्शन मिटाना

अपने डेटासेट और कनेक्शन मिटाने के लिए, Cloud Shell में यह कमांड चलाएं:

bq rm -r -f --location=$REGION iceberg_ai
bq rm -r -f --location=US iceberg_object_ai
bq rm --connection $PROJECT_ID.US.my-conn

GCS बकेट और लोकल फ़ाइलें मिटाना

GCS बकेट और लोकल फ़ाइलें मिटाएं:

# Delete GCS buckets
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud storage rm -r gs://dataproc-temp-${REGION}-${PROJECT_NUMBER}-*
gcloud storage rm -r gs://dataproc-staging-${REGION}-${PROJECT_NUMBER}-*
gcloud storage rm -r gs://${DEPS_BUCKET}

# Delete local files
rm -f train_model.sql predict_fare.sql create_object_table.sql query_images.sql sentiment_analysis.sql test.py query.py history.py timetravel.py review.txt

अगर आपने यह लैब सिर्फ़ इस प्रोजेक्ट के लिए बनाई है, तो इसे भी मिटाया जा सकता है.

9. बधाई हो

बधाई हो! आपने Apache Iceberg, BigLake, और BigQuery AI का इस्तेमाल करके, यूनिफ़ाइड डेटा लेकहाउस बना लिया है!

आपको क्या सीखने को मिला

• Apache Iceberg के सार्वजनिक REST कैटलॉग से कनेक्ट करना और उनके लिए क्वेरी करना.
• डेटासेट के वर्शन की ऑडिटिंग के लिए, Iceberg में टाइम ट्रैवल की सुविधा का इस्तेमाल करना.
• स्ट्रक्चर्ड डेटा पर BigQuery ML मॉडल को ट्रेन करना.
• ऑब्जेक्ट टेबल और ObjectRef का इस्तेमाल करके, अनस्ट्रक्चर्ड डेटा (इमेज) को कनेक्ट करना.
• इमेज का विश्लेषण करने के लिए, BigQuery SQL में सीधे Gemini का इस्तेमाल करना.

रेफ़रंस के लिए दस्तावेज़

• BigLake की खास जानकारी
• BigQuery ML की जनरेटिव एआई सुविधा
• Apache Iceberg की वेबसाइट