Ads Data Hub में रेग्रेसन मॉडलिंग

लीनियर और लॉजिस्टिक रिग्रेशन, मशीन लर्निंग मॉडल हैं. इनकी मदद से, विज्ञापन डेटा से काम के अनुमान लगाए जा सकते हैं.

• लीनियर रिग्रेशन, डेटा में लाइन फ़िट करने के लिए एक फ़ंक्शन बनाता है, ताकि डेटा पॉइंट और लाइन के बीच की दूरी कम हो जाए. इसके बाद, इस मॉडल का इस्तेमाल इनपुट के आधार पर संख्या वाली वैल्यू का अनुमान लगाने के लिए किया जा सकता है. जैसे, खरीदारी, पिछले इंटरैक्शन वगैरह के आधार पर उपयोगकर्ता की लाइफ़टाइम वैल्यू का अनुमान लगाना.
• लॉजिस्टिक रिग्रेशन का इस्तेमाल, अनुमानित कैटगरी की समस्याओं के लिए किया जाता है. आपके दिए गए वैरिएबल के हिसाब से, मॉडल इनमें से किसी एक तरह का हो सकता है:
  • बाइनरी लॉजिस्टिक रिग्रेशन, "हां/नहीं" वाले सवालों के जवाब देता है. जैसे, कन्वर्ज़न इवेंट होने की कितनी संभावना है.
  • मल्टीक्लास लॉजिस्टिक रिग्रेशन का इस्तेमाल, कई संभावित वैल्यू का अनुमान लगाने के लिए किया जाता है. जैसे, यह तय करना कि कोई ग्राहक "कम वैल्यू", "मध्यम वैल्यू" या "ज़्यादा वैल्यू" वाला है.

लीनियर और लॉजिस्टिक रिग्रेशन, दोनों ही ट्रेनिंग डेटा (इस मामले में, आपका विज्ञापन डेटा) से सीखते हैं. इससे, आपको विज्ञापन से जुड़े फ़ैसले लेने के लिए, अनुमान लगाने वाला मॉडल मिलता है. आम तौर पर, ज़्यादा डेटा उपलब्ध कराने और यह पक्का करने से कि आपका डेटा अच्छी क्वालिटी का है, आपके मॉडल की सटीकता बढ़ेगी. जब दोनों मॉडल को ज़्यादा क्लस्टर वाला ट्रेनिंग डेटा दिया जाता है, तो उनकी परफ़ॉर्मेंस बेहतर होती है.

ध्यान दें: ऑडियंस चालू करने की सुविधा, रेग्रेसन मॉडलिंग के साथ इस्तेमाल करने के लिए उपलब्ध नहीं है.

डिफ़रेंशियल प्राइवसी

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

अहम जानकारी: अलग-अलग निजता ≠ अलग-अलग चीज़ों के लिए अलग-अलग क्वेरी. अंतर की जांच से, एग्रीगेशन की ज़रूरी शर्तों का पता चलता है. ये शर्तें, नतीजे में मौजूद उपयोगकर्ताओं की तय संख्या के लिए, एक जैसे उपयोगकर्ताओं के ग्रुप के कम से कम साइज़ को तय करती हैं.

क्वेरी की संख्या सीमित करना

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

अहम जानकारी: डिफ़ॉल्ट EPSILON_PER_MODEL का इस्तेमाल करके, हर दिन के डेटा के लिए 100 से ज़्यादा लीनियर और लॉजिस्टिक रिग्रेशन क्वेरी नहीं चलाई जा सकतीं.

यह कैसे काम करता है

वर्कफ़्लो इन ज़रूरी चरणों का पालन करता है:

1. ट्रेनिंग डेटा तैयार करें.
2. मॉडल बनाएं.
3. मॉडल से अहम जानकारी इकट्ठा करना.

ट्रेनिंग डेटा तैयार करना

जैसा कि ऊपर बताया गया है, आम तौर पर बड़े और अच्छी क्वालिटी वाले डेटासेट का इस्तेमाल करने से बेहतर नतीजे मिलते हैं. इसके अलावा, इनपुट डेटा को कम से ज़्यादा स्केलिंग का इस्तेमाल करके स्केल किया जाता है. इसलिए, कम क्लस्टर वाला डेटा या बहुत ज़्यादा आउटलायर वाला डेटा, मॉडल पर बुरा असर डाल सकता है. ऐसा, मॉडल के औसत में बदलाव होने की वजह से होता है.

डिफ़ॉल्ट रूप से, Ads Data Hub पुष्टि करने के लिए, आपके ट्रेनिंग डेटा का 18% डेटा चुनता है. पुष्टि करने के लिए इस्तेमाल किए गए डेटा का प्रतिशत, data_split_eval_fraction विकल्प से कंट्रोल किया जा सकता है.

मॉडल बनाना

अपने मॉडल को ट्रेनिंग देने के लिए, पैरामीटर और इनपुट डेटा डालें.

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

सबसे सही तरीके

किसी मॉडल की क्वालिटी तय करने में, ट्रेनिंग सेट का साइज़ सबसे अहम भूमिका निभाता है. हालांकि, समस्या और नीचे दिए गए फ़ैक्टर के आधार पर, साइज़/क्वालिटी का समझौता अलग-अलग होगा. कृपया हमें बताएं कि आपका अनुभव कैसा रहा.

• हमें कम से कम 1,00,000 उपयोगकर्ताओं वाले ट्रेनिंग सेट से बनाए गए लॉजिस्टिक रिग्रेशन मॉडल के लिए, सटीकता 0.70 से ज़्यादा दिखी है.
• हमने कम से कम 8,00,000 उपयोगकर्ताओं वाले ट्रेनिंग सेट से बनाए गए लीनियर रिग्रेशन मॉडल के लिए, r-squared > 0.70 देखा है.

मॉडल की क्वालिटी को खराब करने वाले अन्य फ़ैक्टर भी हैं.

• लॉजिस्टिक मॉडल, जिनमें एक क्लास को अन्य क्लास की तुलना में ज़्यादा दिखाया गया है. खास तौर पर, जब किसी लेबल में ट्रेनिंग सेट के उपयोगकर्ताओं की संख्या कम होती है, तो हो सकता है कि दूसरे लेबल के ट्रेनिंग सेट में उपयोगकर्ताओं की संख्या ज़्यादा होने पर भी, छोटे लेबल पर मॉडल की सटीक जानकारी पाने में ज़्यादा मदद न मिले. उदाहरण के लिए, दो लेबल के लिए 20,000 और 1,000 ट्रेनिंग सेट उपयोगकर्ताओं की संख्या, 10,000 और 2,000 से कम है.
• ऐसा सुविधा डेटा जो लेबल के लिए कोई सटीक सिग्नल नहीं देता.
• ऐसा रॉ डेटा जिसे ज़्यादा बेहतर सुविधाओं की ज़रूरत है. उदाहरण के लिए, कुछ फ़ील्ड में संभावित वैल्यू की संख्या बहुत ज़्यादा हो सकती है. इस तरह के डेटा को बेहतर बनाने का एक तरीका यह है कि वैल्यू को कम कैटगरी या बकेट वाली सुविधा में बदला जाए.

अहम जानकारी इकट्ठा करना

फ़ंक्शन को कॉल करके, पुष्टि करने वाले डेटा पर अपने मॉडल की परफ़ॉर्मेंस का आकलन किया जा सकता है. साथ ही, ट्रेनिंग के दौरान दोहराया जाने वाला डेटा (जैसे, अनुमान लगाने के दौरान मॉडल के इस्तेमाल किए गए वज़न) और सुविधाओं की जांच की जा सकती है. इसके अलावा, नया डेटा इस्तेमाल करके अनुमान लगाया जा सकता है.

CREATE MODEL स्टेटमेंट

CREATE MODEL स्टेटमेंट, आपके दिए गए नाम और डेटासेट के साथ एक मॉडल बनाता है. अगर मॉडल का नाम पहले से मौजूद है, तो CREATE MODEL मौजूदा मॉडल की जगह ले लेता है.

ध्यान दें: Ads Data Hub का सुझाव है कि आप CREATE MODEL स्टेटमेंट के बाहर, ट्रेनिंग के लिए इस्तेमाल की जाने वाली टेबल बनाएं. इस सबसे सही तरीके से, मॉडल-ट्रेनिंग पैरामीटर को बार-बार इस्तेमाल करना और समस्याओं को प्राथमिकता के हिसाब से बांटना आसान हो जाता है.

CREATE MODEL सिंटैक्स

CREATE MODEL
model_name
OPTIONS
(
  // model_option_list:
  // Required parameter.
  MODEL_TYPE = { 'ADH_LINEAR_REGRESSION' | 'ADH_LOGISTIC_REGRESSION'}

  // Optional tuning parameters.
  [, L1_REG = float64_value ]
  [, L2_REG = float64_value ]
  [, DATA_SPLIT_EVAL_FRACTION = float64_value ]
  [, OPTIMIZE_STRATEGY = { 'AUTO_STRATEGY' | 'BATCH_GRADIENT_DESCENT' |
                           'NORMAL_EQUATION' } ]
  [, MAX_ITERATIONS = int64_value ]
  [, LEARN_RATE_STRATEGY = { 'LINE_SEARCH' | 'CONSTANT' } ]
  [, LEARN_RATE = float64_value ]
  [, EARLY_STOP = { TRUE | FALSE } ]
  [, MIN_REL_PROGRESS = float64_value ]
  [, LS_INIT_LEARN_RATE = float64_value ]
  [, EPSILON_PER_MODEL = float64_value ]
  [, AUTOMATIC_IMPUT_SCALING = bool_value ]
  [, MIN_MAX_SCALED_COLS = [string_value, string_value... ] ]
  [, STANDARD_SCALED_COLS = [string_value, string_value... ] ]
  [, QUANTILE_BUCKETIZED_COLS = [
        STRUCT(string_value AS col_name, int64_value AS num_buckets), 
       STRUCT(string_value AS col_name, int64_value AS num_buckets)... ] ]
)
AS query_statement

model_name

अंडरस्कोर और डैश के साथ अक्षर और अंकों वाला नाम. इसमें बिंदु शामिल नहीं किए जा सकते. अगर आपने जो मॉडल का नाम दिया है वह पहले से मौजूद है, तो पुराने मॉडल को बदल दिया जाएगा.

query_statement

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

model_option_list

model_type

(ज़रूरी) यह एकमात्र ज़रूरी विकल्प है. यह 'adh_linear_regression' या 'adh_logistic_regression' हो सकता है

l1_reg

(ज़रूरी नहीं) लागू किए गए L1 रेगुलराइज़ेशन की रकम. L1 रेगुलराइज़ेशन, वेट की ऐब्सोलूट वैल्यू के योग के हिसाब से वेट को दंडित करता है. यह कोई भी ऐसी संख्या हो सकती है जो शून्य से बड़ी हो. डिफ़ॉल्ट रूप से, यह शून्य पर सेट होती है.

l2_reg

(ज़रूरी नहीं) लागू किए गए L2 रेगुलराइज़ेशन की रकम. L2 रेगुलराइज़ेशन, वेटेज के स्क्वेयर के योग के वर्गमूल के अनुपात में वेटेज पर जुर्माना लगाता है. यह कोई भी ऐसी संख्या हो सकती है जो शून्य से बड़ी हो. डिफ़ॉल्ट रूप से, यह शून्य पर सेट होती है.

data_split_eval_fraction

(ज़रूरी नहीं) यह वैल्यू .01 से .99 के बीच होनी चाहिए. डिफ़ॉल्ट रूप से, यह वैल्यू .18 होती है. यह उस डेटा का प्रतिशत तय करता है जो आकलन सेट में शामिल होता है. इससे मॉडल में शामिल होने वाली लाइनों की संख्या कम हो जाती है. इससे मॉडल की सटीकता पर असर पड़ता है. हालांकि, इससे उपयोगकर्ता के पास उन मॉडल की संख्या भी बढ़ जाती है जिन्हें वह चला सकता है. यहां उस संबंध का चार्ट दिया गया है, जिसमें यह माना गया है कि किसी डेटासेट में हर मॉडल का फ़्रैक्शन एक जैसा है:

पुष्टि करने के लिए फ़्रैक्शन	अनुमति वाली क्वेरी
0.01	7
0.1	8
0.15	8
0.18	9
0.2	9
0.3	10
0.5	14
0.9	50

optimize_strategy

(ज़रूरी नहीं) लीनियर रिग्रेशन मॉडल को ट्रेन करने की रणनीति.

आर्ग्युमेंट

'AUTO_STRATEGY', ट्रेनिंग की रणनीति को इस तरह तय करता है:

• अगर l1_reg या warm_start की जानकारी दी गई है, तो batch_gradient_descent रणनीति का इस्तेमाल किया जाता है.
• अगर ट्रेनिंग की सुविधाओं के एलिमेंट की कुल संख्या 10,000 से ज़्यादा है, तो batch_gradient_descent रणनीति का इस्तेमाल किया जाता है.
• अगर ओवर-फ़िटिंग की समस्या है (ट्रेनिंग के उदाहरणों की संख्या, एलिमेंट की कुल संख्या के 10 गुना से कम है), तो batch_gradient_descent रणनीति का इस्तेमाल किया जाता है.
• NORMAL_EQUATION रणनीति का इस्तेमाल अन्य सभी मामलों में किया जाता है.

'BATCH_GRADIENT_DESCENT' (सिर्फ़ लॉजिस्टिक) बैच ग्रेडिएंट डिसेंट (बहुत सारे डेटा के लिए एक बार में एल्गोरिदम को बेहतर बनाने का तरीका) का इस्तेमाल करके मॉडल को ट्रेन करता है. यह ग्रेडिएंट फ़ंक्शन का इस्तेमाल करके, लॉस फ़ंक्शन को ऑप्टिमाइज़ करता है.

'NORMAL_EQUATION' (सिर्फ़ लीनियर) विश्लेषण के फ़ॉर्मूला की मदद से, लीनियर रिग्रेशन समस्या के लिए, सीधे तौर पर सबसे कम स्क्वेयर का हिसाब लगाता है. सामान्य समीकरण का इस्तेमाल इन मामलों में नहीं किया जा सकता:

• l1_reg की वैल्यू दी गई हो.
• warm_start की वैल्यू दी गई हो.
• ट्रेनिंग की सुविधाओं की कुल संख्या 10,000 से ज़्यादा है.
• डिफ़ॉल्ट वैल्यू 'AUTO_STRATEGY' होती है.

max_iterations

(ज़रूरी नहीं) ट्रेनिंग के दोहराव या चरणों की संख्या. यह क्वेरी हर बार एक ट्री बनाती है. इसलिए, यह पेड़ों की संख्या भी है. यह संख्या 1 से बड़ी होनी चाहिए. डिफ़ॉल्ट रूप से 20 होती है.

learn_rate_strategy

(ज़रूरी नहीं, सिर्फ़ लॉजिस्टिक के लिए) ट्रेनिंग के दौरान लर्निंग रेट तय करने की रणनीति.

आर्ग्युमेंट

'LINE_SEARCH', लर्निंग रेट का हिसाब लगाने के लिए, लाइन सर्च का तरीका इस्तेमाल करता है. लाइन सर्च के लिए शुरुआती लर्न रेट, LS_INIT_LEARN_RATE के लिए तय की गई वैल्यू होती है .

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

'CONSTANT', लर्निंग रेट को LEARN_RATE के लिए तय की गई वैल्यू पर सेट करता है.

डिफ़ॉल्ट वैल्यू 'LINE_SEARCH' होती है.

learn_rate

(ज़रूरी नहीं, सिर्फ़ लॉजिस्टिक के लिए) जब LEARN_RATE_STRATEGY को CONSTANT पर सेट किया जाता है, तो ग्रेडिएंट डिसेंट के लिए लर्न रेट. अगर LEARN_RATE_STRATEGY को 'LINE_SEARCH' पर सेट किया जाता है, तो गड़बड़ी का मैसेज दिखता है.

आर्ग्युमेंट

float64_value, 64-बिट फ़्लोटिंग पॉइंट वाली कोई भी संख्या हो सकती है. डिफ़ॉल्ट रूप से, यह वैल्यू 0.1 (10%) होती है.

early_stop

(ज़रूरी नहीं) क्या पहले ही दोहराव के बाद ट्रेनिंग बंद होनी चाहिए, जिसमें रिलेटिव लॉस में हुआ सुधार, MIN_REL_PROGRESS के लिए तय की गई वैल्यू से कम है.

आर्ग्युमेंट

“हां” के लिए TRUE और “नहीं” के लिए FALSE. डिफ़ॉल्ट रूप से TRUE.

min_rel_progress

(ज़रूरी नहीं) EARLY_STOP को 'सही' पर सेट करने पर, ट्रेनिंग जारी रखने के लिए, रिलेटिव लॉस में कम से कम यह सुधार होना ज़रूरी है. उदाहरण के लिए, 0.01 की वैल्यू से पता चलता है कि ट्रेनिंग जारी रखने के लिए, हर बार 1% की कमी होनी चाहिए.

आर्ग्युमेंट

float64_value, 64-बिट फ़्लोटिंग पॉइंट वाली कोई भी संख्या हो सकती है. डिफ़ॉल्ट रूप से, यह वैल्यू 0.1 (10%) होती है.

ls_init_learn_rate

(ज़रूरी नहीं) शुरुआती लर्निंग रेट सेट करता है, जिसका इस्तेमाल LEARN_RATE_STRATEGY='LINE_SEARCH' करता है. इस विकल्प का इस्तेमाल सिर्फ़ तब किया जा सकता है, जब LINE_SEARCH की वैल्यू दी गई हो.

अगर ML.TRAINING_INFO के मुताबिक, मॉडल का LEARN_RATE हर बार दोगुना हो रहा है, तो LS_INIT_LEARN_RATE को पिछले दोगुने लर्न रेट पर सेट करें. शुरुआती लर्निंग रेट, हर मॉडल के लिए अलग-अलग होता है. ऐसा हो सकता है कि किसी मॉडल के लिए शुरुआती लर्निंग रेट अच्छा हो, लेकिन किसी दूसरे मॉडल के लिए अच्छा न हो.

आर्ग्युमेंट

float64_value, 64-बिट फ़्लोटिंग पॉइंट वाली कोई भी संख्या हो सकती है.

epsilon_per_model

(ज़रूरी नहीं) इस मॉडल को ट्रेनिंग देने के लिए, निजता बजट की रकम तय करता है. विज्ञापन डेटा के हर ग्राहक को, डेटा के हर दिन के लिए 10.0 का निजता बजट दिया जाता है. ट्रेनिंग पूरा हो जाने के बाद, मॉडल क्वेरी चलाते समय तय की गई तारीख की सीमा में, हर डेटा के दिन के लिए बजट का EPSILON_PER_MODEL खर्च करेगा. ln(3)/10 की डिफ़ॉल्ट वैल्यू का इस्तेमाल करने पर, करीब 100 मॉडल बनाए जा सकेंगे. ज़्यादा वैल्यू का इस्तेमाल करने पर, कम मॉडल बनाए जा सकेंगे. हालांकि, उनकी क्वालिटी बेहतर होगी. कम वैल्यू का इस्तेमाल करने पर, कम क्वालिटी वाले ज़्यादा मॉडल बनाए जा सकेंगे.

आर्ग्युमेंट

float64_value, ln(3) से कम की कोई भी 64-बिट फ़्लोटिंग पॉइंट संख्या हो सकती है, जो करीब 1.0986 होती है. डिफ़ॉल्ट रूप से, यह ln(3)/10 पर सेट होती है.

automatic_input_scaling

(ज़रूरी नहीं) TRUE चुनने पर, संख्या वाले सभी फ़ीचर कॉलम पर min_max_scaling अपने-आप लागू हो जाएगा. ऐसा तब होगा, जब कॉलम के नाम min_max_scaled_cols विकल्प में साफ़ तौर पर बताए गए हों. हालांकि, standard_scaled_cols या quantile_bucketized_cols विकल्प में साफ़ तौर पर बताए गए कॉलम पर यह लागू नहीं होगा.

आर्ग्युमेंट

bool_value एक BOOL है, डिफ़ॉल्ट वैल्यू TRUE है.

min_max_scaled_cols

(ज़रूरी नहीं) तय किए गए numerical_expression फ़ीचर कॉलम में मौजूद हर वैल्यू को 0 से 1 की रेंज में स्केल करता है. साथ ही, सभी लाइनों में MIN और MAX के साथ कैप करता है. अनुमान लगाने के लिए, MIN और MAX का इस्तेमाल अपने-आप किया जाता है. अगर अनुमान का डेटा MIN, MAX की सीमा से बाहर है, तो उसे 0 या 1 पर सेट कर दिया जाता है.

आर्ग्युमेंट

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

standard_scaled_cols

(ज़रूरी नहीं) सभी पंक्तियों में, बताए गए numerical_expression फ़ीचर कॉलम को स्टैंडर्ड बनाता है. एक्सप्रेशन को स्टैंडर्ड करने के लिए कैलकुलेट किए गए STDDEV और MEAN का इस्तेमाल, अनुमान लगाने के लिए अपने-आप किया जाता है.

आर्ग्युमेंट

string_value का कलेक्शन, जहां हर string_value एक STRING होता है. यह STRING, बदले जाने वाले कॉलम के नाम को दिखाता है.

quantile_bucketized_cols

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

आर्ग्युमेंट

STRUCT(string_value AS col_name, int64_value AS num_buckets) का कलेक्शन, जहां हर string_value एक STRING है. यह लगातार मौजूद अंकों वाले कॉलम के नाम को दिखाता है, जिसे बदलना है. साथ ही, हर int64_value, अंकों वाली वैल्यू को बांटने के लिए बकेट की संख्या है.

पुष्टि

• इस क्वेरी के लिए तय की गई तारीख की सीमा में, हर डेटा के दिन के लिए निजता बजट ज़रूर होना चाहिए. इसका मतलब है कि यह बजट, EPSILON_PER_MODEL से ज़्यादा होना चाहिए. ऐसा न होने पर, क्वेरी काम नहीं करेगी.
• अगर ट्यूनिंग के लिए वैकल्पिक पैरामीटर तय किए जाते हैं, तो ऊपर दिखाई गई रेंज के लिए उनकी पुष्टि की जाएगी.
• ज़रूरी model_type पैरामीटर को साफ़ तौर पर बताया जाना चाहिए.
• ट्रेनिंग सेट में मौजूद एक कॉलम का नाम "लेबल" होना चाहिए. फ़िलहाल, एक से ज़्यादा लेबल नहीं जोड़े जा सकते.
• लेबल कॉलम में NULL वैल्यू नहीं हो सकतीं. अगर लेबल कॉलम में कोई वैल्यू मौजूद नहीं है, तो क्वेरी काम नहीं करती.
• कोई भी फ़ीचर कॉलम, user_id से नहीं लिया जा सकता.
• हर लाइन में सिर्फ़ एक यूनीक उपयोगकर्ता की जानकारी होनी चाहिए. एक पंक्ति में एक से ज़्यादा उपयोगकर्ताओं का डेटा नहीं दिखाया जा सकता. ऐसा कुछ खास जॉइन के साथ हो सकता है, जैसे कि क्रॉस जॉइन.
• कोई भी उपयोगकर्ता दो अलग-अलग पंक्तियों में नहीं हो सकता.
• निजता की वजहों से, सिर्फ़ सिंटैक्स सेक्शन में बताए गए विकल्पों का इस्तेमाल किया जा सकता है. फ़िलहाल, BQML CREATE MODEL क्वेरी दस्तावेज़ में मिलने वाले अन्य विकल्प काम नहीं करते.

इवैलुएशन फ़ंक्शन

ML.EVALUATE

मॉडल मेट्रिक का आकलन करने के लिए, ML.EVALUATE फ़ंक्शन का इस्तेमाल करें. ML.EVALUATE फ़ंक्शन का इस्तेमाल, लीनियर रिग्रेशन या लॉजिस्टिक रिग्रेशन मॉडल के साथ किया जा सकता है.

SELECT
  *
FROM ML.EVALUATE(MODEL `linear_model_test`);

ML.ROC_CURVE

लॉजिस्टिक रिग्रेशन से जुड़ी मेट्रिक का आकलन करने के लिए, ML.ROC_CURVE फ़ंक्शन का इस्तेमाल करें. ML.ROC_CURVE सिर्फ़ लॉजिस्टिक रिग्रेशन मॉडल का आकलन करता है.

SELECT
  *
FROM ML.ROC_CURVE(MODEL `logistic_model_test`);

अनुमान लगाने वाले फ़ंक्शन

ML.PREDICT

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

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

/* This example outputs the average value for labels that the model predicted */
SELECT
  AVG(predicted_label) AS average_predicted_label
FROM
  ML.PREDICT(MODEL `linear_model_test`, TABLE tmp.linear_training_set);

लॉजिस्टिक रिग्रेशन

/* This example outputs the model's prediction and probabilities for said prediction over individual users. It groups by label and prediction, counting the number of users in each prediction */
SELECT
  label,
  predicted_label, /* one of the two input labels, depending on which label has the higher predicted probability */
  COUNT(*) AS num /* a tally of users */
FROM
  ML.PREDICT(MODEL `logistic_model_test`, TABLE tmp.logistic_training_set)
GROUP BY 1, 2;

मॉडल और सुविधा की जांच करने वाले फ़ंक्शन

ML.TRAINING_INFO

ML.TRAINING_INFO फ़ंक्शन की मदद से, किसी मॉडल के ट्रेनिंग के बारे में जानकारी देखी जा सकती है.

SELECT
  *
FROM ML.TRAINING_INFO(MODEL `logistic_model_test`);

ML.FEATURE_INFO

ML.FEATURE_INFO फ़ंक्शन की मदद से, मॉडल को ट्रेनिंग देने के लिए इस्तेमाल की गई इनपुट सुविधाओं के बारे में जानकारी देखी जा सकती है

SELECT
  *
FROM ML.FEATURE_INFO(MODEL `logistic_model_test`);

ML.WEIGHTS

ML.WEIGHTS फ़ंक्शन की मदद से, अनुमान लगाने के दौरान मॉडल के इस्तेमाल किए गए वज़न देखे जा सकते हैं.

SELECT
  *
FROM ML.WEIGHTS(MODEL `linear_model_test`);

उदाहरण

मॉडल बनाएं

यहां दिए गए सभी उदाहरणों में, मॉडल बनाने का तरीका दिखाने के लिए natality सैंपल टेबल का इस्तेमाल किया गया है.

इनर-सिलेक्ट (लीनियर) में ट्रेनिंग डेटा

नीचे दिए गए उदाहरण में, बच्चे के जन्म के समय के वज़न का अनुमान लगाने के लिए, जन्म के समय का वज़न, लिंग, गर्भावस्था के हफ़्ते, मां की उम्र, और मां की जाति का इस्तेमाल किया गया है.

CREATE MODEL `natality_model`
OPTIONS
  (model_type='adh_linear_regression') AS
SELECT
  weight_pounds as label,
  is_male,
  gestation_weeks,
  mother_age,
  CAST(mother_race AS string) AS mother_race
FROM
  `bigquery-public-data.samples.natality`
WHERE
  weight_pounds IS NOT NULL

इनर-सिलेक्ट (लॉजिस्टिक) में ट्रेनिंग डेटा

नीचे दिए गए उदाहरण में, बच्चे के लिंग का अनुमान लगाने के लिए, जन्म के समय का वज़न, लिंग, गर्भावस्था के हफ़्ते, मां की उम्र, और मां की जाति का इस्तेमाल किया गया है.

CREATE MODEL `natality_model`
OPTIONS
  (model_type='adh_logistic_regression') AS
SELECT
  weight_pounds,
  is_male as label,
  gestation_weeks,
  mother_age,
  CAST(mother_race AS string) AS mother_race
FROM
  `bigquery-public-data.samples.natality`
WHERE
  weight_pounds IS NOT NULL

ऑडियंस ऐक्टिवेशन

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