ज़्यादा तेज़ी से एआई क्वेरी करने के लिए, AlloyDB AI फ़ंक्शन के साथ TypeSafe AI के Jev मॉडल का इस्तेमाल करना

1. परिचय

इस कोडलैब में, AlloyDB के नेटिव एआई फ़ंक्शन (ai.if, ai.analyze_sentiment, और ml_predict_row) का इस्तेमाल करके, TypeSafe AI के Jev मॉडल को AlloyDB AI से कनेक्ट करने का तरीका बताया गया है. इससे, Jev मॉडल का इस्तेमाल करके, AlloyDB में मौजूद अपने ऑपरेशनल डेटा पर सीधे तौर पर बैच में अनुमान लगाया जा सकता है. इसके लिए, आपको न तो डेटा को ट्रांसफ़र करने की ज़रूरत होगी और न ही ऐप्लिकेशन-साइड पर जटिल कोड लिखने की ज़रूरत होगी.

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

• Private Service Access (पीएसए) और AlloyDB for PostgreSQL क्लस्टर और प्राइमरी इंस्टेंस को प्रोविज़न करना
• Cloud Shell और इंटरनल कनेक्टिविटी की अनुमति देने वाला वीपीसी फ़ायरवॉल नियम बनाएं
• gcloud alloydb clusters import का इस्तेमाल करके, ई-कॉमर्स का सैंपल डेटासेट लोड करें
• Google Secret Manager और AlloyDB के google_ml_integration एक्सटेंशन को चालू करें
• Secret Manager में, TypeSafe AI API पासकोड को सेव करना और उसका ऐक्सेस देना
• Jev के noul (बूलियन) और choice (भावना) प्रिमिटिव के लिए, PL/pgSQL इनपुट और आउटपुट ट्रांसफ़ॉर्मेशन फ़ंक्शन बनाएं
• AlloyDB में कस्टम jev-model मॉडल एंडपॉइंट रजिस्टर करना
• एसक्यूएल में सीधे तौर पर स्केलर और ऐरे-बैच वाली सेमैंटिक क्वेरी (ai.if और ai.analyze_sentiment) चलाना
• ai.analyze_sentiment का इस्तेमाल करके, खरीदारों की प्रॉडक्ट के बारे में की गई समीक्षाओं के आधार पर, उनकी भावनाओं का पता लगाने के लिए क्वेरी करना
• (बोनस) सामान्य एंडपॉइंट (jev-systemone) रजिस्टर करें और Jev के score प्रिमिटिव का इस्तेमाल करके, ग्राहक संतुष्टि की लगातार जांच करें

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

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

लागत और अवधि: इस कोडलैब में दिए गए चरणों को पूरा करने में करीब 45 से 60 मिनट लगेंगे. AlloyDB इंस्टेंस को चालू करने में करीब 6 से 10 मिनट लगते हैं. अगर मुफ़्त में आज़माने की सुविधा वाले क्लस्टर का इस्तेमाल किया जाता है, तो Google Cloud संसाधनों पर कुल लागत 5 डॉलर से कम होनी चाहिए.

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

अपना Google क्लाउड प्रोजेक्ट चुनें

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

Cloud Shell शुरू करना

Google Cloud Console में सबसे ऊपर दाईं ओर मौजूद, Cloud Shell चालू करें पर क्लिक करें.

पुष्टि करें कि आपके Cloud Shell सेशन की पुष्टि हो गई है:

gcloud auth list

अपना प्रोजेक्ट आईडी और एनवायरमेंट वैरिएबल सेट करें:

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID

export REGION="us-west4"
export ADBCLUSTER="my-alloydb-cluster"
export ADBINSTANCE="my-alloydb-primary"

क्षेत्र चुनना: अपने आस-पास का ऐसा क्षेत्र चुनें जहां AlloyDB का इस्तेमाल किया जा सकता हो. उदाहरण के लिए, us-central1, us-east4 या us-west4.

ज़रूरी Google Cloud API चालू करना

Google Cloud की सभी ज़रूरी सेवा एपीआई चालू करने के लिए, यह निर्देश चलाएं:

gcloud services enable \
  alloydb.googleapis.com \
  servicenetworking.googleapis.com \
  secretmanager.googleapis.com \
  compute.googleapis.com

3. AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को प्रोविज़न करना

इस चरण में, आपको अपने वीपीसी नेटवर्क में प्राइवेट सर्विस ऐक्सेस की आईपी रेंज असाइन करनी होगी. साथ ही, प्राइवेट पियरिंग सेट अप करनी होगी. इसके अलावा, आपको अपने AlloyDB क्लस्टर और प्राइमरी इंस्टेंस को आउटबाउंड इंटरनेट ऐक्सेस देना होगा.

1. प्राइवेट सर्विस ऐक्सेस (पीएसए) के लिए आईपी रेंज बनाना

AlloyDB के लिए, आपके वर्चुअल प्राइवेट क्लाउड (वीपीसी) नेटवर्क में निजी आईपी पते की रेंज का ऐलोकेशन ज़रूरी है. मान लें कि default वीपीसी नेटवर्क का इस्तेमाल किया जा रहा है:

निजी आईपी पते की रेंज असाइन करें:

gcloud compute addresses create psa-range \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --description="VPC private service access" \
    --network=default

निजी वीपीसी पीयरिंग कनेक्शन बनाएं:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=psa-range \
    --network=default

2. AlloyDB क्लस्टर बनाना

शुरुआती postgres एडमिन उपयोगकर्ता के लिए, सुरक्षित डेटाबेस पासवर्ड जनरेट करें:

export PGPASSWORD="$(openssl rand -hex 8)@1aA"
echo "Your generated AlloyDB postgres password is: $PGPASSWORD"

AlloyDB को बिना किसी शुल्क आज़माने के लिए क्लस्टर बनाएं:

gcloud alloydb clusters create $ADBCLUSTER \
    --password=$PGPASSWORD \
    --network=default \
    --region=$REGION 

मुफ़्त में आज़माने की सुविधा बनाम स्टैंडर्ड: अगर आपने अपने प्रोजेक्ट के लिए, AlloyDB को 30 दिनों तक मुफ़्त में आज़माने की सुविधा का इस्तेमाल कर लिया है, तो --subscription-type=TRIAL की जगह --subscription-type=STANDARD का इस्तेमाल करें.

3. एआई फ़्लैग और आउटबाउंड कनेक्टिविटी की मदद से प्राइमरी इंस्टेंस बनाना

AlloyDB, आउटबाउंड एचटीटीपीएस के ज़रिए सीधे तौर पर TypeSafe AI के सुरक्षित SaaS एंडपॉइंट (https://api.typesafe.ai/v1/systemone) से कनेक्ट होता है. इसलिए, आपको --outbound-public-ip की जानकारी देनी होगी. इसके अलावा, एनवायरमेंट के लिए AlloyDB AI डेटाबेस फ़्लैग कॉन्फ़िगर करें:

gcloud alloydb instances create $ADBINSTANCE \
    --instance-type=PRIMARY \
    --cpu-count=2 \
    --region=$REGION \
    --cluster=$ADBCLUSTER \
    --outbound-public-ip \
    --ssl-mode=ALLOW_UNENCRYPTED_AND_ENCRYPTED \
    --database-flags=\
google_ml_integration.enable_model_support=on,\
google_ml_integration.enable_ai_query_engine=on,\
google_ml_integration.enable_ai_function_acceleration=on,\
google_ml_integration.enable_cost_optimized_ai_functions=on,\
parameterized_views.enabled=on,\
password.enforce_complexity=on,\
password.min_uppercase_letters=1,\
password.min_numerical_chars=1,\
password.min_pass_length=10

प्रोविज़निंग की अवधि: प्राइमरी इंस्टेंस बनाने में करीब 6 से 10 मिनट लगते हैं.

अगर आपको "अनुरोध पूरा करने के लिए, इस जगह पर ज़रूरी संसाधन उपलब्ध नहीं हैं" गड़बड़ी का मैसेज मिलता है, तो सीपीयू की संख्या बदलें. इसके अलावा, कोई दूसरा क्षेत्र (जैसे, us-east4 या us-central1) चुनें और क्लस्टर और इंस्टेंस को फिर से बनाएं.

4. ई-कॉमर्स का सैंपल डेटा लोड करना

सटीक सिमैंटिक क्वेरी की जांच करने के लिए, Cloud Storage से सीधे तौर पर ई-कॉमर्स का एक सैंपल डेटासेट इंपोर्ट करें. इसमें प्रॉडक्ट कैटलॉग और खरीदारों की समीक्षाएं शामिल हों:

gcloud alloydb clusters import $ADBCLUSTER \
    --region=$REGION \
    --project=$PROJECT_ID \
    --gcs-uri="gs://sample-data-and-media/ecomm-retail/ecom_generic.sql" \
    --sql \
    --database=postgres \
    --user=postgres

बैकग्राउंड में अपने-आप इंपोर्ट होने की सुविधा: क्लस्टर इंपोर्ट, AlloyDB कंट्रोल-प्लेन ऑपरेशन के तौर पर एसिंक्रोनस तरीके से चलता है. Cloud Shell में इसकी प्रोग्रेस को मॉनिटर किया जा सकता है. इसके अलावा, बैकग्राउंड में डेटा लोड होने के दौरान, अगले चरण में सीधे Secret Manager का सेटअप जारी रखा जा सकता है.

4. Secret Manager में TypeSafe AI API पासकोड सेव करना

AlloyDB का मॉडल एंडपॉइंट मैनेजमेंट, Google Secret Manager के साथ नेटिव तौर पर इंटिग्रेट होता है. इससे बाहरी एपीआई कॉल की पुष्टि की जा सकती है. इसके लिए, डेटाबेस कोड या कॉन्फ़िगरेशन लॉग में प्लेनटेक्स्ट क्रेडेंशियल दिखाने की ज़रूरत नहीं होती.

1. सीक्रेट बनाना

Cloud Shell में, typesafe-jev-api-key नाम का नया सीक्रेट बनाएं:

gcloud secrets create typesafe-jev-api-key \
  --replication-policy="automatic"

TypeSafe AI API पासकोड को सीक्रेट वर्शन के तौर पर जोड़ें:

echo -n "<YOUR_TYPESAFE_API_KEY>" | \
  gcloud secrets versions add typesafe-jev-api-key --data-file=-

2. AlloyDB सेवा एजेंट को ऐक्सेस देना

क्वेरी को लागू करने के दौरान, AlloyDB अपने प्रोजेक्ट सेवा एजेंट का इस्तेमाल करके सीक्रेट वापस पाता है. अपना प्रोजेक्ट नंबर ढूंढें और Secret Accessor की भूमिका असाइन करें:

PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
ALLOYDB_SA="service-${PROJECT_NUMBER}@gcp-sa-alloydb.iam.gserviceaccount.com"

gcloud secrets add-iam-policy-binding typesafe-jev-api-key \
  --member="serviceAccount:${ALLOYDB_SA}" \
  --role="roles/secretmanager.secretAccessor"

आपको आउटपुट में यह पुष्टि दिखेगी कि सेवा एजेंट को roles/secretmanager.secretAccessor मिल गया है.

5. AlloyDB Studio के ज़रिए AlloyDB से कनेक्ट करना और डेटाबेस एक्सटेंशन शुरू करना

स्थानीय क्लाइंट टूल या प्रॉक्सी टनल कॉन्फ़िगर किए बिना, सीधे अपने ब्राउज़र से AlloyDB डेटाबेस के साथ इंटरैक्ट करने के लिए, Google Cloud Console में AlloyDB Studio का इस्तेमाल करें.

1. AlloyDB Studio खोलें

1. Google Cloud Console में, AlloyDB for PostgreSQL > क्लस्टर पर जाएं.
2. अपने क्लस्टर (my-alloydb-cluster) पर क्लिक करें.
3. बाईं ओर मौजूद नेविगेशन मेन्यू में, AlloyDB Studio पर क्लिक करें.
4. डेटाबेस में पुष्टि करें:
   • डेटाबेस: postgres
   • उपयोगकर्ता: postgres
   • पासवर्ड: क्लस्टर बनाते समय जनरेट हुआ $PGPASSWORD डालें. उदाहरण के लिए, इसे देखने के लिए Cloud Shell में echo $PGPASSWORD चलाएं.
5. प्रमाणित करें पर क्लिक करें.

अब आप AlloyDB Studio के इंटरैक्टिव एसक्यूएल क्वेरी एडिटर में हैं.

2. डेटाबेस एक्सटेंशन और फ़्लैग चालू करना

AlloyDB Studio के क्वेरी एडिटर में, google_ml_integration एक्सटेंशन चालू करने और रनटाइम सेटिंग कॉन्फ़िगर करने के लिए, यहां दिए गए स्टेटमेंट चिपकाएं और चलाएं:

-- Enable the AlloyDB AI integration extension
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

-- Enable preview AI functions (ai.analyze_sentiment, ai.classify)
SET google_ml_integration.enable_preview_ai_functions = 'on';

-- Disable async batching for the session to use custom transform functions directly
SET google_ml_integration.enable_async_operation = 'off';

क्वेरी चलाने के लिए, चलाएं पर क्लिक करें.

अहम सेटिंग: कस्टम मॉडल एंडपॉइंट मैनेजमेंट बैच ट्रांसफ़ॉर्म का इस्तेमाल करते समय, google_ml_integration.enable_async_operation को off पर सेट करना ज़रूरी है. on होने पर, AlloyDB बैच को एक इंटरनल एसिंक रूटीन के ज़रिए रूट करता है. इसे सिर्फ़ Vertex AI के लिए ऑप्टिमाइज़ किया गया है.

3. AlloyDB MEM में सीक्रेट रजिस्टर करना

AlloyDB को बताएं कि आपकी TypeSafe AI API कुंजी कहां मिलेगी:

CALL google_ml.create_sm_secret(
    secret_id => 'jev_api_key',
    secret_path => 'projects/<YOUR_PROJECT_ID>/secrets/typesafe-jev-api-key/versions/latest'
);

6. एसक्यूएल ट्रांसफ़ॉर्मेशन फ़ंक्शन बनाना

TypeSafe AI का System One API, स्ट्रक्चर्ड JSON को स्वीकार करता है. इसमें अलग-अलग तरह की तर्क क्षमताएं होती हैं (noul बूलियन कंस्ट्रेंट के लिए, choice मल्टी-क्लास क्लासिफ़िकेशन के लिए).

AlloyDB का मॉडल एंडपॉइंट मैनेजमेंट, चार ट्रांसफ़ॉर्मेशन फ़ंक्शन (स्केलर इनपुट, स्केलर आउटपुट, बैच इनपुट, बैच आउटपुट) का इस्तेमाल करता है. इससे, स्टैंडर्ड PostgreSQL ai.* फ़ंक्शन सिग्नेचर को Jev REST API फ़ॉर्मैट में बदला जा सकता है.

1. स्केलर इनपुट ट्रांसफ़ॉर्म

सिंगल-रो ai.if और ai.analyze_sentiment कॉल को Jev अनुरोध पेलोड में बदलने के लिए, यह फ़ंक्शन जोड़ें:

CREATE OR REPLACE FUNCTION public.jev_model_input_transform(
    model_id VARCHAR(100),
    input_text TEXT,
    generation_config JSON,
    system_instruction TEXT
) RETURNS JSON
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    full_instruction TEXT;
    enum_json JSON;
    criteria_obj JSONB := '{}'::JSONB;
    elem TEXT;
    q_obj JSON;
BEGIN
    -- Combine optional system instructions with the input prompt
    IF system_instruction IS NOT NULL AND length(trim(system_instruction)) > 0 THEN
        full_instruction := system_instruction || E'\n\n' || input_text;
    ELSE
        full_instruction := input_text;
    END IF;

    -- Inspect generation_config to determine whether caller expects a multi-class choice or boolean
    enum_json := COALESCE(
        generation_config->'generationConfig'->'responseSchema'->'enum',
        generation_config->'responseSchema'->'enum'
    );

    IF enum_json IS NOT NULL AND json_typeof(enum_json) = 'array' THEN
        -- Multi-class classification (ai.analyze_sentiment) -> Jev choice primitive
        FOR elem IN SELECT json_array_elements_text(enum_json) LOOP
            criteria_obj := criteria_obj || jsonb_build_object(elem, 'Category: ' || elem);
        END LOOP;
        q_obj := json_build_object(
            'type', 'choice',
            'instructions', full_instruction,
            'criteria', criteria_obj::JSON
        );
    ELSE
        -- Boolean filtering (ai.if) -> Jev noul primitive
        q_obj := json_build_object(
            'type', 'noul',
            'instructions', full_instruction
        );
    END IF;

    RETURN json_build_object(
        'model', 'jev-latest',
        'state', COALESCE(generation_config->>'state', 'Evaluate the question accurately based on the provided text.'),
        'questions', json_build_object('q_1', q_obj)
    );
END;
$$;

2. स्केलर आउटपुट ट्रांसफ़ॉर्म

Jev के JSON रिस्पॉन्स को वापस PostgreSQL TEXT नतीजे में बदलने के लिए, फ़ंक्शन जोड़ें:

CREATE OR REPLACE FUNCTION public.jev_model_output_transform(
    model_id VARCHAR(100),
    response_json JSON
) RETURNS TEXT
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    q_ans JSON := response_json->'answers'->'q_1';
    ans_type TEXT := q_ans->>'type';
BEGIN
    IF ans_type = 'choice' THEN
        RETURN q_ans->>'choice';
    ELSIF ans_type = 'noul' THEN
        -- Convert probability score (0.00 to 1.00) to boolean text
        RETURN CASE WHEN (q_ans->>'noul')::FLOAT >= 0.50 THEN 'true' ELSE 'false' END;
    ELSE
        RAISE EXCEPTION 'Unexpected Jev response payload: %', response_json::TEXT;
    END IF;
END;
$$;

3. बैच इनपुट ट्रांसफ़ॉर्म

Jev, एक ही एचटीटीपी राउंड-ट्रिप में कई सवालों का एक साथ आकलन कर सकता है. इससे जनरेटिव एआई की परफ़ॉर्मेंस पर कोई असर नहीं पड़ता.

PostgreSQL prompts TEXT[] ऐरे को पैरलल q_1 .. q_N Jev सवालों में बदलने के लिए, बैच इनपुट ट्रांसफ़ॉर्म जोड़ें:

CREATE OR REPLACE FUNCTION public.jev_model_batch_input_transform(
    model_id VARCHAR(100),
    prompts TEXT[],
    generation_config JSON,
    system_instructions JSON
) RETURNS JSON
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    questions_obj JSONB := '{}'::JSONB;
    enum_json JSON;
    criteria_obj JSONB := '{}'::JSONB;
    elem TEXT;
    is_choice BOOLEAN := FALSE;
    i INT;
BEGIN
    enum_json := COALESCE(
        generation_config->'generationConfig'->'responseSchema'->'items'->'enum',
        generation_config->'generationConfig'->'responseSchema'->'enum',
        generation_config->'responseSchema'->'items'->'enum',
        generation_config->'responseSchema'->'enum'
    );

    IF enum_json IS NOT NULL AND json_typeof(enum_json) = 'array' THEN
        IF NOT (enum_json::JSONB = '["true", "false"]'::JSONB OR enum_json::JSONB = '["false", "true"]'::JSONB) THEN
            is_choice := TRUE;
            FOR elem IN SELECT json_array_elements_text(enum_json) LOOP
                criteria_obj := criteria_obj || jsonb_build_object(elem, 'Category: ' || elem);
            END LOOP;
        END IF;
    END IF;

    -- Construct parallel questions for every prompt in the array
    FOR i IN 1 .. COALESCE(array_length(prompts, 1), 0) LOOP
        IF is_choice THEN
            questions_obj := questions_obj || jsonb_build_object(
                'q_' || i::TEXT,
                jsonb_build_object(
                    'type', 'choice',
                    'instructions', prompts[i],
                    'criteria', criteria_obj
                )
            );
        ELSE
            questions_obj := questions_obj || jsonb_build_object(
                'q_' || i::TEXT,
                jsonb_build_object(
                    'type', 'noul',
                    'instructions', prompts[i]
                )
            );
        END IF;
    END LOOP;

    RETURN json_build_object(
        'model', 'jev-latest',
        'state', COALESCE(generation_config->>'state', 'Evaluate each question independently based on the record data.'),
        'questions', questions_obj::JSON
    );
END;
$$;

4. बैच आउटपुट ट्रांसफ़ॉर्म

जवाबों को सही 1..N ऐरे इंडेक्स के क्रम में निकालने के लिए, यह फ़ंक्शन जोड़ें:

CREATE OR REPLACE FUNCTION public.jev_model_batch_output_transform(
    model_id VARCHAR(100),
    response JSON
) RETURNS TEXT[]
LANGUAGE plpgsql IMMUTABLE AS $$
DECLARE
    results TEXT[] := ARRAY[]::TEXT[];
    answers JSON := response->'answers';
    i INT := 1;
    q_ans JSON;
    ans_type TEXT;
BEGIN
    LOOP
        q_ans := answers->('q_' || i::TEXT);
        EXIT WHEN q_ans IS NULL;
        ans_type := q_ans->>'type';
        IF ans_type = 'choice' THEN
            results := array_append(results, q_ans->>'choice');
        ELSE
            results := array_append(results, CASE WHEN (q_ans->>'noul')::FLOAT >= 0.50 THEN 'true' ELSE 'false' END);
        END IF;
        i := i + 1;
    END LOOP;
    RETURN results;
END;
$$;

7. AlloyDB में कस्टम मॉडल एंडपॉइंट रजिस्टर करना

अब ट्रांसफ़ॉर्मेशन फ़ंक्शन, सीक्रेट क्रेडेंशियल, और TypeSafe AI REST एंडपॉइंट को एक साथ jev-model नाम के रजिस्टर किए गए मॉडल में बाइंड करें.

1. jev-model रजिस्टर करें

AlloyDB Studio के क्वेरी एडिटर में, इसे चिपकाएं और चलाएं:

-- Drop previous registration if updating
DO $$
BEGIN
    IF EXISTS (SELECT 1 FROM google_ml.model_info_view WHERE model_id = 'jev-model') THEN
        CALL google_ml.drop_model('jev-model');
    END IF;
END $$;

-- Register custom LLM endpoint
CALL google_ml.create_model(
    model_id => 'jev-model',
    model_request_url => 'https://api.typesafe.ai/v1/systemone',
    model_provider => 'custom',
    model_type => 'llm',
    model_qualified_name => 'jev-latest',
    model_auth_type => 'secret_manager',
    model_auth_id => 'jev_api_key',
    model_in_transform_fn => 'jev_model_input_transform',
    model_out_transform_fn => 'jev_model_output_transform',
    model_batch_in_transform_fn => 'jev_model_batch_input_transform',
    model_batch_out_transform_fn => 'jev_model_batch_output_transform'
);

2. रजिस्ट्रेशन की पुष्टि करना

मॉडल रजिस्ट्री व्यू को क्वेरी करें, ताकि यह पक्का किया जा सके कि jev-model चालू है और इसे पहचाना जा रहा है:

SELECT model_id, model_type, model_provider, model_auth_type 
FROM google_ml.model_info_view 
WHERE model_id = 'jev-model';

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

 model_id | model_type | model_provider | model_auth_type 
----------+------------+----------------+-----------------
 jev-model  | llm        | custom         | secret_manager
(1 row)

8. जेव के ख़िलाफ़ टेस्ट क्वेरी चलाना

jev-model रजिस्टर होने के बाद, अब सीधे तौर पर स्टैंडर्ड PostgreSQL क्वेरी में सिमैंटिक ऑपरेशन किए जा सकते हैं.

1. टेस्ट स्केलर बूलियन फ़िल्टरिंग (ai.if)

ai.if का इस्तेमाल करके, किसी एक टेक्स्ट स्टेटमेंट का आकलन करें:

SELECT ai.if(
    prompt => 'Is the product "North Face Waterproof Gore-Tex Hiking Jacket ($249)" suitable for rainy outdoor conditions?',
    model_id => 'jev-model'
) AS is_suitable;

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

 is_suitable 
-------------
 true
(1 row)

2. स्केलर सेंटीमेंट ऐनलिसिस की जांच करें (ai.analyze_sentiment)

ग्राहक से मिले सुझाव, राय या शिकायत को कैटगरी के हिसाब से लेबल करें (positive, negative या neutral):

SET google_ml_integration.enable_preview_ai_functions = 'on';
SELECT ai.analyze_sentiment(
    input => 'The stitching on this jacket tore on the second day and the zipper jammed completely.',
    model_id => 'jev-model'
) AS sentiment;

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

 sentiment 
-----------
 negative
(1 row)

3. टेस्ट ऐरे-बैच किए गए बूलियन फ़िल्टरिंग

प्रॉम्प्ट की एक कैटगरी पास करके, एक ही क्वेरी में कई आइटम का आकलन करें:

SET google_ml_integration.enable_async_operation = 'off';
SELECT unnest(prompts) AS product_prompt,
       unnest(ai.if(prompts => prompts, model_id => 'jev-model')) AS is_cold_weather
FROM (
    SELECT ARRAY[
        'Is "Arctic Expedition Down Parka (-30F)" cold-weather winter outerwear?',
        'Is "Men''s Boardshorts Beach Swim Trunk" cold-weather winter outerwear?',
        'Is "Merino Wool Thermal Base Layer" cold-weather winter outerwear?'
    ] AS prompts
) b;

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

                             product_prompt                              | is_cold_weather 
-------------------------------------------------------------------------+-----------------
 Is "Arctic Expedition Down Parka (-30F)" cold-weather winter outerwear? | true
 Is "Men's Boardshorts Beach Swim Trunk" cold-weather winter outerwear?  | false
 Is "Merino Wool Thermal Base Layer" cold-weather winter outerwear?      | false
(3 rows)

4. ऐरे बैचिंग की मदद से टेबल क्वेरी टेस्ट करना

अब क्लस्टर प्रोविज़निंग के दौरान पहले लोड की गई ecomm.products टेबल से क्वेरी करें. इसके लिए, आइटम के बैच पर ai.if का इस्तेमाल करें. इससे यह पता चलेगा कि कैटलॉग में मौजूद कौनसे प्रॉडक्ट, ठंड के मौसम में पहने जाने वाले कपड़े हैं.

टेबल के डेटा पर ज़्यादा थ्रूपुट वाला सिमैंटिक फ़िल्टरिंग लागू करने के लिए, PostgreSQL के row_number() विंडो फ़ंक्शन का इस्तेमाल करें. उदाहरण के लिए, हर बैच में 50 लाइनें:

-- Evaluate a 50-row batch of real catalog items from ecomm.products
WITH numbered AS (
    SELECT 
        id, 
        name, 
        category,
        product_description,
        ((row_number() OVER (ORDER BY id) - 1) / 50) AS batch_id
    FROM ecomm.products
    ORDER BY id DESC
    LIMIT 50
),
batched AS (
    SELECT 
        batch_id,
        array_agg(id ORDER BY id) AS ids,
        array_agg(name ORDER BY id) AS names,
        array_agg(category ORDER BY id) AS categories,
        array_agg(product_description ORDER BY id) AS descs,
        ai.if(
            prompts => array_agg('Is "' || name || '" designed for cold weather winter outerwear?' ORDER BY id),
            model_id => 'jev-model'
        ) AS decisions
    FROM numbered
    GROUP BY batch_id
),
unrolled AS (
    SELECT 
        b.batch_id,
        u.id,
        u.name,
        u.category,
        u.product_description,
        u.decision AS cold_weather_gear
    FROM batched b
    CROSS JOIN LATERAL unnest(b.ids, b.names, b.categories, b.descs, b.decisions) 
      AS u(id, name, category, product_description, decision)
)
SELECT id, name, category, product_description, cold_weather_gear
FROM unrolled
WHERE cold_weather_gear = TRUE
LIMIT 5;

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

  id   |                                 name                                 |  category   |                                                product_description                                                 | cold_weather_gear 
-------+----------------------------------------------------------------------+-------------+--------------------------------------------------------------------------------------------------------------------+-------------------
 29071 | Winter Striped Beanie with Pom                                       | Accessories | Brave the chill in style with the SoleStyle Winter Striped Beanie! This cozy beanie adds a pop of personality...  | true
 29077 | Knit Collegiate Rugby Stripe Winter Scarf & Beanie Hat Set           | Accessories | Stay cozy and show off your sporty side with our Knit Collegiate Rugby Stripe Scarf & Beanie Set...               | true
 29083 | Junction Finds Men's Muscle Wool Blend Trapper Hat                   | Accessories | Brave the elements in style with the Junction Finds Trapper Hat! This wool-blend hat will keep you warm...        | true
 29086 | Mens Soft Thermal Insulated Wrist Length Leather Gloves - Black      | Accessories | Brave the chill in style with these supple leather gloves from Gavel Goods! Lined with a soft, thermal knit...    | true
 29090 | Long Beanie-Red W16S24E                                              | Accessories | Stay cozy and stylish all season long with this vibrant red beanie from Enchant! This isn't just any hat...       | true
(5 rows)

5. भावना के आधार पर, खरीदार की प्रॉडक्ट समीक्षाएं क्वेरी करना

अब ecomm.product_reviews टेबल में मौजूद खरीदारों की समीक्षाओं का विश्लेषण करें. इसके लिए, Jev के choice प्रिमिटिव पर आधारित ai.analyze_sentiment का इस्तेमाल करें:

SET google_ml_integration.enable_preview_ai_functions = 'on'
SELECT 
    r.id,
    p.name AS product_name,
    r.rating AS customer_star_rating,
    substring(r.review_text FROM 1 FOR 70) || '...' AS review_snippet,
    ai.analyze_sentiment(
        input => r.review_text,
        model_id => 'jev-model'
    ) AS detected_sentiment
FROM ecomm.product_reviews r
JOIN ecomm.products p ON r.product_id = p.id
ORDER BY r.id
LIMIT 5;

आपको इससे मिलता-जुलता आउटपुट दिखेगा:

 id |                  product_name                  | customer_star_rating |                             review_snippet                              | detected_sentiment 
----+------------------------------------------------+----------------------+-------------------------------------------------------------------------+--------------------
  1 | Hugs & Kisses Juniors Peplum Skirt             |                    1 | This skirt was poorly made and the fabric felt extremely cheap for for...| negative
  2 | Bonkers Larry Full Length Pull on Pants        |                    1 | These pants are way too expensive for the terrible quality you get. Th...| negative
  3 | Gifts and Garb Brah Bra Extenders              |                    3 | These extenders are okay but nothing special. They do add a bit of ext...| neutral
  4 | Auto Forge Men's Tall Duck Traditional Coat    |                    1 | This coat is terribly stiff and heavy, making it very uncomfortable to...| negative
  5 | Weaver's Way Men's Shetland Zip Neck Sweater   |                    2 | This sweater is just okay and not really worth the high price tag. The...| negative
(5 rows)

9. बोनस: JevScore की मदद से, लगातार सेंटीमेंट स्कोरिंग करना

AlloyDB के एआई फ़ंक्शन, जैसे कि ai.analyze_sentiment, कैटगरी के हिसाब से बकेट (positive, negative, neutral) दिखाते हैं. वहीं, TypeSafe AI का score प्रिमिटिव, क्रम से लगाए गए रूब्रिक के हिसाब से बारीकियों का आकलन करता है. साथ ही, उम्मीद के हिसाब से लगातार रेटिंग दिखाता है. यह रेटिंग 0 से 100 के बीच होती है.

score, टेक्स्ट क्लासिफ़िकेशन लेबल के बजाय संख्यात्मक मेटाडेटा दिखाता है. इसलिए, कस्टम generic मॉडल एंडपॉइंट (jev-systemone) को रजिस्टर किया जा सकता है और google_ml.predict_row का इस्तेमाल करके इसे चालू किया जा सकता है.

1. सामान्य एंडपॉइंट रजिस्टर करना

AlloyDB Studio में, jev-systemone को model_type => 'generic' के साथ रजिस्टर करें:

DO $$
BEGIN
    IF EXISTS (SELECT 1 FROM google_ml.model_info_view WHERE model_id = 'jev-systemone') THEN
        CALL google_ml.drop_model('jev-systemone');
    END IF;
EXCEPTION WHEN OTHERS THEN
    NULL;
END $$;

CALL google_ml.create_model(
    model_id => 'jev-systemone',
    model_request_url => 'https://api.typesafe.ai/v1/systemone',
    model_provider => 'custom',
    model_type => 'generic',
    model_qualified_name => 'jev-latest',
    model_auth_type => 'secret_manager',
    model_auth_id => 'jev_api_key'
);

model_type => 'generic' वाले मॉडल, request_body को सीधे तौर पर एपीआई एंडपॉइंट पर भेजते हैं और JSON जवाब को सीधे तौर पर वापस भेजते हैं. इससे आपको Jev के मल्टी-क्वेश्चन वाले पूरे एपीआई का इस्तेमाल करने की अनुमति मिलती है.

2. मल्टी-टास्क का आकलन (बूलियन + लगातार स्कोर) करना

एक ही एचटीटीपी कॉल में, डिफ़ेक्ट के बारे में बताने वाले बूलियन चेक (noul) और लगातार सेंटीमेंट इंटेंसिटी (score), दोनों का एक साथ आकलन करें:

SELECT jsonb_pretty(google_ml.predict_row(
    model_id => 'jev-systemone',
    request_body => json_build_object(
        'model', 'jev-latest',
        'state', 'Review for North Face Parka: "The zipper broke on day 3 and customer service refused an exchange, though the fabric itself is very soft."',
        'questions', json_build_object(
            'has_defect', json_build_object(
                'type', 'noul',
                'instructions', 'Does this review report a physical product defect or failure?'
            ),
            'satisfaction_score', json_build_object(
                'type', 'score',
                'instructions', 'Rate the customer sentiment and satisfaction on a 1-5 scale.',
                'criteria', json_build_array(
                    '1: Extremely dissatisfied / defect failure',
                    '2: Dissatisfied',
                    '3: Mixed or neutral',
                    '4: Satisfied',
                    '5: Delighted'
                )
            )
        )
    )
)::jsonb) AS jev_analysis;

आपको इससे मिलता-जुलता आउटपुट दिखेगा (आपके नतीजे अलग-अलग हो सकते हैं):

{
  "model": "jev-1.13.0",
  "usage": {
    "input_tokens": 388,
    "output_tokens": 39
  },
  "answers": {
    "has_defect": {
      "noul": 0.98,
      "type": "noul"
    },
    "satisfaction_score": {
      "type": "score",
      "score": 0.11,
      "legend": {
        "0": "1: Extremely dissatisfied / defect failure",
        "1": "2: Dissatisfied",
        "2": "3: Mixed or neutral",
        "3": "4: Satisfied",
        "4": "5: Delighted"
      },
      "confidence": 0.91,
      "probabilities": {
        "0": 0.9,
        "1": 0.08,
        "2": 0.02,
        "3": 0.0,
        "4": 0.0
      }
    }
  }
}

ध्यान दें कि satisfaction_score को 11 / 100 के तौर पर रेटिंग दी गई है. इससे पता चलता है कि ग्राहक का अनुभव ज़्यादातर नकारात्मक था. हालांकि, उसने यह माना है कि फ़ैब्रिक मुलायम था!

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

इस कोडलैब के दौरान बनाए गए संसाधनों के लिए, लगातार शुल्क लगने से बचने के लिए, सीक्रेट और डेटाबेस ऑब्जेक्ट हटाएं. साथ ही, AlloyDB क्लस्टर मिटाएं.

1. Secret Manager के संसाधन मिटाना

Cloud Shell में, TypeSafe AI API पासकोड के लिए बनाया गया सीक्रेट मिटाएं:

gcloud secrets delete typesafe-jev-api-key --quiet

2. AlloyDB प्राइमरी इंस्टेंस और क्लस्टर मिटाना

सबसे पहले प्राइमरी इंस्टेंस मिटाएं:

gcloud alloydb instances delete $ADBINSTANCE \
  --cluster=$ADBCLUSTER \
  --region=$REGION \
  --quiet

इंस्टेंस मिटाने की प्रोसेस पूरी होने के बाद, क्लस्टर मिटाएं:

gcloud alloydb clusters delete $ADBCLUSTER \
  --region=$REGION \
  --quiet

11. बधाई हो

बधाई हो! आपने Google Cloud AlloyDB क्लस्टर को सफलतापूर्वक प्रोविज़न कर लिया है और इसे TypeSafe AI System One (Jev) के साथ इंटिग्रेट कर लिया है.

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

• Private Service Access (पीएसए) सेट अप करने और AlloyDB for PostgreSQL क्लस्टर और प्राइमरी इंस्टेंस को प्रोविज़न करने का तरीका.
• --outbound-public-ip को चालू करने का तरीका, ताकि AlloyDB, बाहरी एचटीटीपीएस SaaS एपीआई तक पहुंच सके.
• तीसरे पक्ष के एआई सेवा देने वाली कंपनी के क्रेडेंशियल को Google Secret Manager में सुरक्षित तरीके से सेव करने और उन्हें AlloyDB से बाइंड करने का तरीका.
• PL/pgSQL ट्रांसफ़ॉर्मेशन फ़ंक्शन लिखने का तरीका, जो स्टैंडर्ड PostgreSQL एआई फ़ंक्शन (ai.if और ai.analyze_sentiment) को बाहरी REST API से जोड़ते हैं.
• google_ml.create_model का इस्तेमाल करके, AlloyDB में कस्टम एलएलएम एंडपॉइंट रजिस्टर करने का तरीका.
• स्केलर और हाई-थ्रूपुट वाली बैच की गई सेमैंटिक एसक्यूएल क्वेरी को सीधे तौर पर PostgreSQL में कैसे एक्ज़ीक्यूट करें.
• किसी कैटगरी के लिए, खरीदारों की प्रॉडक्ट के बारे में की गई समीक्षाओं का विश्लेषण कैसे करें.
• सामान्य मॉडल एंडपॉइंट को रजिस्टर करने और google_ml.predict_row के ज़रिए, ग्राहक संतुष्टि के स्कोर (0..100) का लगातार आकलन करने का तरीका.

अगले चरण

• AlloyDB AI के दस्तावेज़ में, AlloyDB AI फ़ंक्शन की क्षमताओं के बारे में ज़्यादा जानें.
• Noul के कॉन्स्ट्रेंट लॉजिक और सेंटीमेंट स्कोरिंग के बारे में ज़्यादा जानने के लिए, TypeSafe AI API का रेफ़रंस पढ़ें.

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

• AlloyDB मॉडल एंडपॉइंट मैनेजमेंट (एमईएम)
• Secret Manager की मदद से सीक्रेट मैनेज करना