एआई की मदद से काम करने वाले BigQuery DataFrames पैकेज का इस्तेमाल करके, स्ट्रक्चर्ड और अनस्ट्रक्चर्ड डेटा से अहम जानकारी पाएं

1. खास जानकारी

इस लैब में, आपको BigQuery Studio में Python नोटबुक से BigQuery डेटाफ़्रेम का इस्तेमाल करना होगा. इससे, Python का इस्तेमाल करके डेटा से अहम जानकारी हासिल की जा सकेगी. बिना स्ट्रक्चर वाले टेक्स्ट डेटा का विश्लेषण करने और उसे विज़ुअलाइज़ करने के लिए, Google के जनरेटिव एआई का इस्तेमाल करें.

आपको सार्वजनिक तौर पर उपलब्ध, ग्राहकों की शिकायतों के डेटाबेस को अलग-अलग कैटगरी में बांटने और उसकी खास जानकारी देने के लिए, Python नोटबुक बनानी होगी. इसे किसी भी अनस्ट्रक्चर्ड टेक्स्ट डेटा पर काम करने के लिए अडैप्ट किया जा सकता है.

मकसद

इस लैब में, आपको ये काम करने का तरीका पता चलेगा:

  • BigQuery Studio में Python नोटबुक चालू करना और उनका इस्तेमाल करना
  • BigQuery DataFrames पैकेज का इस्तेमाल करके, BigQuery से कनेक्ट करना
  • BigQuery ML का इस्तेमाल करके, बिना स्ट्रक्चर वाले टेक्स्ट डेटा से एम्बेडिंग बनाएं. साथ ही, Vertex AI में टेक्स्ट एम्बेडिंग एंडपॉइंट से कनेक्ट करें
  • BigQuery ML का इस्तेमाल करके क्लस्टर एम्बेड करना
  • BigQuery ML की मदद से, एलएलएम का इस्तेमाल करके क्लस्टर की खास जानकारी पाना

2. ज़रूरी शर्तें

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

शुरू करने से पहले

इस कोडलैब में दिए गए निर्देशों का पालन करने के लिए, आपके पास BigQuery Studio की सुविधा वाला Google Cloud प्रोजेक्ट और उससे जुड़ा बिलिंग खाता होना चाहिए.

  1. Google Cloud Console में, प्रोजेक्ट चुनने वाले पेज पर, Google Cloud प्रोजेक्ट चुनें या बनाएं
  2. पक्का करें कि आपके Google Cloud प्रोजेक्ट के लिए बिलिंग की सुविधा चालू हो. किसी प्रोजेक्ट के लिए बिलिंग की सुविधा चालू है या नहीं, यह देखने का तरीका जानें
  3. एसेट मैनेजमेंट के लिए BigQuery Studio चालू करने के लिए, दिए गए निर्देशों का पालन करें.

BigQuery Studio को तैयार करना

कोई खाली नोटबुक बनाएं और उसे किसी रनटाइम से कनेक्ट करें.

  1. Google Cloud Console में, BigQuery Studio पर जाएं.
  2. + बटन के बगल में मौजूद ▼ पर क्लिक करें.
  3. Python नोटबुक चुनें.
  4. टेंप्लेट सिलेक्टर बंद करें.
  5. नई कोड सेल बनाने के लिए, + कोड चुनें.
  6. कोड सेल से, BigQuery DataFrames पैकेज का नया वर्शन इंस्टॉल करें.इसके लिए, यह कमांड टाइप करें.
    %pip install --upgrade bigframes --quiet
    कोड सेल को चलाने के लिए, 🞂 बटन पर क्लिक करें या Shift + Enter दबाएं.

3. सार्वजनिक डेटासेट को पढ़ना

किसी नई कोड सेल में नीचे दी गई कोड चलाकर, BigQuery DataFrames पैकेज को शुरू करें:

import bigframes.pandas as bpd

bpd.options.bigquery.ordering_mode = "partial"

ध्यान दें: इस ट्यूटोरियल में, हम एक्सपेरिमेंट के तौर पर उपलब्ध "कुछ हिस्से को क्रम से लगाने वाले मोड" का इस्तेमाल करते हैं. इससे, pandas जैसे फ़िल्टर का इस्तेमाल करके ज़्यादा असरदार क्वेरी की जा सकती हैं. ऐसा हो सकता है कि pandas की कुछ सुविधाएं काम न करें. इन सुविधाओं के लिए, डेटा को क्रम से लगाना या इंडेक्स करना ज़रूरी होता है.

उपभोक्ता की शिकायत का डेटाबेस

उपभोक्ता की शिकायत का डेटाबेस, Google Cloud के सार्वजनिक डेटासेट प्रोग्राम की मदद से BigQuery पर उपलब्ध कराया जाता है. यह उपभोक्ता के वित्तीय प्रॉडक्ट और सेवाओं के बारे में की गई शिकायतों का कलेक्शन है. यह डेटा, अमेरिका के कंज्यूमर फ़ाइनेंशियल प्रोटेक्शन ब्यूरो इकट्ठा करता है.

उपभोक्ता शिकायत डेटाबेस का विश्लेषण करने के लिए, BigQuery में bigquery-public-data.cfbp_complaints.complaint_database टेबल पर क्वेरी करें. क्वेरी स्ट्रिंग या टेबल आईडी से DataFrame बनाने के लिए, bigframes.pandas.read_gbq() तरीके का इस्तेमाल करें.

"feedback" नाम का डेटाफ़्रेम बनाने के लिए, नई कोड सेल में नीचे दिए गए कोड को चलाएं:

feedback = bpd.read_gbq(
    "bigquery-public-data.cfpb_complaints.complaint_database"
)

DataFrame के बारे में बुनियादी जानकारी

डेटा का एक छोटा सैंपल डाउनलोड करने के लिए, DataFrame.peek() तरीके का इस्तेमाल करें.

इस सेल को चलाएं:

feedback.peek()

अनुमानित आउटपुट:

  date_received                  product ... timely_response  consumer_disputed complaint_id  
0    2014-03-05  Bank account or service ...            True              False       743665   
1    2014-01-21  Bank account or service ...            True              False       678608   
2    2020-12-31          Debt collection ...            True               <NA>      4041190   
3    2014-02-12          Debt collection ...            True              False       714350   
4    2015-02-23          Debt collection ...            True              False      1251358

ध्यान दें: head() के लिए क्रम से लगाने की ज़रूरत होती है. साथ ही, अगर आपको डेटा का सैंपल विज़ुअलाइज़ करना है, तो आम तौर पर peek() से बेहतर परफ़ॉर्म नहीं करता.

pandas की तरह ही, सभी उपलब्ध कॉलम और उनके डेटा टाइप देखने के लिए, DataFrame.dtypes प्रॉपर्टी का इस्तेमाल करें. इन्हें pandas के साथ काम करने वाले तरीके से दिखाया जाता है.

इस सेल को चलाएं:

feedback.dtypes

अनुमानित आउटपुट:

date_received                   date32[day][pyarrow]
product                              string[pyarrow]
subproduct                           string[pyarrow]
issue                                string[pyarrow]
subissue                             string[pyarrow]
consumer_complaint_narrative         string[pyarrow]
company_public_response              string[pyarrow]
company_name                         string[pyarrow]
state                                string[pyarrow]
zip_code                             string[pyarrow]
tags                                 string[pyarrow]
consumer_consent_provided            string[pyarrow]
submitted_via                        string[pyarrow]
date_sent_to_company            date32[day][pyarrow]
company_response_to_consumer         string[pyarrow]
timely_response                              boolean
consumer_disputed                            boolean
complaint_id                         string[pyarrow]
dtype: object

DataFrame.describe() तरीका, DataFrame से कुछ बुनियादी आंकड़ों के बारे में क्वेरी करता है. इस DataFrame में कोई अंकों वाला कॉलम नहीं है. इसलिए, यह नॉन-नल वैल्यू की संख्या और अलग-अलग वैल्यू की संख्या की खास जानकारी दिखाता है.

इस सेल को चलाएं:

# Exclude some of the larger columns to make the query more efficient.
feedback.drop(columns=[
  "consumer_complaint_narrative",
  "company_public_response",
  "company_response_to_consumer",
]).describe()

अनुमानित आउटपुट:

         product  subproduct    issue  subissue  company_name    state ... timely_response  consumer_disputed  complaint_id
count    3458906     3223615  3458906   2759004       3458906  3417792 ...         3458906             768399       3458906
nunique       18          76      165       221          6694       63 ...               2                  2       3458906

4. डेटा एक्सप्लोर करना

असल शिकायतों को देखने से पहले, डेटा को विज़ुअलाइज़ करने के लिए, DataFrame पर pandas जैसे तरीकों का इस्तेमाल करें.

DataFrame को विज़ुअलाइज़ करना

विज़ुअलाइज़ेशन के लिए, पहले से मौजूद कई तरीके हैं. जैसे, DataFrame.plot.hist(). इस डेटाफ़्रेम में ज़्यादातर स्ट्रिंग और बूलियन डेटा होता है. इसलिए, अलग-अलग कॉलम के बारे में ज़्यादा जानने के लिए, पहले कुछ एग्रीगेशन किए जा सकते हैं.

देखें कि हर राज्य से कितनी शिकायतें मिली हैं.

complaints_by_state = (
  feedback.groupby(
    "state", as_index=False,
  ).size()
  .rename(columns={"size": "total_complaints"})
  .sort_values(by="total_complaints", ascending=False)
)

DataFrame.to_pandas() तरीके का इस्तेमाल करके, इसे pandas DataFrame में बदलें.

complaints_pd = complaints_by_state.head(10).to_pandas()

डाउनलोड किए गए इस DataFrame पर, Pandas के विज़ुअलाइज़ेशन के तरीकों का इस्तेमाल करें.

complaints_pd.plot.bar(x="state", y="total_complaints")

बार चार्ट, जिसमें कैलिफ़ोर्निया को सबसे ज़्यादा शिकायतों वाले राज्य के तौर पर दिखाया गया है

अन्य डेटासेट से जॉइन करना

पहले, हर राज्य के हिसाब से शिकायतों को देखा जाता था. हालांकि, इससे अहम जानकारी नहीं मिलती थी. कुछ राज्यों की आबादी, दूसरे राज्यों की तुलना में ज़्यादा होती है. जनसंख्या के डेटासेट से जॉइन करें. जैसे, अमेरिका के सेंसस ब्यूरो का अमेरिकन कम्यूनिटी सर्वे और bigquery-public-data.geo_us_boundaries.states टेबल.

us_states = bpd.read_gbq("bigquery-public-data.geo_us_boundaries.states")
us_survey = bpd.read_gbq("bigquery-public-data.census_bureau_acs.state_2020_5yr")

# Ensure there are leading 0s on GEOIDs for consistency across tables.
us_states = us_states.assign(
    geo_id=us_states["geo_id"].str.pad(2, fillchar="0")
)

us_survey = us_survey.assign(
    geo_id=us_survey["geo_id"].str.pad(2, fillchar="0")
)

अमेरिकन कम्यूनिटी सर्वे, राज्यों की पहचान GEOID से करता है. राज्य के नाम के दो अक्षरों वाले कोड के हिसाब से जनसंख्या पाने के लिए, राज्यों की टेबल से जॉइन करें.

pops = us_states.set_index("geo_id")[["state"]].join(
  us_survey.set_index("geo_id")[["total_pop"]]
)

अब, शिकायतों की संख्या के साथ जनसंख्या की तुलना करने के लिए, इसे शिकायतों के डेटाबेस से जोड़ें.

complaints_and_pops = complaints_by_state.set_index("state").join(
    pops.set_index("state")
)

राज्य की आबादी की तुलना शिकायतों की संख्या से करने के लिए, स्कैटर प्लॉट बनाएं.

(
  complaints_and_pops
  .to_pandas()
  .plot.scatter(x="total_pop", y="total_complaints")
)

शिकायतों की संख्या और जनसंख्या की तुलना करने वाला स्कैटर प्लॉट

शिकायतों की संख्या की तुलना जनसंख्या से करने पर, कुछ राज्यों के आंकड़े अलग दिखते हैं. इनकी पहचान करने के लिए, पाठक को पॉइंट लेबल के साथ प्लॉट करने का अभ्यास करना होगा. इसी तरह, इसकी कुछ वजहें बताएं कि ऐसा क्यों हो सकता है. जैसे, अलग-अलग डेमोग्राफ़िक्स, वित्तीय सेवाएं देने वाली कंपनियों की अलग-अलग संख्या वगैरह. इसके बाद, इनकी जांच करें.

5. एम्बेड की गिनती करना

अक्सर, अहम जानकारी टेक्स्ट, ऑडियो या इमेज जैसे अनस्ट्रक्चर्ड डेटा में छिपी होती है. इस उदाहरण में, शिकायतों के डेटाबेस में मौजूद ज़्यादातर काम की जानकारी, शिकायत के टेक्स्ट कॉन्टेंट में शामिल होती है.

एआई और सेंटिमेंट विश्लेषण, "बैग ऑफ़ वर्ड", और word2vec जैसी पारंपरिक तकनीकों से, आंकड़ों से जुड़ी कुछ जानकारी को अनस्ट्रक्चर्ड डेटा से निकाला जा सकता है. हाल ही में, एलएलएम से मिलते-जुलते "वेक्टर एम्बेडिंग" मॉडल, टेक्स्ट की सेमैटिक जानकारी दिखाने वाले फ़्लोटिंग पॉइंट नंबर का क्रम बना सकते हैं.

डेटाबेस का सबसेट चुनना

वेक्टर एम्बेडिंग मॉडल चलाने पर, अन्य ऑपरेशन के मुकाबले ज़्यादा संसाधनों का इस्तेमाल होता है. खर्च और कोटा से जुड़ी समस्याओं को कम करने के लिए, इस ट्यूटोरियल के बाकी हिस्से के लिए डेटा का सबसेट चुनें.

import bigframes.pandas as bpd

bpd.options.bigquery.ordering_mode = "partial"

feedback = bpd.read_gbq(
    "bigquery-public-data.cfpb_complaints.complaint_database"
)

# Note: if not using ordering_mode = "partial", you must specify these in read_gbq
# for these to affect query efficiency.
# feedback = bpd.read_gbq(
#    "bigquery-public-data.cfpb_complaints.complaint_database",
#     columns=["consumer_complaint_narrative"],
#     filters= [
#         ("consumer_complaint_narrative", "!=", ""),
#         ("date_received", "==", "2022-12-01")])

feedback.shape

पूरे डेटाबेस में करीब 35 लाख लाइनें हैं (feedback.shape से देखें), जबकि 01-12-2022 को करीब 1,000 शिकायतें सबमिट की गई हैं.

सिर्फ़ 01-12-2022 का डेटा और सिर्फ़ consumer_complaint_narrative कॉलम चुनें.

import datetime

feedback = feedback[
    # Filter rows by passing in a boolean Series.
    (feedback["date_received"] == datetime.date(2022, 12, 1))
    & ~(feedback["date_received"].isnull())
    & ~(feedback["consumer_complaint_narrative"].isnull())
    & (feedback["consumer_complaint_narrative"] != "")
    & (feedback["state"] == "CA")

    # Uncomment the following if using free credits for a workshop.
    # Billing accounts with free credits have limited Vertex AI quota.
    # & (feedback["product"] == "Mortgage")
][
    # Filter columns by passing in a list of strings.
    ["consumer_complaint_narrative"]
]

feedback.shape

pandas के drop_duplicates तरीके के लिए, पंक्तियों को क्रम से लगाना ज़रूरी है, क्योंकि यह मैच करने वाली पहली या आखिरी पंक्ति को चुनने और उससे जुड़े इंडेक्स को बनाए रखने की कोशिश करता है.

इसके बजाय, पंक्तियों की डुप्लीकेट कॉपी हटाने के लिए, groupby तरीके को कॉल करके एग्रीगेट करें.

feedback = (
  feedback.groupby("consumer_complaint_narrative", as_index=False)
  .size()
)[["consumer_complaint_narrative"]]

feedback.shape

एम्बेड जनरेट करना

BigQuery DataFrames, TextEmbeddingGenerator क्लास की मदद से एम्बेडिंग वैक्टर जनरेट करता है. यह BigQuery ML में ML.GENERATE_EMBEDDING तरीके पर आधारित है. यह Vertex AI के टेक्स्ट एम्बेडिंग मॉडल को कॉल करता है.

from bigframes.ml.llm import TextEmbeddingGenerator

embedding_model = TextEmbeddingGenerator(
    model_name="text-embedding-004"
)
feedback_embeddings = embedding_model.predict(feedback)

देखें कि एम्बेडिंग कैसी दिखती हैं. ये वेक्टर, टेक्स्ट के सेमैनटिक मतलब को दिखाते हैं, जैसा कि टेक्स्ट एम्बेडिंग मॉडल समझता है.

feedback_embeddings.peek()

अनुमानित आउटपुट:

                        ml_generate_embedding_result  \
0  [ 7.36380890e-02  2.11779331e-03  2.54309829e-...   
1  [-1.10935252e-02 -5.53950183e-02  2.01338865e-...   
2  [-7.85628427e-03 -5.39347418e-02  4.51385677e-...   
3  [ 0.02013054 -0.0224789  -0.00164843  0.011354...   
4  [-1.51684484e-03 -5.02693094e-03  1.72322839e-...

इन वैक्टर में कई डाइमेंशन होते हैं. एम्बेड किए गए एक वेक्टर पर एक नज़र डालें:

feedback_embeddings["ml_generate_embedding_result"].peek().iloc[0]

एम्बेड जनरेशन, "कुछ हद तक सफल" समझौते के तहत काम करता है. इसका मतलब है कि कुछ पंक्तियों में गड़बड़ियां हो सकती हैं और वे एम्बेड नहीं जनरेट कर सकतीं. गड़बड़ी के मैसेज, 'ml_generate_embedding_status' कॉलम में दिखते हैं. खाली होने का मतलब है कि कोई गड़बड़ी नहीं है.

एम्बेड को फ़िल्टर करके, सिर्फ़ उन लाइनों को शामिल करें जिनमें कोई गड़बड़ी नहीं हुई है.

mask = feedback_embeddings["ml_generate_embedding_status"] == ""
valid_embeddings = feedback_embeddings[mask]
valid_embeddings.shape

6. टेक्स्ट एम्बेड का इस्तेमाल करके क्लस्टर बनाना

अब, k-means का इस्तेमाल करके एम्बेड को क्लस्टर करें. इस डेमो के लिए, अपनी पसंद के मुताबिक ग्रुप (जिन्हें सेंट्राइड भी कहा जाता है) का इस्तेमाल करें. प्रॉडक्शन क्वालिटी वाले समाधान में, सिल्हूट विधि जैसी तकनीक का इस्तेमाल करके सेंट्राइड की संख्या को ट्यून किया जाना चाहिए.

from bigframes.ml.cluster import KMeans

num_clusters = 5
cluster_model = KMeans(n_clusters=num_clusters)
cluster_model.fit(valid_embeddings["ml_generate_embedding_result"])

clusters = cluster_model.predict(valid_embeddings)
clusters.peek()

एम्बेड करने में हुई गड़बड़ियों को हटाएं.

mask = clusters["ml_generate_embedding_status"] == ""
clusters = clusters[mask]

हर सेंट्राइड के हिसाब से, टिप्पणियों का डिस्ट्रिब्यूशन देखें.

clusters.groupby("CENTROID_ID").size()

7. क्लस्टर की खास जानकारी

हर सेंट्राइड से जुड़ी कुछ टिप्पणियां करें और Gemini से शिकायतों की खास जानकारी मांगें. प्रॉम्प्ट इंजीनियरिंग एक नया क्षेत्र है. हालांकि, इंटरनेट पर इसके अच्छे उदाहरण मौजूद हैं, जैसे कि https://www.promptingguide.ai/.

from bigframes.ml.llm import GeminiTextGenerator

preamble = "What is the main concern in this list of user complaints:"
suffix = "Write the main issue using a formal tone."

# Now let's sample the raw comments and get the LLM to summarize them.
prompts = []
for centroid_id in range(1, num_clusters + 1):
  cluster = clusters[clusters["CENTROID_ID"] == centroid_id]
  comments = "\n".join(["- {0}".format(x) for x in cluster.content.peek(40)])
  prompts.append("{}:\n{}\n{}".format(preamble, comments, suffix))

prompt_df = bpd.DataFrame(prompts)
gemini = GeminiTextGenerator(model_name="gemini-1.5-flash-001")
issues = gemini.predict(X=prompt_df, temperature=0.0)
issues.peek()

खास जानकारी से रिपोर्ट बनाने के लिए, Gemini का इस्तेमाल करें.

from IPython.display import display, Markdown

prompt = "Turn this list of issues into a short, concise report:"
for value in issues["ml_generate_text_llm_result"]:
  prompt += "- {}".format(value)
prompt += "Using a formal tone, write a markdown text format report."

summary_df = bpd.DataFrame(([prompt]))
summary = gemini.predict(X=summary_df, temperature=0.0)

report = (summary["ml_generate_text_llm_result"].values[0])
display(Markdown(report))

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

अगर आपने इस ट्यूटोरियल के लिए नया Google Cloud प्रोजेक्ट बनाया है, तो टेबल या बनाए गए अन्य संसाधनों के लिए अतिरिक्त शुल्क से बचने के लिए, इसे मिटाया जा सकता है.

9. बधाई हो!

आपने BigQuery डेटाफ़्रेम का इस्तेमाल करके, स्ट्रक्चर्ड और अनस्ट्रक्चर्ड डेटा का विश्लेषण किया है. इस दौरान, आपने Google Cloud के सार्वजनिक डेटासेट, BigQuery Studio में Python नोटबुक, BigQuery ML, Vertex AI, और BigQuery Studio की नैचुरल लैंग्वेज से Python की सुविधाओं के बारे में जाना है. बहुत बढ़िया!

अगले चरण