Gnuplot बनाम 2MASS

यह लेख एक उदाहरण के रूप में तारकीय वस्तुओं 2MASS के एटलस का उपयोग करके निम्न-स्तरीय कंप्यूटिंग के लाभों का वर्णन करता है।
2MASS ~ 471 मिलियन ऑब्जेक्ट्स हैं जिनके लिए निर्देशांक दिए गए हैं, साथ ही संबंधित जानकारी, कुल 60 विशेषताएँ।
शारीरिक रूप से, यह 50GB स्रोत gzipped text files है।
क्या "भारी तोपखाने" का सहारा लिए बिना इस तरह के आधार के साथ काम करना संभव है?
आइए कोशिश करते हैं।

प्रस्तावना

यह काम 2009 में किया गया था और यह खुद जियो-डीबीएमएस बनाने के लिए डेटाएस्ट के प्रयासों का हिस्सा था।
लक्ष्य डिबग, प्रोफ़ाइल करना और बेंचमार्क क्वेरी प्रोसेसर बनाना था।
एक क्वेरी भाषा के रूप में, ट्यूरोरियल डी बोली को चुना गया था, या बल्कि, इसका संबंध रिलेशनल बीजगणित से संबंधित था। बोली को वास्तविक जीवन की आवश्यकताओं के लिए अनुकूलित किया गया था, विशेष रूप से, कर्सर के साथ काम करने की क्षमता को जोड़ा गया था।

हालाँकि, यह सिर्फ संदर्भ है और इस पोस्ट का उद्देश्य पिछली जीत के बारे में एक कहानी नहीं है जो "बारिश में आँसू की तरह पिघल गया", लेकिन सीधे DBMS कर्सर में गणना की अधिकतम हस्तांतरण की तकनीक का प्रदर्शन है।
बेशक, आप इस तकनीक को पीएल / एसक्यूएल उपकरणों के साथ संग्रहीत प्रक्रियाओं और / या समुच्चय का उपयोग करके लागू कर सकते हैं।

परिचय

डेटा तैयार करने की प्रक्रिया पर विस्तार से ध्यान देने का कोई मतलब नहीं है, मान लें कि डेटा को भरने के लिए 8h 26min और स्थानिक अनुक्रमण के लिए 1h 17min लिया।
स्रोत डेटा के साथ एक सत्यापन अनुरोध शामिल है।

select count(*) as rows, sum(pts_key::bigint) as sum_pts_key, sum(pxcntr::bigint) as sum_pxcntr, sum(scan_key::bigint) as sum_scan_key, sum(scan::bigint) as sum_scan, sum(ext_key::bigint) as sum_ext_key, sum(coadd_key::bigint) as sum_coadd_key, sum(coadd::bigint) as sum_coadd, sum(mp_flg) as sum_mp_flg, sum(gal_contam) as sum_gal_contam, sum(use_src) as sum_use_src, sum(dup_src) as sum_dup_src, sum(nopt_mchs) as sum_nopt_mchs, sum(phi_opt::bigint) as sum_phi_opt, sum(dist_edge_ew::bigint) as sum_dist_edge_ew, sum(dist_edge_ns::bigint) as sum_dist_edge_ns, sum(err_ang::bigint) as sum_err_ang FROM twomass_psc; 

हमारे मामले में, यह क्वेरी जैसा दिखेगा

 select "PSC" chew { "rows" INTEGER, "sum_pts_key" INTEGER, "sum_pxcntr" INTEGER, "sum_scan_key" INTEGER, "sum_scan" INTEGER, "sum_ext_key" INTEGER, "sum_coadd_key" INTEGER, "sum_coadd" INTEGER, "sum_mp_flg" INTEGER, "sum_gal_contam" INTEGER, "sum_use_src" INTEGER, "sum_dup_src "INTEGER, "sum_nopt_mchs" INTEGER, "sum_phi_opt" INTEGER, "sum_dist_edge_ew" INTEGER, "sum_dist_edge_ns" INTEGER, "sum_err_ang" INTEGER } hook "init" { "rows" := 0; "sum_pts_key" := 0; ... "sum_err_ang" := 0; } hook "row" { "rows" := "rows" + 1; if (not isnull("pts_key/cntr")) then "sum_pts_key" := "sum_pts_key" + "pts_key/cntr"; end if; ... if (not isnull("err_ang")) then "sum_err_ang" := "sum_err_ang" + "err_ang"; end if; } hook "finit" { call __interrupt (); }; 

निष्पादन का परिणाम इस प्रकार है:

 INFO: start [04/Jun/2009:09:37:45:822] ----------------------------------------------------------------- rows sum_pts_key sum_pxcntr sum_scan_key sum_scan sum_ext_key sum_coadd_key sum_coadd sum_mp_flg sum_gal_contam sum_use_src sum_dup_src sum_nopt_mchs sum_phi_opt sum_dist_edge_ew sum_dist_edge_ns sum_err_ang ----------------------------------------------------------------- 470992970 306810325437475788 306815556538478936 16902776758555 32666066948 2048692118201 388758631396659 64617139213 16048 729878 464456155 79798372 369187043 64916239773 69388217174 2670725813652 29279563815 ----------------------------------------------------------------- INFO: stop [04/Jun/2009:12:35:59:571] 

यहां, चॉव ऑपरेटर का उपयोग मूल डेटा स्ट्रीम (संपूर्ण तालिका) को सिंथेटिक में बदलने के लिए किया जाता है, कुछ क्षेत्रों के साथ जो स्थानीय चर बन जाते हैं। हुक ऑपरेटर (SQL समुच्चय के समान) का उपयोग घटनाओं की सदस्यता के लिए किया जाता है - एक स्ट्रीम शुरू / रोकें और एक स्ट्रिंग प्राप्त करें। जब __interrupt को कहा जाता है , स्थानीय चर के वर्तमान मान परिणाम में आते हैं।

परिणाम सत्यापन वालों के साथ मेल खाते हैं, जिसका अर्थ है कि डेटा काम के लिए तैयार है।
ऑपरेटिंग समय - 3 घंटे, निरंतर देखने के दौरान प्रति कॉलम लगभग 10 मिनट। यह गति (Intel Core2 P4-2.4 GHz, 2Gb, डिस्क ST3400620AS पर) आगे के सभी अनुरोधों के लिए विशिष्ट है। दूसरी ओर, अगर हमने स्रोत पाठ फ़ाइलों को अनपैक किया और उन्हें GAWK के माध्यम से संसाधित किया, तो उदाहरण के लिए, डेटा को पढ़ने के लिए 50 एमबी / एस = 1000 सेकंड पर हमें 50 जीबी लगेगा और उसी राशि को अनपैक करने के लिए, 35 मिनट सिर्फ स्ट्रीम को व्यवस्थित करने के लिए। Wc के माध्यम से सभी डेटा को अनपैक करना और चलाना एक घंटे और आधे घंटे का था।

जो लोग अपनी आँखों से सब कुछ देखना चाहते हैं, उनके लिए आकाश का एक प्लेट दोष है:

कुछ लोगों ने शाही बेड़े की युद्ध रेखाओं के लिए उनसे गलती की।

डाटा माइनिंग

सरल आँकड़े। अधिकतम, न्यूनतम, औसत - चलो "जेएम" कॉलम (डिफ़ॉल्ट जे-बैंड परिमाण) के साथ खेलते हैं।

 select "PSC" chew { "nrows" INTEGER, "nulls_j_m" INTEGER, "num_j_m" INTEGER, "sum_j_m" RATIONAL, "avg_j_m" RATIONAL, "max_j_m" RATIONAL, "min_j_m" RATIONAL } hook "init" { "nrows" := 0; "nulls_j_m" := 0; "num_j_m" := 0; "sum_j_m" := 0; "avg_j_m" := 0; "max_j_m" := -1e66; "min_j_m" := 1e66; } hook "row" { nrows := nrows + 1; if (isnull("j_m")) then "nulls_j_m" := "nulls_j_m" + 1; else "num_j_m" := "num_j_m" + 1; "sum_j_m" := "sum_j_m" + "j_m"; if ("max_j_m"<"j_m") then "max_j_m" := "j_m"; end if; if ("min_j_m">"j_m") then "min_j_m" := "j_m"; end if; end if; } hook "finit" { "avg_j_m" := "sum_j_m" / "num_j_m"; call __interrupt (); }; 

परिणाम:

 INFO: start [04/Jun/2009:15:00:54:821] -------------------------------------------------------------------- nrows nulls_j_m num_j_m sum_j_m avg_j_m max_j_m min_j_m -------------------------------------------------------------------- 470992970 19 470992951 7.15875e+009 15.1993 25.86 -2.989 -------------------------------------------------------------------- INFO: stop [04/Jun/2009:15:18:47:743] 

फैलाव:

 select "PSC" chew { "nrows" INTEGER, "nulls_j_m" INTEGER, "num_j_m" INTEGER, "disp_j_m" RATIONAL } hook "init" { "nrows" := 0; "nulls_j_m" := 0; "num_j_m" := 0; "disp_j_m" := 0; var tmp rational; var tavg rational; tavg := 15.1993; -- previously calculated } hook "row" { nrows := nrows + 1; if (isnull("j_m")) then "nulls_j_m" := "nulls_j_m" + 1; else "num_j_m" := "num_j_m" + 1; tmp := "j_m" - tavg; tmp := tmp * tmp; "disp_j_m" := "disp_j_m" + tmp; end if; } hook "finit" { "disp_j_m" := "disp_j_m" / "num_j_m"; call __interrupt (); }; 

परिणाम :

 INFO: start [04/Jun/2009:15:48:27:274] -------------------------------------------------------------------- nrows nulls_j_m num_j_m disp_j_m -------------------------------------------------------------------- 470992970 19 470992951 1.98223 -------------------------------------------------------------------- INFO: stop [04/Jun/2009:16:05:01:946 

हिस्टोग्राम:

 select "PSC" chew { "j_m_cell" rational, "num" INTEGER } hook "init" { var tmp integer; var tmp2 integer; var tmax rational; tmax := 26.; -- previously calculated var tmin rational; tmin := -5.; -- previously calculated var ncells integer; ncells := 500; var tcell rational; tcell := (tmax - tmin)/ncells; var htptr integer; htptr := hti_alloc (0); call hti_set (htptr, 0, 0); } hook "row" { if (not isnull("j_m")) then tmp := ("j_m" - tmin)/tcell; tmp2 := hti_get (htptr, tmp); tmp2 := tmp2 + 1; call hti_set (htptr, tmp, tmp2); end if; } hook "finit" { tmp := 0; while tmp < ncells; begin; "j_m_cell" := tmin + tcell * tmp + tcell * 0.5; "num" := hti_get (htptr, tmp); tmp := tmp + 1; call __interrupt (); end; end while; call hti_free (htptr); }; 

हिस्टोग्राम कोशिकाओं में संचय एक हैश तालिका का उपयोग भाषा में सरणियों की अनुपस्थिति के कारण होता है। इस मामले में, परिणाम हिस्टोग्राम कोशिकाओं का एक प्रिंटआउट होगा, जो gnuplot के माध्यम से देखने के लिए सुविधाजनक है। निम्नलिखित तस्वीर में, स्तंभों के लिए प्रिंटआउट भी जोड़े गए हैं "किमी" (डिफ़ॉल्ट केएस-बैंड परिमाण) और "एचएम" (डिफ़ॉल्ट एच-बैंड परिमाण)।


3 डी
हिस्टोग्राम पर "किमी" और "एचएम" बहुत समान दिखते हैं, लेकिन साझा वितरण के बारे में क्या?

 select "PSC" chew { "cell" rational, "num" INTEGER } hook "init" { var tmp integer; var tmp2 integer; var tmp4 integer; var tmax rational; tmax := 25; var tmin rational; tmin := -5.; var ncells integer; ncells := 512; var tcell rational; tcell := (tmax - tmin)/ncells; var "hnd" integer; hnd:= img_create ( ncells, ncells, tmin, tmin, tmax, tmax, 1); var cl integer; cl := img_alloc_color (hnd, 255,0,0); } hook "row" { if ((not isnull("h_m")) and (not isnull("k_m"))) then tmp := img_get_point (hnd, "h_m", "k_m"); tmp := tmp + 1; call img_draw_point (hnd, "h_m", "k_m", tmp); end if; } hook "finit" { tmp := 0; while tmp < ncells; begin; tmp2 := 0; while tmp2 < ncells; begin; tmp4 := img_get_point (hnd, tmin + tcell * tmp, tmin + tcell * tmp2); call print ((tmin + tmp * tcell)+' '+ (tmin + tmp2* tcell)+' '+tmp4+'\n'); if tmp4 > 0 then tmp4 := cl; else tmp4 := 0; end if; call img_draw_point (hnd, tmin + tcell * tmp, tmin + tcell * tmp2, cl); tmp2 := tmp2 + 1; end; end while; tmp := tmp + 1; end; end while; call img_saveas (hnd, 'stat4.gif'); call img_destroy (hnd); }; 

इस उदाहरण में, दो-आयामी हिस्टोग्राम को संग्रहीत करने के लिए, हमने जीडी प्लग-इन का उपयोग करके प्राप्त एक छवि छवि का उपयोग किया, जो कि कोशिकाओं में होने वाले लॉगरिदम को फिर से देखने के लिए देख रहे थे, जो कि pm3d मोड में gnuplot टूल का उपयोग कर रहे थे ।

"J_m" के वितरण के लिए एक समान तस्वीर - "k_m" बनाम "h_m" - "k_m":

इन हिस्टोग्राम के निर्माण में प्रति कॉलम ~ 35 मिनट - 12 मिनट लगते हैं।
लेकिन क्या होगा अगर हमें एक विशिष्ट स्थानिक डोमेन पर इस तरह के वितरण का निर्माण करने की आवश्यकता है? क्या हम इसे सेकंड में कर सकते हैं? बेशक:
स्थानिक प्रतिबंधों के साथ नमूना ।

 select "PSC" where sp_overlap ("Point", [rational:xmin], [rational:ymin], [rational:xmax], [rational:ymax]) chew { "m_cell" rational, "num" INTEGER } … -- below is the same text 

Sp_overlap को जोड़ने से मूल पहचानकर्ता स्ट्रीम तालिका से स्थानिक सूचकांक में बदल गई।

कोशिकाओं के निचले बाएं कोनों में नमूनों के विस्तार का संकेत दिया जाता है।

उत्तरदायी प्रतिबंधों के बारे में क्या?
यह अंतरिक्ष में सीमित करने जितना आसान है।

 select "PSC" where “j_snr” < 10. -- or you may combine your restrictions adding -- and sp_overlap ("Point", … ) chew { "m_cell" rational, "num" INTEGER } … -- below is the same text 

और यहाँ परिणाम है।

कुल मिलाकर

हमें कर्सर में गणना का हस्तांतरण क्या देता है?

• गति , जगह में डेटा पढ़ने की प्रक्रिया, हम क्रमांकन से मुक्त हैं, नेटवर्क पर भेज रहे हैं, प्राप्त कर रहे हैं, deserializing ...
• संग्रहीत संसाधन , उदाहरण के लिए, आधा अरब लाइनें, नेटवर्क पर भेजी जा रही हैं, लंबे समय तक अपने थ्रूपुट के उचित हिस्से पर कब्जा कर लेंगी

और इस तकनीक से हमें क्या खतरा है?

• हमें स्वयं सब कुछ करना होगा, और यह त्रुटियों का एक संभावित स्रोत है।
• एल्गोरिदम जिसमें वास्तव में बहुत सारी गणनाएं साझा सर्वर पर प्रदर्शन करने के लिए बहुत सुविधाजनक नहीं हैं।
• सभी गणना स्ट्रीम में नहीं की जा सकती हैं।

यह सब सच है, लेकिन लेखक का दावा नहीं है कि यह हमेशा किया जाना चाहिए, यह डेटा के साथ काम करने के लिए कई उपकरणों में से एक है, यद्यपि सुविधाजनक, विशेष रूप से काम के अनुसंधान भाग के लिए, उदाहरण के लिए, जब परिकल्पनाओं को जल्दी से जांचने और संशोधित करने की आवश्यकता होती है।