Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

ऑडियंस की सूचियों के लिए रिग्रेशन मॉडलिंग

ML.PREDICT का इस्तेमाल किए बिना, मौजूदा लीनियर या लॉजिस्टिक रिग्रेशन मॉडल का इस्तेमाल करके अनुमान लगाए जा सकते हैं. इसके लिए, आपको मॉडल के वेट पता होने चाहिए. इसके अलावा, मॉडल का ऐक्सेस न होने पर भी अनुमान लगाए जा सकते हैं. इसके लिए, आपको Ads Data Hub में ऑडियंस ऐक्टिवेशन क्वेरी के अंदर, डिफ़रेंशियल प्राइवेट (डीपी) रिग्रेशन मॉडल का इस्तेमाल करने के लिए, कोई दूसरा तरीका अपनाना होगा.

इस चरण-दर-चरण उदाहरण में, आपको यह सिखाया जाएगा कि असली लीनियर और बाइनरी लॉजिस्टिक रिग्रेशन मॉडल के लिए, सिम्युलेटेड इन्फ़रेंस कैसे किया जाता है. इसके बाद, सिम्युलेट किए गए नतीजों की सटीक जानकारी दिखाने के लिए, ML.PREDICT के नतीजों से उनकी तुलना की जाएगी. इसमें यह भी दिखाया जाएगा कि बाइनरी लॉजिस्टिक मॉडल का इस्तेमाल करके, ऑडियंस लिस्ट कैसे बनाई जाती है. इस लिस्ट का इस्तेमाल, ऑडियंस ऐक्टिवेशन के लिए कन्वर्ज़न मॉडल लागू करने में किया जाएगा.

उदाहरण की खास जानकारी:

डेटा जनरेट करना
मॉडल को ट्रेनिंग देना
वेटेज पाना और इंटरसेप्ट करना
अनुमान को सिम्युलेट करना
नतीजों की तुलना करना

चरण-दर-चरण उदाहरण

1. डेटा जनरेट करना

मॉडल को ट्रेनिंग देने के लिए, सिम्युलेट किए गए डेटा की एक टेबल बनाएं. होल्डबैक सेट के लिए, पंक्तियों के कुछ हिस्से को मार्क करें.

लीनियर रिग्रेशन

CREATE OR REPLACE TABLE DATASET_NAME.LIN_REG_TRAINING_SET AS
  WITH
  A AS (
    SELECT
      *
    FROM
      UNNEST(GENERATE_ARRAY(1, 100000)) AS row_number),
  B AS (
    SELECT
      row_number,
      RAND() AS rand_label,
      RAND() AS rand_feature_1,
      RAND() AS rand_feature_2,
      RAND() AS rand_feature_3,
      RAND() AS rand_feature_4,
      RAND() AS rand_feature_5,
      RAND() AS rand_feature_6,
      RAND() AS rand_feature_7,
      RAND() AS rand_feature_8,
      RAND() AS rand_feature_9,
      RAND() AS rand_feature_10
    FROM
      A),
  C AS (
    SELECT
      rand_label AS label,
      *
    FROM
      B),
  D AS (
    SELECT
    row_number,
    CAST(round(10 * label) AS INT64) AS label,
    (rand_label + rand_feature_1) / 2 AS feature_1,
    (rand_label + rand_feature_2) / 2 AS feature_2,
    (rand_label + rand_feature_3) / 2 AS feature_3,
    (rand_label + rand_feature_4) / 2 AS feature_4,
    (rand_label + rand_feature_5) / 2 AS feature_5,
    (rand_label + rand_feature_6) / 2 AS feature_6,
    (rand_label + rand_feature_7) / 2 AS feature_7,
    (rand_label + rand_feature_8) / 2 AS feature_8,
    (rand_label + rand_feature_9) / 2 AS feature_9,
    (rand_label + rand_feature_10) / 2 AS feature_10
    FROM
    C)

SELECT
  label,
  feature_1,
  feature_2,
  feature_3,
  feature_4,
  feature_5,
  feature_6,
  feature_7,
  feature_8,
  feature_9,
  feature_10,
  RAND() < 0.1 AS holdback -- Ten percent will be true.
FROM
  D

बाइनरी लॉजिस्टिक रिग्रेशन

SELECT
  CASE
    WHEN label < 5 THEN 0
    WHEN label >= 5 THEN 1
  END
  AS label,
  * EXCEPT (label)
FROM
  `DATASET_NAME.BIN_LOG_REG_TRAINING_SET`

2. मॉडल को ट्रेनिंग देना

ट्रेनिंग सेट से रिग्रेशन मॉडल को ट्रेन करें.

लीनियर रिग्रेशन

CREATE OR REPLACE MODEL `DATASET_NAME.LIN_REG_MODEL` OPTIONS (model_type="linear_reg") AS
  SELECT
    * except (holdback)
  FROM
    `DATASET_NAME.LIN_REG_TRAINING_SET`
  WHERE
    NOT holdback

ध्यान दें कि हमने सिम्युलेट किए गए डेटा में इतना नॉइज़ जोड़ा है कि हमें R² = 0.9009 वाला मॉडल मिल सके.

आकलन	मान
कुल गड़बड़ी का मध्यमान	0.7359
वर्ग में गड़बड़ी का माध्य	0.8432
लॉग में गड़बड़ी का माध्य	0.0810
कुल गड़बड़ी का मीडियन	0.6239
R स्क्वैयर्ड	0.9009

बाइनरी लॉजिस्टिक रिग्रेशन

CREATE OR REPLACE MODEL `DATASET_NAME.BIN_LOG_REG_MODEL` OPTIONS (model_type="logistic_reg") AS
  SELECT
    * EXCEPT (holdback)
  FROM
    `DATASET_NAME.BIN_LOG_REG_TRAINING_SET`
  WHERE
    NOT holdback

नतीजों के सैंपल. सटीकता की वैल्यू 0.9260 पर ध्यान दें.

आकलन	मान
पॉज़िटिव क्लास	1
नेगेटिव क्लास	0
स्पष्टता	0.0810
रीकॉल	0.9315
सटीक जवाब	0.9260
F1 स्कोर	0.9328

इस कन्फ़्यूज़न मैट्रिक्स में बोल्ड की गई वैल्यू से पता चलता है कि मॉडल ने हर लेबल को कितनी बार सही तरीके से क्लासिफ़ाई किया. वहीं, बोल्ड नहीं की गई वैल्यू से पता चलता है कि मॉडल ने हर लेबल को कितनी बार गलत तरीके से क्लासिफ़ाई किया.

सही लेबल	अनुमानित लेबल 1	अनुमानित लेबल 2
1	93%	7%
0	8%	92%

3. वज़न और इंटरसेप्ट पाना

मॉडल के लिए वेट और इंटरसेप्ट पाएं:

लीनियर रिग्रेशन

SELECT
  *
FROM
  ML.WEIGHTS(MODEL `DATASET_NAME.LIN_REG_MODEL`)

वज़न का डेटा	category_weights.category
feature_1	1.8263055528635743
feature_2	1.8143804404490813
feature_3	1.8601204874033492
feature_4	1.8507603439031859
feature_5	1.7899764387123640
feature_6	1.8645246630251291
feature_7	1.8698005281925356
feature_8	1.7904637080330201
feature_9	1.8036887855406274
feature_10	1.8117115890624449
INTERCEPT	-4.1428754911504306

बाइनरी लॉजिस्टिक रिग्रेशन

SELECT
  *
FROM
  ML.WEIGHTS(MODEL `DATASET_NAME.BIN_LOG_REG_MODEL`)

वज़न का डेटा	category_weights.category
feature_1	3.823533928
feature_2	3.734812819
feature_3	3.842239823
feature_4	3.785488823
feature_5	3.737386716
feature_6	3.567663961
feature_7	3.819643052
feature_8	3.734673763
feature_9	3.839301406
feature_10	3.787306994
INTERCEPT	-17.922169920

4. अनुमान को सिम्युलेट करना

लीनियर रिग्रेशन

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

WITH
T AS (
SELECT
  label AS actual_label,
  predicted_label AS ml_predicted_label,
  [feature_1,
  feature_2,
  feature_3,
  feature_4,
  feature_5,
  feature_6,
  feature_7,
  feature_8,
  feature_9,
  feature_10] AS features,
  [1.8263055528635743,
  1.8143804404490813,
  1.8601204874033492,
  1.8507603439031859,
  1.789976438712364,
  1.8645246630251291,
  1.8698005281925356,
  1.7904637080330201,
  1.8036887855406274,
  1.8117115890624449] AS weights
FROM
  ML.PREDICT(MODEL `DATASET_NAME.LIN_REG_MODEL`,
    (
    SELECT
      *
    FROM
      `PROJECT_NAME.DATASET_NAME.LIN_REG_TRAINING_SET`))
WHERE
  holdback),
P AS (
SELECT
  actual_label,
  ml_predicted_label,
  (
   SELECT
    SUM(element1 * element2) - 4.1428754911504306
  FROM
    T.features element1
  WITH
  OFFSET
    pos
  JOIN
    T.weights element2
  WITH
  OFFSET
    pos
  USING
    (pos) ) sql_predicted_label,
  features,
  weights
FROM
  T)
SELECT
  actual_label,
  ml_predicted_label,
  sql_predicted_label,
  ABS(ml_predicted_label - sql_predicted_label) < 0.00000000001 AS diff_is_negligible
FROM
  P

बाइनरी लॉजिस्टिक रिग्रेशन

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

वज़न के साथ फ़ीचर वैल्यू के डॉट प्रॉडक्ट का इस्तेमाल करें. साथ ही, इंटरसेप्ट जोड़ें, ताकि ML.PREDICT का इस्तेमाल किए बिना स्टैंडर्ड एसक्यूएल का इस्तेमाल करके अनुमान लगाया जा सके. इसके बाद, नतीजे पर 0.5 की थ्रेशोल्ड वैल्यू के साथ सिग्मॉइड फ़ंक्शन का इस्तेमाल करके, 0 या 1 का अनुमान लगाएं. इस क्वेरी में, इस तकनीक का इस्तेमाल करके किए गए अनुमानों की तुलना, ML.PREDICT का इस्तेमाल करके किए गए अनुमानों से की जाती है.

WITH
T AS (
SELECT
  label AS actual_label,
  predicted_label AS ml_predicted_label,
  [feature_1,
  feature_2,
  feature_3,
  feature_4,
  feature_5,
  feature_6,
  feature_7,
  feature_8,
  feature_9,
  feature_10] AS features,
  [3.8235339279050287,
  3.7348128191185244,
  3.8422398227859471,
  3.7854888232502479,
  3.7373867156553713,
  3.5676639605351026,
  3.8196430517007811,
  3.7346737628343032,
  3.8393014063170749,
  3.7873069939244743] AS weights
FROM
  ML.PREDICT(MODEL `DATASET_NAME.BIN_LOG_REG_MODEL`,
    (
    SELECT
      *
    FROM
      `PROJECT_NAME.DATASET_NAME.BIN_LOG_REG_TRAINING_SET`))
WHERE
  holdback),
P AS (
SELECT
  actual_label,
  ml_predicted_label,
  (
   SELECT
    IF((1 / (1 + EXP(-(SUM(element1 * element2) -17.922169920432161)))) < 0.5, 0, 1)
  FROM
    T.features element1
  WITH
  OFFSET
    pos
  JOIN
    T.weights element2
  WITH
  OFFSET
    pos
  USING
    (pos) ) sql_predicted_label,
  features,
  weights
FROM
  T)
SELECT
  actual_label,
  ml_predicted_label,
  sql_predicted_label,
  ml_predicted_label = sql_predicted_label AS simulation_is_accurate
FROM
  P

ऊपर दी गई क्वेरी में, बोल्ड किए गए SQL कोड का ब्लॉक, मॉडल के वेट के साथ हर लाइन के लिए फ़ीचर वैल्यू का डॉट प्रॉडक्ट कर रहा है. साथ ही, लीनियर रिग्रेशन का अनुमान पाने के लिए इंटरसेप्ट जोड़ रहा है:

IF((1 / (1 + EXP(-(SUM(element1 * element2) -17.922169920432161)))) < 0.5, 0, 1)

इसके बाद, स्टैंडर्ड एसक्यूएल का इस्तेमाल करके, डॉट प्रॉडक्ट और इंटरसेप्ट पर सिग्मॉइड फ़ंक्शन Y = 1 / (1+e^-z) लागू किया जाता है:

IF((1 / (1 + EXP(-(SUM(element1 * element2) -17.922169920432161)))) < 0.5, 0, 1)

आखिर में, सिग्मॉइड फ़ंक्शन के नतीजे की तुलना थ्रेशोल्ड वैल्यू 0.5 से की जाती है. इससे बाइनरी लॉजिस्टिक रिग्रेशन का अनुमान लगाया जाता है. अगर नतीजा 0.5 से कम है, तो अनुमान 0 होता है. अगर नतीजा 0.5 से कम नहीं है, तो अनुमान 1 होता है. ध्यान दें कि 0 से 1 के बीच की किसी भी थ्रेशोल्ड वैल्यू का इस्तेमाल किया जा सकता है.

IF((1 / (1 + EXP(-(SUM(element1 * element2) -17.922169920432161)))) < 0.5, 0, 1)

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

5. नतीजों की तुलना करना

लीनियर रिग्रेशन

सैंपल के नतीजे करीब-करीब एक जैसे हैं. हालांकि, पूर्णांक में बदलने की वजह से थोड़ा अंतर है.

actual_label	ml_predicted_label	sql_predicted_label	diff_is_negligible
6	5.2062349420751834	5.2062349420751826	सही
0	0.40318472770048075	0.403184727700479	सही
3	3.0703766078249597	3.0703766078249597	सही
7	7.0588171538562	7.0588171538562	सही
6	6.7802375930646	6.7802375930646	सही
6	5.1088569571339368	5.1088569571339377	सही
4	4.051839078116874	4.051839078116874	सही
4	5.1810254680219243	5.1810254680219234	सही
6	6.1440349466401223	6.1440349466401205	सही
1	2.0842399472783519	2.0842399472783519	सही
2	2.1911209811886847	2.1911209811886838	सही
3	3.0236086790006622	3.0236086790006613	सही
2	2.573083132964213	2.5730831329642125	सही
7	5.68662973136732	5.6866297313673186	सही
9	8.1860026312677938	8.1860026312677938	सही

बाइनरी लॉजिस्टिक रिग्रेशन

सिम्युलेट किए गए अनुमान की तुलना, ML.PREDICT के असल नतीजों से की गई है. यह तुलना सटीक है. 10 हज़ार लाइनों वाले होल्डबैक सेट में कोई भी विरोधाभास नहीं है. कुछ पंक्तियों में, ML.PREDICT और सिम्युलेटेड अनुमान, दोनों ही असल लेबल से मेल नहीं खाते. ऐसा इसलिए है, क्योंकि मॉडल की सटीकता करीब 93% है. साथ ही, कन्फ़्यूज़न मैट्रिक्स के ऑफ़-डायगोनल सेल में छोटी, लेकिन शून्य से ज़्यादा वैल्यू मौजूद हैं.

ml_predicted_label	sql_predicted_label	simulation_is_accurate
1	1	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
0	0	सही
1	1	सही
0	0	सही

मशीन लर्निंग की मदद से, ऑडियंस ऐक्टिवेशन की सूची बनाना

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

यहां दी गई क्वेरी से पता चलता है कि उन उपयोगकर्ताओं की ऑडियंस सूची कैसे बनाई जाती है जिनके बारे में मॉडल का अनुमान है कि वे ग्राहक में बदलेंगे:

WITH
T AS (
SELECT
  *,
  label AS actual_label,
  [feature_1,
  feature_2,
  feature_3,
  feature_4,
  feature_5,
  feature_6,
  feature_7,
  feature_8,
  feature_9,
  feature_10] AS features,
  [3.8235339279050287,
  3.7348128191185244,
  3.8422398227859471,
  3.7854888232502479,
  3.7373867156553713,
  3.5676639605351026,
  3.8196430517007811,
  3.7346737628343032,
  3.8393014063170749,
  3.7873069939244743] AS weights
FROM
  `PROJECT_NAME.DATASET_NAME.BIN_LOG_REG_TRAINING_SET`
WHERE
  holdback),
P AS (
SELECT
  *,
  (
  SELECT
  IF
    ((1 / (1 + EXP(-(SUM(element1 * element2) -17.922169920432161)))) < 0.5, 0, 1)
  FROM
    T.features element1
  WITH
  OFFSET
    pos
  JOIN
    T.weights element2
  WITH
  OFFSET
    pos
  USING
    (pos) ) predicted_label,
  features,
  weights
FROM
  T),
SELECT
  user_id
FROM
  P
WHERE
  predicted_label = 1;