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

1. परिचय

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

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

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

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

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

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

अनुमानित लागत और अवधि

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

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, और Gemini Enterprise Agent Engine के लिए ज़रूरी एपीआई चालू करने के लिए, यह कमांड चलाएं:

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 Public Catalog से कनेक्ट करना

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

Managed Apache Spark Batch CLI की मदद से Spark SQL चलाना

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

  1. Lakehouse REST कैटलॉग की प्रॉपर्टी तय करें, ताकि उन्हें दोहराने से बचा जा सके.इस कॉन्फ़िगरेशन से Spark को यह जानकारी मिलती है:
    • iceberg-spark-runtime और iceberg-gcp-bundle लाइब्रेरी का इस्तेमाल करने के लिए.
    • Lakehouse REST Catalog endpoint का इस्तेमाल करके, 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. स्ट्रक्चर्ड आइसबर्ग डेटा को क्वेरी करना

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

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

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 पर फ़िल्टर करती है. आइसबर्ग की मदद से, इंजन को पिछले सालों के डेटा को पूरी तरह से स्कैन करने की ज़रूरत नहीं पड़ती.
  • इंजन की सुविधा: इसे 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 कैटलॉग सिर्फ़ पढ़ने के लिए होता है. इसलिए, हम BigQuery का इस्तेमाल करके, अपने वर्कस्पेस में किसी मॉडल को ट्रेन कर सकते हैं. इसके लिए, हमें पब्लिक टेबल से डेटा पढ़ना होगा.

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

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

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

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

अब सार्वजनिक Lakehouse 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

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

मॉडल को ट्रेन करने के बाद, 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. लेकहाउस के साथ अनस्ट्रक्चर्ड एआई

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

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

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

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

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

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

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

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

Cloud रिसोर्स कनेक्शन बनाने के लिए, 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')

सेवा खाते को Gemini Enterprise Agent Engine 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 का इस्तेमाल करके, स्टैंडर्ड एसक्यूएल की मदद से इमेज के लिए क्वेरी करें:

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

अब स्टैंडर्ड एसक्यूएल में 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, Lakehouse, और BigQuery AI का इस्तेमाल करके, यूनिफ़ाइड डेटा लेकहाउस को सफलतापूर्वक बनाया है!

आपने क्या सीखा

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

रेफ़रंस दस्तावेज़