डेटा माइनिंग: एक DBMS का उपयोग करके प्राथमिक डेटा प्रोसेसिंग। भाग 3 (सारांश सारणी)

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

उनमें खेतों की संरचना एक क्षेत्र से भिन्न होती है - बची हुई है, जिसका मूल्य हमें परीक्षण डेटा सेट के लिए निर्धारित करना होगा। यहाँ तालिका संरचना titanik_train_3 का वर्णन करने वाला कोड है

CREATE TABLE titanik_train_3 ( id bigint, survived integer, pclass integer, name character varying(255), sex character varying(255), age double precision, sibsp integer, parch integer, ticket character varying(255), fare double precision, cabin character varying(255), embarked character varying(255), cabin_cnt integer, cabin_type text, ticket_type text, ticket_number text, cabin_people_cnt integer ) 

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

 select a.* into titanik_full_1 from ( select * from titanik_train_3 union select id, NULL::integer as survived, pclass, "name", sex , age , sibsp , parch, ticket,fare,cabin,embarked,cabin_cnt,cabin_type,ticket_type,ticket_number, cabin_people_cnt from titanik_test_3 ) as a; 

अब हमें एक तालिका मिलती है जिसमें परीक्षण और प्रशिक्षण डेटा सेट दोनों होते हैं।
हम संख्यात्मक को छोड़कर सभी क्षेत्रों को हटा देते हैं:

  select a.* into titanik_full_2 from ( select id, survived, pclass::float, age::float, sibsp::float, parch::float, fare::float, cabin_cnt::float, CAST(ticket_number as float) as ticket_number, cabin_people_cnt::float from titanik_full_1 where ticket_number != '' union select id, survived, pclass, age, sibsp, parch, fare, cabin_cnt, 0 as ticket_number, cabin_people_cnt from titanik_full_1 where ticket_number = '' ) as a; 

हमें तालिका titanik_full_2 मिलती है, जो इस प्रकार है:

 CREATE TABLE titanik_full_2 ( id bigint, survived integer, pclass integer, age double precision, sibsp integer, parch integer, fare double precision, cabin_cnt integer, ticket_number integer, cabin_people_cnt bigint ) 

अब हम फ़ील्ड द्वारा इस तालिका में जोड़ देंगे, जिसका अर्थ होगा, इस या उस संपत्ति के मूल्य में इस पंक्ति के लिए मान है। ऐसी तालिकाओं को पिवट टेबल कहा जाता है, जो सामान्य से थोड़ी अलग है, मान फ़ील्ड या तो 0 या 1 को स्वीकार करेंगे। योजनाबद्ध रूप से, यह आंकड़ा में दिखाया गया है:

यानी तालिका अब बड़ी हो गई है, फ़ील्ड की संख्या अद्वितीय मानों की संख्या के बराबर होगी। सिद्धांत रूप में, इन सभी मूल्यों को अनुरोध पर मैन्युअल रूप से बनाया जा सकता है। लेकिन PL / PGSQL में एक छोटे से फ़ंक्शन को लिखना बेहतर है जो स्वचालित रूप से खेतों का विस्तार करेगा।

 CREATE OR REPLACE FUNCTION sparse_matrix_generator( tablename_source character varying, tablename_dest character varying, field_name character varying) RETURNS integer AS $$ DECLARE pgst_object REFCURSOR; unival character varying; BEGIN OPEN pgst_object FOR EXECUTE 'select distinct '||field_name ||' from '||tablename_source ||' where ' || field_name ||' NOTNULL'; LOOP FETCH pgst_object INTO unival; EXIT WHEN NOT FOUND; EXECUTE 'ALTER TABLE '|| tablename_dest ||' ADD COLUMN "'|| field_name||unival ||'" smallint NOT NULL DEFAULT 0'; EXECUTE 'UPDATE '||tablename_dest||' SET "'||field_name||unival|| '"= 1 FROM ' ||tablename_source|| ' WHERE '||tablename_dest||'.id = '||tablename_source||'.id and '||field_name||' = '''||unival||''''; END LOOP; RETURN 0; END; $$ LANGUAGE 'plpgsql'; 

यह फ़ंक्शन निम्नानुसार लागू होता है:

 select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'cabin_type'); select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'ticket_type'); select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'embarked'); select sparse_matrix_generator('titanik_full_1', 'titanik_full_2', 'sex'); 

इसलिए अब हमारे पास 58 कॉलम का एक विरल मैट्रिक्स है। इसे सामान्य करने और जीवित क्षेत्र के अनुसार परीक्षण और प्रशिक्षण नमूनों को अलग करने के लिए आवश्यक है।
राशनिंग के अलग-अलग तरीके हैं। विभिन्न डेटा विश्लेषण विधियों के लिए, विभिन्न नमूना आवश्यकताएं हैं। हम सबसे सरल न्यूनतम रेशनिंग में से एक का उपयोग करते हैं। लब्बोलुआब यह है: न्यूनतम 0 होगा, अधिकतम: 1, और बाकी सब उनके बीच आनुपातिक होगा। ऐसा करने के लिए, हम एक फ़ंक्शन लिखते हैं:

 CREATE OR REPLACE FUNCTION minmax_normalizer(tablename_source character varying, field_name character varying) RETURNS integer AS $BODY$ DECLARE pgst_object REFCURSOR; maxval float; minval float; C RECORD; BEGIN EXECUTE 'select min("'||field_name ||'") as minval, max("'||field_name ||'") as maxval from '|| tablename_source INTO C; maxval := C.maxval; minval := C.minval; EXECUTE 'UPDATE '||tablename_source||' SET "'||field_name||'"=("'||field_name||'"-$1)/($2-$1)' USING minval, maxval; RETURN 0; END; $BODY$ LANGUAGE plpgsql VOLATILE COST 100; 

और इसे तालिका के उन क्षेत्रों पर लागू करें जिन्हें सामान्यीकृत करने की आवश्यकता है:

 select minmax_normalizer('titanik_full_2', 'pclass'); select minmax_normalizer('titanik_full_2', 'age'); select minmax_normalizer('titanik_full_2', 'sibsp'); select minmax_normalizer('titanik_full_2', 'parch'); select minmax_normalizer('titanik_full_2', 'fare'); select minmax_normalizer('titanik_full_2', 'cabin_cnt'); select minmax_normalizer('titanik_full_2', 'ticket_number'); select minmax_normalizer('titanik_full_2', 'cabin_people_cnt'); 

परिणामस्वरूप, हमें शून्य से एक तक की सीमा में केवल संख्यात्मक मूल्यों के साथ एक तालिका मिलती है।
एक परीक्षण और प्रशिक्षण नमूना चुनें:

 select * into titanik_test_final from titanik_full_2 where survived isnull; alter table titanik_test_final drop column survived; 

एक परीक्षण नमूने के लिए और तदनुसार:

 select * into titanik_train_final from titanik_full_2 where survived notnull; 

प्रशिक्षण के लिए।
इस तालिका में रिक्त मान हैं। उन्हें प्रतिस्थापित किया जा सकता है, उदाहरण के लिए, औसत मूल्य के साथ। ऐसा करने के लिए, हम फ़ंक्शन का उपयोग करते हैं:

 CREATE OR REPLACE FUNCTION null_normalizer(tablename_source character varying) RETURNS integer AS $BODY$ DECLARE pgst_object REFCURSOR; fieldval character varying; count_null integer; field_avg float; BEGIN OPEN pgst_object FOR EXECUTE 'select column_name from information_schema.columns where'|| ' table_name='''||tablename_source||''''; LOOP FETCH pgst_object INTO fieldval; EXIT WHEN NOT FOUND; count_null := 0; EXECUTE 'select count(id) from '||tablename_source||' where "'||fieldval||'" isnull' into count_null; IF count_null > 0 THEN raise notice 'field: %', fieldval; EXECUTE 'select avg('||fieldval||') from '||tablename_source INTO field_avg; EXECUTE 'UPDATE '||tablename_source||' set '||fieldval||'= $1 where '||fieldval||' isnull' using field_avg; END IF; END LOOP; RETURN 0; END; $BODY$ LANGUAGE plpgsql VOLATILE COST 100; 

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

 select null_normalizer('titanik_test_final'); select null_normalizer('titanik_train_final'); 

परिणामी तालिका काफी बड़ी है और विरल है:

 CREATE TABLE titanik_test_final ( id bigint, pclass double precision, age double precision, sibsp double precision, parch double precision, fare double precision, cabin_cnt double precision, ticket_number double precision, cabin_people_cnt double precision, "cabin_typeF" smallint, "cabin_typeB" smallint, "cabin_typeG" smallint, "cabin_typeC" smallint, "cabin_typeT" smallint, "cabin_typeD" smallint, "cabin_typeE" smallint, "cabin_typeA" smallint, "ticket_typeSW/PP" smallint, "ticket_typeC" smallint, "ticket_typePC" smallint, "ticket_typeAQ/3." smallint, "ticket_typeSC/A.3" smallint, "ticket_typeS.OC" smallint, "ticket_typeS.O./PP" smallint, "ticket_typeSC/AH" smallint, "ticket_typeSOTON/O2" smallint, "ticket_typeC.A." smallint, "ticket_typeW/C" smallint, "ticket_typeS.C./A.4." smallint, "ticket_typeFa" smallint, "ticket_typeLP" smallint, "ticket_typeSCO/W" smallint, "ticket_typeF.C." smallint, "ticket_typeA.5." smallint, "ticket_typeSC/AH Basle" smallint, "ticket_typeSC/A4" smallint, "ticket_typeS.C./PARIS" smallint, "ticket_typeS.OP" smallint, "ticket_typeLINE" smallint, "ticket_typeSO/C" smallint, "ticket_typeP/PP" smallint, "ticket_typeAQ/4" smallint, "ticket_typeSC" smallint, "ticket_typeW.EP" smallint, "ticket_typeSOTON/OQ" smallint, "ticket_typeA/4" smallint, "ticket_typeSC/PARIS" smallint, "ticket_typeA. 2." smallint, "ticket_typeF.CC" smallint, "ticket_typeS.P." smallint, "ticket_typePP" smallint, "ticket_typeC.A./SOTON" smallint, "embarkedC" smallint, "embarkedQ" smallint, "embarkedS" smallint, sexfemale smallint, sexmale smallint ) 

पाठ फ़ाइलों के उत्पादन के लिए, स्क्रिप्ट का उपयोग करें:

 COPY titanik_train_final to '/tmp/titanik_train_final.csv'; COPY titanik_test_final to '/tmp/titanik_test_final.csv'; 

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

यूपीडी: चौथा