कागल होम क्रेडिट डिफॉल्ट रिस्क कॉम्पिटिशन - डेटा एनालिसिस और सिंपल प्रेडिक्टिव मॉडल

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



( यहां से तस्वीर)

होम क्रेडिट ग्रुप बैंकों और गैर-बैंक क्रेडिट संगठनों का एक समूह है जो 11 देशों (गृह ऋण और वित्त बैंक एलएलसी के रूप में रूस सहित) में संचालन करता है। प्रतियोगिता का उद्देश्य उन उधारकर्ताओं की साख का आकलन करने के लिए एक कार्यप्रणाली तैयार करना है, जिनके पास क्रेडिट इतिहास नहीं है। जो इस मामले में उत्कृष्ट है - इस श्रेणी के उधारकर्ता अक्सर बैंक से कोई क्रेडिट प्राप्त नहीं कर सकते हैं और स्कैमर और माइक्रोलोन्स को चालू करने के लिए मजबूर होते हैं। यह दिलचस्प है कि ग्राहक मॉडल की पारदर्शिता और व्याख्या के लिए आवश्यकताओं को निर्धारित नहीं करता है (जैसा कि आमतौर पर बैंकों के साथ होता है), आप कुछ भी उपयोग कर सकते हैं, यहां तक ​​कि एक तंत्रिका नेटवर्क भी।

प्रशिक्षण के नमूने में 300+ हजार रिकॉर्ड होते हैं, बहुत सारे संकेत हैं - 122, उनमें से कई श्रेणीबद्ध (गैर-संख्यात्मक) हैं। संकेत उधारकर्ता को पर्याप्त विवरण में वर्णित करते हैं, नीचे उस सामग्री से जिसमें से उसके घर की दीवारें बनाई जाती हैं। डेटा का हिस्सा 6 अतिरिक्त तालिकाओं (क्रेडिट ब्यूरो, क्रेडिट कार्ड बैलेंस और पिछले ऋणों पर डेटा) में निहित है, इन आंकड़ों को भी किसी तरह संसाधित किया जाना चाहिए और मुख्य लोगों को लोड किया जाना चाहिए।

प्रतियोगिता एक मानक वर्गीकरण कार्य की तरह दिखती है (TARGET क्षेत्र में 1 का अर्थ है भुगतान के साथ कोई कठिनाई, 0 का अर्थ है कोई कठिनाई नहीं)। हालांकि, यह 0/1 नहीं है, जिसकी भविष्यवाणी की जानी चाहिए, लेकिन समस्याओं की संभावना (जो, संयोगवश, सभी जटिल मॉडल के पूर्वानुभव की भविष्यवाणी के तरीकों से आसानी से हल हो सकती है)।

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

कर्नेल ध्यान देने योग्य हैं:

• ईडीए शुरुआती और सरल मॉडल के लिए एक विस्तृत विवरण के साथ
• प्लॉटली पैकेज + ब्यूरो डेटा अपलोड के साथ डीप ईडीए
• Seaborn पैकेज के साथ अच्छा EDA
• समस्या और डिफ़ॉल्ट उधारकर्ताओं का तुलनात्मक विश्लेषण
• 0.714 की अंतिम गति के साथ तीन संकेतों पर 15-लाइन लाइट जीबीएम
• क्रेडिट ब्यूरो के अनुसार संकेतों का विश्लेषण
• प्रसंस्करण जोड़ें। टेबल + लाइट जीबीएम

डेटा के साथ काम करने के लिए, आमतौर पर निम्नलिखित योजना की सिफारिश की जाती है, जिसका हम अनुसरण करने का प्रयास करेंगे।

1. समस्या को समझना और डेटा से परिचित होना
2. डेटा की सफाई और स्वरूपण
3. EDA
4. बेस मॉडल
5. मॉडल में सुधार
6. मॉडल की व्याख्या

इस मामले में, आपको इस तथ्य को ध्यान में रखने की आवश्यकता है कि डेटा काफी व्यापक है और अभी इसे प्रबल नहीं किया जा सकता है, यह चरणों में कार्य करने के लिए समझ में आता है।

आइए उन पुस्तकालयों को आयात करके शुरू करें जिन्हें हमें टेबल के रूप में डेटा के साथ काम करने के लिए विश्लेषण की आवश्यकता है, ग्राफ़ का निर्माण, और मैट्रिस के साथ काम करना है।

import pandas as pd import matplotlib.pyplot as plt import numpy as np import seaborn as sns %matplotlib inline 

डेटा डाउनलोड करें। आइए देखें कि हम सभी के पास क्या है। "../Input/" निर्देशिका में यह स्थान, कागल पर अपनी गुठली लगाने की आवश्यकता के साथ जुड़ा हुआ है।

 import os PATH="../input/" print(os.listdir(PATH)) 

['application_test.csv', 'application_train.csv', 'bureau.csv', 'bureau_balance.csv', 'credit_card_balance.csv', 'HomeCredit_columns_description.csv', 'installments_payments.csv', 'POS_CASH_balance.csv', 'previous_application.csv']

डेटा के साथ 8 तालिकाएँ हैं (तालिका की गिनती नहीं कर रहे हैं HomeCredit_columns_description.csv, जिसमें फ़ील्ड का विवरण शामिल है), जो निम्नानुसार परस्पर जुड़े हुए हैं:



application_train / application_test: मास्टर डेटा, उधारकर्ता की पहचान SK_ID_CURR द्वारा की जाती है
ब्यूरो: क्रेडिट ब्यूरो से अन्य क्रेडिट संस्थानों से पिछले ऋण पर डेटा
bureau_balance: पिछले ब्यूरो ऋण पर मासिक डेटा। प्रत्येक पंक्ति ऋण का उपयोग करने का महीना है
पिछला_आवेदन: होम क्रेडिट में ऋण के लिए पिछले आवेदन, प्रत्येक में एक विशिष्ट फ़ील्ड SK_ID_PREV है
POS_CASH_BALANCE: सामानों की खरीद के लिए नकद और ऋण जारी करने के साथ होम क्रेडिट में ऋण पर मासिक डेटा
credit_card_balance: होम क्रेडिट में मासिक क्रेडिट कार्ड बैलेंस डेटा
किश्तों_ भुगतान: होम क्रेडिट पर पिछले ऋणों का भुगतान इतिहास।

आइए हम पहले मुख्य डेटा स्रोत पर ध्यान केंद्रित करें और देखें कि इसमें से कौन सी जानकारी निकाली जा सकती है और किन मॉडलों का निर्माण करना है। मूल डेटा डाउनलोड करें।

• app_train = pd.read_csv (PATH + 'application_train.csv',)
• app_test = pd.read_csv (PATH + 'application_test.csv',)
• प्रिंट ("प्रशिक्षण सेट प्रारूप:", app_train.shape)
• प्रिंट ("परीक्षण नमूना प्रारूप:", app_test.shape)
• प्रशिक्षण नमूना प्रारूप: (307511, 122)
• परीक्षण नमूना प्रारूप: (48744, 121)

कुल मिलाकर, हमारे पास प्रशिक्षण नमूने में 307 हजार रिकॉर्ड और 122 संकेत हैं और परीक्षण में 49 हजार रिकॉर्ड और 121 संकेत हैं। विसंगति स्पष्ट रूप से इस तथ्य के कारण है कि परीक्षण के नमूने में कोई लक्ष्य विशेषता लक्ष्य नहीं है, और हम इसकी भविष्यवाणी करेंगे।

आइए डेटा पर करीब से नज़र डालें

 pd.set_option('display.max_columns', None) #  pandas     app_train.head() 

(पहले 8 कॉलम दिखाए गए)

इस प्रारूप में डेटा देखना काफी कठिन है। आइए कॉलम की सूची देखें:

app_train.info(max_cols=122)
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 307511 entries, 0 to 307510
Data columns (total 122 columns):
SK_ID_CURR 307511 non-null int64
TARGET 307511 non-null int64
NAME_CONTRACT_TYPE 307511 non-null object
CODE_GENDER 307511 non-null object
FLAG_OWN_CAR 307511 non-null object
FLAG_OWN_REALTY 307511 non-null object
CNT_CHILDREN 307511 non-null int64
AMT_INCOME_TOTAL 307511 non-null float64
AMT_CREDIT 307511 non-null float64
AMT_ANNUITY 307499 non-null float64
AMT_GOODS_PRICE 307233 non-null float64
NAME_TYPE_SUITE 306219 non-null object
NAME_INCOME_TYPE 307511 non-null object
NAME_EDUCATION_TYPE 307511 non-null object
NAME_FAMILY_STATUS 307511 non-null object
NAME_HOUSING_TYPE 307511 non-null object
REGION_POPULATION_RELATIVE 307511 non-null float64
DAYS_BIRTH 307511 non-null int64
DAYS_EMPLOYED 307511 non-null int64
DAYS_REGISTRATION 307511 non-null float64
DAYS_ID_PUBLISH 307511 non-null int64
OWN_CAR_AGE 104582 non-null float64
FLAG_MOBIL 307511 non-null int64
FLAG_EMP_PHONE 307511 non-null int64
FLAG_WORK_PHONE 307511 non-null int64
FLAG_CONT_MOBILE 307511 non-null int64
FLAG_PHONE 307511 non-null int64
FLAG_EMAIL 307511 non-null int64
OCCUPATION_TYPE 211120 non-null object
CNT_FAM_MEMBERS 307509 non-null float64
REGION_RATING_CLIENT 307511 non-null int64
REGION_RATING_CLIENT_W_CITY 307511 non-null int64
WEEKDAY_APPR_PROCESS_START 307511 non-null object
HOUR_APPR_PROCESS_START 307511 non-null int64
REG_REGION_NOT_LIVE_REGION 307511 non-null int64
REG_REGION_NOT_WORK_REGION 307511 non-null int64
LIVE_REGION_NOT_WORK_REGION 307511 non-null int64
REG_CITY_NOT_LIVE_CITY 307511 non-null int64
REG_CITY_NOT_WORK_CITY 307511 non-null int64
LIVE_CITY_NOT_WORK_CITY 307511 non-null int64
ORGANIZATION_TYPE 307511 non-null object
EXT_SOURCE_1 134133 non-null float64
EXT_SOURCE_2 306851 non-null float64
EXT_SOURCE_3 246546 non-null float64
APARTMENTS_AVG 151450 non-null float64
BASEMENTAREA_AVG 127568 non-null float64
YEARS_BEGINEXPLUATATION_AVG 157504 non-null float64
YEARS_BUILD_AVG 103023 non-null float64
COMMONAREA_AVG 92646 non-null float64
ELEVATORS_AVG 143620 non-null float64
ENTRANCES_AVG 152683 non-null float64
FLOORSMAX_AVG 154491 non-null float64
FLOORSMIN_AVG 98869 non-null float64
LANDAREA_AVG 124921 non-null float64
LIVINGAPARTMENTS_AVG 97312 non-null float64
LIVINGAREA_AVG 153161 non-null float64
NONLIVINGAPARTMENTS_AVG 93997 non-null float64
NONLIVINGAREA_AVG 137829 non-null float64
APARTMENTS_MODE 151450 non-null float64
BASEMENTAREA_MODE 127568 non-null float64
YEARS_BEGINEXPLUATATION_MODE 157504 non-null float64
YEARS_BUILD_MODE 103023 non-null float64
COMMONAREA_MODE 92646 non-null float64
ELEVATORS_MODE 143620 non-null float64
ENTRANCES_MODE 152683 non-null float64
FLOORSMAX_MODE 154491 non-null float64
FLOORSMIN_MODE 98869 non-null float64
LANDAREA_MODE 124921 non-null float64
LIVINGAPARTMENTS_MODE 97312 non-null float64
LIVINGAREA_MODE 153161 non-null float64
NONLIVINGAPARTMENTS_MODE 93997 non-null float64
NONLIVINGAREA_MODE 137829 non-null float64
APARTMENTS_MEDI 151450 non-null float64
BASEMENTAREA_MEDI 127568 non-null float64
YEARS_BEGINEXPLUATATION_MEDI 157504 non-null float64
YEARS_BUILD_MEDI 103023 non-null float64
COMMONAREA_MEDI 92646 non-null float64
ELEVATORS_MEDI 143620 non-null float64
ENTRANCES_MEDI 152683 non-null float64
FLOORSMAX_MEDI 154491 non-null float64
FLOORSMIN_MEDI 98869 non-null float64
LANDAREA_MEDI 124921 non-null float64
LIVINGAPARTMENTS_MEDI 97312 non-null float64
LIVINGAREA_MEDI 153161 non-null float64
NONLIVINGAPARTMENTS_MEDI 93997 non-null float64
NONLIVINGAREA_MEDI 137829 non-null float64
FONDKAPREMONT_MODE 97216 non-null object
HOUSETYPE_MODE 153214 non-null object
TOTALAREA_MODE 159080 non-null float64
WALLSMATERIAL_MODE 151170 non-null object
EMERGENCYSTATE_MODE 161756 non-null object
OBS_30_CNT_SOCIAL_CIRCLE 306490 non-null float64
DEF_30_CNT_SOCIAL_CIRCLE 306490 non-null float64
OBS_60_CNT_SOCIAL_CIRCLE 306490 non-null float64
DEF_60_CNT_SOCIAL_CIRCLE 306490 non-null float64
DAYS_LAST_PHONE_CHANGE 307510 non-null float64
FLAG_DOCUMENT_2 307511 non-null int64
FLAG_DOCUMENT_3 307511 non-null int64
FLAG_DOCUMENT_4 307511 non-null int64
FLAG_DOCUMENT_5 307511 non-null int64
FLAG_DOCUMENT_6 307511 non-null int64
FLAG_DOCUMENT_7 307511 non-null int64
FLAG_DOCUMENT_8 307511 non-null int64
FLAG_DOCUMENT_9 307511 non-null int64
FLAG_DOCUMENT_10 307511 non-null int64
FLAG_DOCUMENT_11 307511 non-null int64
FLAG_DOCUMENT_12 307511 non-null int64
FLAG_DOCUMENT_13 307511 non-null int64
FLAG_DOCUMENT_14 307511 non-null int64
FLAG_DOCUMENT_15 307511 non-null int64
FLAG_DOCUMENT_16 307511 non-null int64
FLAG_DOCUMENT_17 307511 non-null int64
FLAG_DOCUMENT_18 307511 non-null int64
FLAG_DOCUMENT_19 307511 non-null int64
FLAG_DOCUMENT_20 307511 non-null int64
FLAG_DOCUMENT_21 307511 non-null int64
AMT_REQ_CREDIT_BUREAU_HOUR 265992 non-null float64
AMT_REQ_CREDIT_BUREAU_DAY 265992 non-null float64
AMT_REQ_CREDIT_BUREAU_WEEK 265992 non-null float64
AMT_REQ_CREDIT_BUREAU_MON 265992 non-null float64
AMT_REQ_CREDIT_BUREAU_QRT 265992 non-null float64
AMT_REQ_CREDIT_BUREAU_YEAR 265992 non-null float64
dtypes: float64(65), int64(41), object(16)
memory usage: 286.2+ MB

HomeCredit_columns_description फ़ाइल में फ़ील्ड द्वारा विस्तृत एनोटेशन याद करें। जैसा कि आप जानकारी से देख सकते हैं, डेटा का हिस्सा अधूरा है और भाग श्रेणीबद्ध है, उन्हें ऑब्जेक्ट के रूप में प्रदर्शित किया जाता है। अधिकांश मॉडल ऐसे डेटा के साथ काम नहीं करते हैं, हमें इसके साथ कुछ करना होगा। इस पर, प्रारंभिक विश्लेषण को पूरा माना जा सकता है, हम सीधे ईडीए के पास जाएंगे

खोजपूर्ण डेटा विश्लेषण या प्राथमिक डेटा खनन

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

लक्ष्य वितरण वितरण

 app_train.TARGET.value_counts() 

0 282686
1 24825
Name: TARGET, dtype: int64

 plt.style.use('fivethirtyeight') plt.rcParams["figure.figsize"] = [8,5]​ plt.hist(app_train.TARGET) plt.show()  plt.style.use('fivethirtyeight') plt.rcParams["figure.figsize"] = [8,5]​ plt.hist(app_train.TARGET) plt.show() 

मैं आपको याद दिला दूं कि 1 का मतलब किसी भी तरह की समस्याओं से होता है, 0 का मतलब कोई समस्या नहीं है। जैसा कि आप देख सकते हैं, मुख्य रूप से उधारकर्ताओं को पुनर्भुगतान में कोई समस्या नहीं है, समस्याग्रस्त का हिस्सा लगभग 8% है। इसका मतलब है कि कक्षाएं संतुलित नहीं हैं और मॉडल बनाते समय इसे ध्यान में रखना पड़ सकता है।

मिसिंग डेटा रिसर्च

हमने देखा है कि डेटा की कमी काफी है। आइए अधिक विस्तार से देखें कि कहां और क्या गायब है।

 #      def missing_values_table(df): #   mis_val = df.isnull().sum() #    mis_val_percent = 100 * df.isnull().sum() / len(df) #    mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1) #   mis_val_table_ren_columns = mis_val_table.rename( columns = {0 : 'Missing Values', 1 : '% of Total Values'}) #    mis_val_table_ren_columns = mis_val_table_ren_columns[ mis_val_table_ren_columns.iloc[:,1] != 0].sort_values( '% of Total Values', ascending=False).round(1) #  print ("   " + str(df.shape[1]) + " .\n" " " + str(mis_val_table_ren_columns.shape[0]) + "    .") #     return mis_val_table_ren_columns missing_values = missing_values_table(app_train) missing_values.head(10) 

122 .
67 .


ग्राफिक प्रारूप में:

 plt.style.use('seaborn-talk')​ fig = plt.figure(figsize=(18,6)) miss_train = pd.DataFrame((app_train.isnull().sum())*100/app_train.shape[0]).reset_index() miss_test = pd.DataFrame((app_test.isnull().sum())*100/app_test.shape[0]).reset_index() miss_train["type"] = "" miss_test["type"] = "" missing = pd.concat([miss_train,miss_test],axis=0) ax = sns.pointplot("index",0,data=missing,hue="type") plt.xticks(rotation =90,fontsize =7) plt.title("    ") plt.ylabel("  %") plt.xlabel("")  plt.style.use('seaborn-talk')​ fig = plt.figure(figsize=(18,6)) miss_train = pd.DataFrame((app_train.isnull().sum())*100/app_train.shape[0]).reset_index() miss_test = pd.DataFrame((app_test.isnull().sum())*100/app_test.shape[0]).reset_index() miss_train["type"] = "" miss_test["type"] = "" missing = pd.concat([miss_train,miss_test],axis=0) ax = sns.pointplot("index",0,data=missing,hue="type") plt.xticks(rotation =90,fontsize =7) plt.title("    ") plt.ylabel("  %") plt.xlabel("") 

"इस सबका क्या करना है" सवाल के कई जवाब हैं। आप इसे शून्य से भर सकते हैं, आप मध्ययुगीन मूल्यों का उपयोग कर सकते हैं, आप आवश्यक जानकारी के बिना बस लाइनें हटा सकते हैं। यह सब उस मॉडल पर निर्भर करता है जिसका हम उपयोग करने की योजना बनाते हैं, क्योंकि उनमें से कुछ लापता मूल्यों के साथ पूरी तरह से सामना करते हैं। जबकि हम इस तथ्य को याद रखते हैं और सब कुछ छोड़ देते हैं।

कॉलम प्रकार और श्रेणीबद्ध कोडिंग

जैसा कि हमें याद है। स्तंभों का हिस्सा प्रकार ऑब्जेक्ट का है, अर्थात इसमें संख्यात्मक मान नहीं है, लेकिन यह कुछ श्रेणी को दर्शाता है। आइए इन स्तंभों को अधिक बारीकी से देखें।

 app_train.dtypes.value_counts() 

float64 65
int64 41
object 16
dtype: int64

 app_train.select_dtypes(include=[object]).apply(pd.Series.nunique, axis = 0) 

NAME_CONTRACT_TYPE 2
CODE_GENDER 3
FLAG_OWN_CAR 2
FLAG_OWN_REALTY 2
NAME_TYPE_SUITE 7
NAME_INCOME_TYPE 8
NAME_EDUCATION_TYPE 5
NAME_FAMILY_STATUS 6
NAME_HOUSING_TYPE 6
OCCUPATION_TYPE 18
WEEKDAY_APPR_PROCESS_START 7
ORGANIZATION_TYPE 58
FONDKAPREMONT_MODE 4
HOUSETYPE_MODE 3
WALLSMATERIAL_MODE 7
EMERGENCYSTATE_MODE 2
dtype: int64

हमारे पास 16 कॉलम हैं, जिनमें से प्रत्येक में 2 से 58 विभिन्न मूल्य विकल्प हैं। सामान्य तौर पर, मशीन लर्निंग मॉडल ऐसे कॉलम के साथ कुछ नहीं कर सकते हैं (कुछ को छोड़कर, जैसे कि लाइट जीबीएम या कैटबॉस्ट)। चूंकि हम डेटासेट पर विभिन्न मॉडलों की कोशिश करने की योजना बनाते हैं, इसलिए इसके साथ कुछ करने की आवश्यकता है। मूल रूप से दो दृष्टिकोण हैं:

• लेबल एनकोडिंग - श्रेणियों को 0, 1, 2 और इसी तरह के अंक दिए गए हैं और एक ही कॉलम में लिखे गए हैं
• एक-हॉट-एन्कोडिंग - एक कॉलम विकल्पों की संख्या के अनुसार कई में विघटित हो जाता है और ये कॉलम इंगित करते हैं कि यह रिकॉर्ड किस विकल्प का है।

लोकप्रिय लोगों के बीच, यह ध्यान देने योग्य लक्ष्य एन्कोडिंग (स्पष्टीकरण roryorangepants के लिए धन्यवाद) के लायक है ।

लेबल एन्कोडिंग के साथ एक छोटी सी समस्या है - यह संख्यात्मक मान प्रदान करता है जिनका वास्तविकता से कोई लेना-देना नहीं है। उदाहरण के लिए, यदि हम एक संख्यात्मक मान के साथ काम कर रहे हैं, तो 100,000 की उधारकर्ता की आय निश्चित रूप से 20,000 की आय से अधिक से अधिक और बेहतर है। लेकिन क्या यह कहा जा सकता है कि, उदाहरण के लिए, एक शहर दूसरे से बेहतर है क्योंकि एक को मूल्य 100 और दूसरे को 200 आवंटित किया गया है। ?

दूसरी ओर एक-हॉट-एन्कोडिंग, अधिक सुरक्षित है, लेकिन "अतिरिक्त" कॉलम का उत्पादन कर सकता है। उदाहरण के लिए, यदि हम वन-हॉट का उपयोग करते हुए समान लिंग को एनकोड करते हैं, तो हमें दो कॉलम मिलते हैं, "पुरुष लिंग" और "महिला लिंग", हालांकि एक पर्याप्त होगा, "यह पुरुष है"।

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

 app_train = pd.get_dummies(app_train) app_test = pd.get_dummies(app_test)​ print('Training Features shape: ', app_train.shape) print('Testing Features shape: ', app_test.shape)  app_train = pd.get_dummies(app_train) app_test = pd.get_dummies(app_test)​ print('Training Features shape: ', app_train.shape) print('Testing Features shape: ', app_test.shape) 

Training Features shape: (307511, 246)
Testing Features shape: (48744, 242)

चूंकि चयन कॉलम में विकल्पों की संख्या समान नहीं है, इसलिए कॉलम की संख्या अब मेल नहीं खाती। संरेखण आवश्यक है - आपको प्रशिक्षण सेट से स्तंभों को हटाने की आवश्यकता है जो परीक्षण सेट में नहीं हैं। यह संरेखित विधि बनाता है, आपको अक्ष = 1 (कॉलम के लिए) निर्दिष्ट करने की आवश्यकता है।

 # ,           . train_labels = app_train['TARGET']​ #  -   .     app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)​ print('  : ', app_train.shape) print('  : ', app_test.shape)​ # Add target back in to the data app_train['TARGET'] = train_labels  # ,           . train_labels = app_train['TARGET']​ #  -   .     app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)​ print('  : ', app_train.shape) print('  : ', app_test.shape)​ # Add target back in to the data app_train['TARGET'] = train_labels  # ,           . train_labels = app_train['TARGET']​ #  -   .     app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)​ print('  : ', app_train.shape) print('  : ', app_test.shape)​ # Add target back in to the data app_train['TARGET'] = train_labels  # ,           . train_labels = app_train['TARGET']​ #  -   .     app_train, app_test = app_train.align(app_test, join = 'inner', axis = 1)​ print('  : ', app_train.shape) print('  : ', app_test.shape)​ # Add target back in to the data app_train['TARGET'] = train_labels 

: (307511, 242)
: (48744, 242)

डेटा सहसंबंध

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

• 00 -19 "बहुत कमजोर"
• 20 -39 "कमजोर"
• 40 -59 "औसत"
• 60 -79 मजबूत
• 80-1.0 "बहुत मजबूत"

 #    correlations = app_train.corr()['TARGET'].sort_values()​ #  print('  : \n', correlations.tail(15)) print('\n  : \n', correlations.head(15))  #    correlations = app_train.corr()['TARGET'].sort_values()​ #  print('  : \n', correlations.tail(15)) print('\n  : \n', correlations.head(15)) 

:
DAYS_REGISTRATION 0.041975
OCCUPATION_TYPE_Laborers 0.043019
FLAG_DOCUMENT_3 0.044346
REG_CITY_NOT_LIVE_CITY 0.044395
FLAG_EMP_PHONE 0.045982
NAME_EDUCATION_TYPE_Secondary / secondary special 0.049824
REG_CITY_NOT_WORK_CITY 0.050994
DAYS_ID_PUBLISH 0.051457
CODE_GENDER_M 0.054713
DAYS_LAST_PHONE_CHANGE 0.055218
NAME_INCOME_TYPE_Working 0.057481
REGION_RATING_CLIENT 0.058899
REGION_RATING_CLIENT_W_CITY 0.060893
DAYS_BIRTH 0.078239
TARGET 1.000000
Name: TARGET, dtype: float64

:
EXT_SOURCE_3 -0.178919
EXT_SOURCE_2 -0.160472
EXT_SOURCE_1 -0.155317
NAME_EDUCATION_TYPE_Higher education -0.056593
CODE_GENDER_F -0.054704
NAME_INCOME_TYPE_Pensioner -0.046209
ORGANIZATION_TYPE_XNA -0.045987
DAYS_EMPLOYED -0.044932
FLOORSMAX_AVG -0.044003
FLOORSMAX_MEDI -0.043768
FLOORSMAX_MODE -0.043226
EMERGENCYSTATE_MODE_No -0.042201
HOUSETYPE_MODE_block of flats -0.040594
AMT_GOODS_PRICE -0.039645
REGION_POPULATION_RELATIVE -0.037227
Name: TARGET, dtype: float64

इस प्रकार, सभी डेटा कमजोर रूप से लक्ष्य के साथ सहसंबद्ध होते हैं (केवल लक्ष्य को छोड़कर, जो, ज़ाहिर है, स्वयं के बराबर है)। हालांकि, उम्र और कुछ "बाहरी डेटा स्रोत" डेटा से अलग हैं। यह संभवतः अन्य क्रेडिट संगठनों के कुछ अतिरिक्त डेटा हैं। यह हास्यास्पद है कि यद्यपि लक्ष्य को क्रेडिट निर्णय लेने में ऐसे डेटा से स्वतंत्रता के रूप में घोषित किया गया है, वास्तव में हम मुख्य रूप से उन पर आधारित होंगे।

आयु

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

 app_train['DAYS_BIRTH'] = abs(app_train['DAYS_BIRTH']) app_train['DAYS_BIRTH'].corr(app_train['TARGET']) 

-0.078239308309827088

चलो चर पर एक करीब देखो। आइए हिस्टोग्राम के साथ शुरू करें।

 #     ,  25  plt.hist(app_train['DAYS_BIRTH'] / 365, edgecolor = 'k', bins = 25) plt.title('Age of Client'); plt.xlabel('Age (years)'); plt.ylabel('Count'); 

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

 # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'DAYS_BIRTH'] / 365, label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'DAYS_BIRTH'] / 365, label = 'target == 1')​ #  plt.xlabel('Age (years)'); plt.ylabel('Density'); plt.title('Distribution of Ages');  # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'DAYS_BIRTH'] / 365, label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'DAYS_BIRTH'] / 365, label = 'target == 1')​ #  plt.xlabel('Age (years)'); plt.ylabel('Density'); plt.title('Distribution of Ages');  # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'DAYS_BIRTH'] / 365, label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'DAYS_BIRTH'] / 365, label = 'target == 1')​ #  plt.xlabel('Age (years)'); plt.ylabel('Density'); plt.title('Distribution of Ages'); 

जैसा कि देखा जा सकता है, कम उम्र के लोगों के लिए चूक का हिस्सा अधिक है और बढ़ती उम्र के साथ कम हो जाता है। यह हमेशा युवाओं को ऋण देने से इनकार करने का एक कारण नहीं है, इस तरह की "सिफारिश" केवल बैंक के लिए आय और बाजार का नुकसान होगा। यह ऐसे ऋणों की अधिक गहन निगरानी, ​​मूल्यांकन और संभवतः, यहां तक ​​कि युवा उधारकर्ताओं के लिए कुछ प्रकार की वित्तीय शिक्षा के बारे में सोचने का अवसर है।

बाहरी स्रोत

चलो "बाहरी डेटा स्रोतों" EXT_SOURCE और उनके सहसंबंध पर करीब से नज़र डालें।

 ext_data = app_train[['TARGET', 'EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH']] ext_data_corrs = ext_data.corr() ext_data_corrs 

हीटमैप का उपयोग करके सहसंबंध प्रदर्शित करना भी सुविधाजनक है

 sns.heatmap(ext_data_corrs, cmap = plt.cm.RdYlBu_r, vmin = -0.25, annot = True, vmax = 0.6) plt.title('Correlation Heatmap'); 

जैसा कि आप देख सकते हैं, सभी स्रोत लक्ष्य के साथ एक नकारात्मक सहसंबंध दिखाते हैं। आइए प्रत्येक स्रोत के लिए केडीई के वितरण को देखें।

 plt.figure(figsize = (10, 12))​ #    for i, source in enumerate(['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']): #  plt.subplot(3, 1, i + 1) #    sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, source], label = 'target == 0') #    sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, source], label = 'target == 1') #  plt.title('Distribution of %s by Target Value' % source) plt.xlabel('%s' % source); plt.ylabel('Density'); plt.tight_layout(h_pad = 2.5)  plt.figure(figsize = (10, 12))​ #    for i, source in enumerate(['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3']): #  plt.subplot(3, 1, i + 1) #    sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, source], label = 'target == 0') #    sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, source], label = 'target == 1') #  plt.title('Distribution of %s by Target Value' % source) plt.xlabel('%s' % source); plt.ylabel('Density'); plt.tight_layout(h_pad = 2.5) 

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

जोड़ी अनुसूची

इन चरों के संबंधों को बेहतर ढंग से समझने के लिए, आप एक जोड़ी चार्ट बना सकते हैं, इसमें हम प्रत्येक जोड़ी के संबंध और विकर्ण के साथ वितरण का एक हिस्टोग्राम देख सकते हैं। विकर्ण के ऊपर, आप स्कैप्लॉट दिखा सकते हैं, और नीचे - 2 डी केडीई।

 #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05);  #       age_data = app_train[['TARGET', 'DAYS_BIRTH']] age_data['YEARS_BIRTH'] = age_data['DAYS_BIRTH'] / 365​ #     plot_data = ext_data.drop(labels = ['DAYS_BIRTH'], axis=1).copy()​ #   plot_data['YEARS_BIRTH'] = age_data['YEARS_BIRTH']​ #         100 .  plot_data = plot_data.dropna().loc[:100000, :]​ #     def corr_func(x, y, **kwargs): r = np.corrcoef(x, y)[0][1] ax = plt.gca() ax.annotate("r = {:.2f}".format(r), xy=(.2, .8), xycoords=ax.transAxes, size = 20)​ #   pairgrid object grid = sns.PairGrid(data = plot_data, size = 3, diag_sharey=False, hue = 'TARGET', vars = [x for x in list(plot_data.columns) if x != 'TARGET'])​ #  -  grid.map_upper(plt.scatter, alpha = 0.2)​ #  -  grid.map_diag(sns.kdeplot)​ #  -   grid.map_lower(sns.kdeplot, cmap = plt.cm.OrRd_r);​ plt.suptitle('Ext Source and Age Features Pairs Plot', size = 32, y = 1.05); 

चुकाने योग्य ऋण नीले रंग में दिखाए जाते हैं, गैर-चुकौती लाल रंग में। यह सब व्याख्या करना मुश्किल है, लेकिन टी-शर्ट या आधुनिक कला के संग्रहालय में एक तस्वीर पर एक अच्छा प्रिंट इस तस्वीर से बाहर आ सकता है।

अन्य संकेतों की परीक्षा

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

 application_train = pd.read_csv(PATH+"application_train.csv") application_test = pd.read_csv(PATH+"application_test.csv") 

हमें वितरण चर और लक्ष्य चर पर उनके प्रभाव को खूबसूरती से प्रदर्शित करने के लिए कुछ कार्यों की भी आवश्यकता होगी। इस कर्नेल के लेखक के लिए उन्हें बहुत धन्यवाद

 def plot_stats(feature,label_rotation=False,horizontal_layout=True): temp = application_train[feature].value_counts() df1 = pd.DataFrame({feature: temp.index,' ': temp.values})​ #   target=1   cat_perc = application_train[[feature, 'TARGET']].groupby([feature],as_index=False).mean() cat_perc.sort_values(by='TARGET', ascending=False, inplace=True) if(horizontal_layout): fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,6)) else: fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(12,14)) sns.set_color_codes("pastel") s = sns.barplot(ax=ax1, x = feature, y=" ",data=df1) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) s = sns.barplot(ax=ax2, x = feature, y='TARGET', order=cat_perc[feature], data=cat_perc) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) plt.ylabel(' ', fontsize=10) plt.tick_params(axis='both', which='major', labelsize=10)​ plt.show();  def plot_stats(feature,label_rotation=False,horizontal_layout=True): temp = application_train[feature].value_counts() df1 = pd.DataFrame({feature: temp.index,' ': temp.values})​ #   target=1   cat_perc = application_train[[feature, 'TARGET']].groupby([feature],as_index=False).mean() cat_perc.sort_values(by='TARGET', ascending=False, inplace=True) if(horizontal_layout): fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,6)) else: fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(12,14)) sns.set_color_codes("pastel") s = sns.barplot(ax=ax1, x = feature, y=" ",data=df1) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) s = sns.barplot(ax=ax2, x = feature, y='TARGET', order=cat_perc[feature], data=cat_perc) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) plt.ylabel(' ', fontsize=10) plt.tick_params(axis='both', which='major', labelsize=10)​ plt.show();  def plot_stats(feature,label_rotation=False,horizontal_layout=True): temp = application_train[feature].value_counts() df1 = pd.DataFrame({feature: temp.index,' ': temp.values})​ #   target=1   cat_perc = application_train[[feature, 'TARGET']].groupby([feature],as_index=False).mean() cat_perc.sort_values(by='TARGET', ascending=False, inplace=True) if(horizontal_layout): fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12,6)) else: fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(12,14)) sns.set_color_codes("pastel") s = sns.barplot(ax=ax1, x = feature, y=" ",data=df1) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) s = sns.barplot(ax=ax2, x = feature, y='TARGET', order=cat_perc[feature], data=cat_perc) if(label_rotation): s.set_xticklabels(s.get_xticklabels(),rotation=90) plt.ylabel(' ', fontsize=10) plt.tick_params(axis='both', which='major', labelsize=10)​ plt.show(); 

इसलिए, हम ग्राहकों के मुख्य संकेतों पर विचार करेंगे

ऋण का प्रकार

 plot_stats('NAME_CONTRACT_TYPE') 

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

ग्राहक लिंग

 plot_stats('CODE_GENDER') 

पुरुषों की तुलना में लगभग दो गुना अधिक महिला ग्राहक हैं, पुरुषों में बहुत अधिक जोखिम है।

कार और संपत्ति का स्वामित्व

 plot_stats('FLAG_OWN_CAR') plot_stats('FLAG_OWN_REALTY') 

कार के ग्राहक आधे "हॉर्सलेस" हैं। जोखिम लगभग समान है, मशीन वाले ग्राहक थोड़ा बेहतर भुगतान करते हैं।

अचल संपत्ति के लिए, विपरीत सच है - इसके बिना कुछ ग्राहक आधे हैं। संपत्ति के मालिकों के लिए जोखिम भी थोड़ा कम है।

वैवाहिक स्थिति

 plot_stats('NAME_FAMILY_STATUS',True, True) 

जबकि अधिकांश ग्राहक विवाहित हैं, सबसे जोखिम भरा नागरिक और एकल ग्राहक हैं। विधुर न्यूनतम जोखिम दिखाते हैं।

बच्चों की संख्या

 plot_stats('CNT_CHILDREN') 

ज्यादातर ग्राहक निःसंतान हैं। इसी समय, 9 और 11 बच्चों वाले ग्राहक पूर्ण गैर-वापसी दिखाते हैं

 application_train.CNT_CHILDREN.value_counts() 

0 215371
1 61119
2 26749
3 3717
4 429
5 84
6 21
7 7
14 3
19 2
12 2
10 2
9 2
8 2
11 1
Name: CNT_CHILDREN, dtype: int64

जैसा कि मूल्यों की गणना से पता चलता है, यह डेटा सांख्यिकीय रूप से महत्वहीन है - दोनों श्रेणियों के केवल 1-2 ग्राहक। हालांकि, सभी तीन डिफ़ॉल्ट में चले गए, जैसा कि 6 बच्चों वाले आधे ग्राहकों ने किया था।

परिवार के सदस्यों की संख्या

 plot_stats('CNT_FAM_MEMBERS',True) 

स्थिति समान है - कम मुंह, उच्च वापसी।

आय का प्रकार

 plot_stats('NAME_INCOME_TYPE',False,False) 

एकल माताओं और बेरोजगारों के आवेदन के चरण में काट दिए जाने की संभावना है - नमूने में उनमें से बहुत कम हैं। लेकिन समस्याएं काफी हद तक दिख रही हैं।

गतिविधि का प्रकार

 plot_stats('OCCUPATION_TYPE',True, False) 

 application_train.OCCUPATION_TYPE.value_counts() 

Laborers 55186
Sales staff 32102
Core staff 27570
Managers 21371
Drivers 18603
High skill tech staff 11380
Accountants 9813
Medicine staff 8537
Security staff 6721
Cooking staff 5946
Cleaning staff 4653
Private service staff 2652
Low-skill Laborers 2093
Waiters/barmen staff 1348
Secretaries 1305
Realty agents 751
HR staff 563
IT staff 526
Name: OCCUPATION_TYPE, dtype: int64

यह उन ड्राइवरों और सुरक्षा अधिकारियों के लिए रूचि रखता है जो काफी हैं और अन्य श्रेणियों की तुलना में अधिक बार समस्याओं का सामना करते हैं।

गठन

 plot_stats('NAME_EDUCATION_TYPE',True) 

उच्च शिक्षा, बेहतर पुनरावृत्ति, स्पष्ट रूप से।

संगठन का प्रकार - नियोक्ता

 plot_stats('ORGANIZATION_TYPE',True, False) 

गैर-रिटर्न का उच्चतम प्रतिशत परिवहन में टाइप किया गया है: टाइप 3 (16%), उद्योग: प्रकार 13 (13.5%), उद्योग: टाइप 8 (12.5%) और रेस्तरां (12% तक)।

ऋण आवंटन

ऋण राशियों के वितरण और पुनर्भुगतान पर उनके प्रभाव पर विचार करें

 plt.figure(figsize=(12,5)) plt.title(" AMT_CREDIT") ax = sns.distplot(app_train["AMT_CREDIT"]) 

 plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'AMT_CREDIT'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'AMT_CREDIT'], label = 'target == 1')​ #  plt.xlabel(' '); plt.ylabel(''); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'AMT_CREDIT'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'AMT_CREDIT'], label = 'target == 1')​ #  plt.xlabel(' '); plt.ylabel(''); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'AMT_CREDIT'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'AMT_CREDIT'], label = 'target == 1')​ #  plt.xlabel(' '); plt.ylabel(''); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'AMT_CREDIT'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'AMT_CREDIT'], label = 'target == 1')​ #  plt.xlabel(' '); plt.ylabel(''); plt.title(' '); 

जैसा कि घनत्व ग्राफ दिखाता है, मजबूत मात्रा अधिक बार लौटाई जाती है

घनत्व वितरण

 plt.figure(figsize=(12,5)) plt.title(" REGION_POPULATION_RELATIVE") ax = sns.distplot(app_train["REGION_POPULATION_RELATIVE"]) 

 plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'REGION_POPULATION_RELATIVE'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'REGION_POPULATION_RELATIVE'], label = 'target == 1')​ #  plt.xlabel(''); plt.ylabel(' '); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'REGION_POPULATION_RELATIVE'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'REGION_POPULATION_RELATIVE'], label = 'target == 1')​ #  plt.xlabel(''); plt.ylabel(' '); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'REGION_POPULATION_RELATIVE'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'REGION_POPULATION_RELATIVE'], label = 'target == 1')​ #  plt.xlabel(''); plt.ylabel(' '); plt.title(' ');  plt.figure(figsize=(12,5))​ # KDE ,   sns.kdeplot(app_train.loc[app_train['TARGET'] == 0, 'REGION_POPULATION_RELATIVE'], label = 'target == 0')​ # KDE   sns.kdeplot(app_train.loc[app_train['TARGET'] == 1, 'REGION_POPULATION_RELATIVE'], label = 'target == 1')​ #  plt.xlabel(''); plt.ylabel(' '); plt.title(' '); 

अधिक आबादी वाले क्षेत्र के ग्राहक बेहतर ऋण का भुगतान करते हैं।

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

फ़ीचर इंजीनियरिंग - फ़ीचर रूपांतरण

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

परिवर्तनों को बदलने की प्रक्रिया में नए उपलब्ध डेटा का निर्माण, सबसे महत्वपूर्ण उपलब्ध का चयन, आदि शामिल हो सकते हैं। हम इस बार बहुपद संकेत की कोशिश करेंगे।

बहुपद संकेत

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

 #       poly_features = app_train[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH', 'TARGET']] poly_features_test = app_test[['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH']]​ #    from sklearn.preprocessing import Imputer imputer = Imputer(strategy = 'median')​ poly_target = poly_features['TARGET']​ poly_features = poly_features.drop('TARGET', axis=1)​ poly_features = imputer.fit_transform(poly_features) poly_features_test = imputer.transform(poly_features_test) from sklearn.preprocessing import PolynomialFeatures #     3 poly_transformer = PolynomialFeatures(degree = 3) #    poly_transformer.fit(poly_features) #   poly_features = poly_transformer.transform(poly_features) poly_features_test = poly_transformer.transform(poly_features_test) print('  : ', poly_features.shape) 

: (307511, 35)
get_feature_names

 poly_transformer.get_feature_names(input_features = ['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH'])[:15] 

['1',
'EXT_SOURCE_1',
'EXT_SOURCE_2',
'EXT_SOURCE_3',
'DAYS_BIRTH',
'EXT_SOURCE_1^2',
'EXT_SOURCE_1 EXT_SOURCE_2',
'EXT_SOURCE_1 EXT_SOURCE_3',
'EXT_SOURCE_1 DAYS_BIRTH',
'EXT_SOURCE_2^2',
'EXT_SOURCE_2 EXT_SOURCE_3',
'EXT_SOURCE_2 DAYS_BIRTH',
'EXT_SOURCE_3^2',
'EXT_SOURCE_3 DAYS_BIRTH',
'DAYS_BIRTH^2']

कुल 35 बहुपद और व्युत्पन्न विशेषताएं। लक्ष्य के साथ उनके सहसंबंध की जाँच करें।

 #     poly_features = pd.DataFrame(poly_features, columns = poly_transformer.get_feature_names(['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH']))​ #   poly_features['TARGET'] = poly_target​ #   poly_corrs = poly_features.corr()['TARGET'].sort_values()​ #      print(poly_corrs.head(10)) print(poly_corrs.tail(5)) 

EXT_SOURCE_2 EXT_SOURCE_3 -0.193939
EXT_SOURCE_1 EXT_SOURCE_2 EXT_SOURCE_3 -0.189605
EXT_SOURCE_2 EXT_SOURCE_3 DAYS_BIRTH -0.181283
EXT_SOURCE_2^2 EXT_SOURCE_3 -0.176428
EXT_SOURCE_2 EXT_SOURCE_3^2 -0.172282
EXT_SOURCE_1 EXT_SOURCE_2 -0.166625
EXT_SOURCE_1 EXT_SOURCE_3 -0.164065
EXT_SOURCE_2 -0.160295
EXT_SOURCE_2 DAYS_BIRTH -0.156873
EXT_SOURCE_1 EXT_SOURCE_2^2 -0.156867
Name: TARGET, dtype: float64
DAYS_BIRTH -0.078239
DAYS_BIRTH^2 -0.076672
DAYS_BIRTH^3 -0.074273
TARGET 1.000000
1 NaN
Name: TARGET, dtype: float64

तो, कुछ संकेत मूल की तुलना में एक उच्च सहसंबंध दिखाते हैं। यह उनके और उनके बिना सीखने की कोशिश करने के लिए समझ में आता है (जैसे मशीन सीखने में बहुत अधिक, यह प्रयोगात्मक रूप से निर्धारित किया जा सकता है)। ऐसा करने के लिए, डेटाफ्रेम की एक प्रति बनाएँ और वहां नई सुविधाएँ जोड़ें।

 #      poly_features_test = pd.DataFrame(poly_features_test, columns = poly_transformer.get_feature_names(['EXT_SOURCE_1', 'EXT_SOURCE_2', 'EXT_SOURCE_3', 'DAYS_BIRTH']))​ #    poly_features['SK_ID_CURR'] = app_train['SK_ID_CURR'] app_train_poly = app_train.merge(poly_features, on = 'SK_ID_CURR', how = 'left')​ #    poly_features_test['SK_ID_CURR'] = app_test['SK_ID_CURR'] app_test_poly = app_test.merge(poly_features_test, on = 'SK_ID_CURR', how = 'left')​ #   app_train_poly, app_test_poly = app_train_poly.align(app_test_poly, join = 'inner', axis = 1)​ #   print('    : ', app_train_poly.shape) print('    : ', app_test_poly.shape) 

: (307511, 277)
: (48744, 277)

मॉडल प्रशिक्षण

मूल स्तर

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

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

लॉजिस्टिक रिग्रेशन की गणना करने के लिए , हमें कोडेड श्रेणीबद्ध विशेषताओं के साथ तालिकाओं को लेने, लापता डेटा को भरने और उन्हें सामान्य करने की आवश्यकता है (उन्हें 0 से 1 तक मानों पर लाएं)। यह सब निम्नलिखित कोड निष्पादित करता है:

 from sklearn.preprocessing import MinMaxScaler, Imputer​ #      if 'TARGET' in app_train: train = app_train.drop(labels = ['TARGET'], axis=1) else: train = app_train.copy() features = list(train.columns)​ #    test = app_test.copy()​ #     imputer = Imputer(strategy = 'median')​ #  scaler = MinMaxScaler(feature_range = (0, 1))​ #    imputer.fit(train)​ #      train = imputer.transform(train) test = imputer.transform(app_test)​ #      scaler.fit(train) train = scaler.transform(train) test = scaler.transform(test)​ print('  : ', train.shape) print('  : ', test.shape) 

: (307511, 242)
: (48744, 242)

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

 from sklearn.linear_model import LogisticRegression​ #   log_reg = LogisticRegression(C = 0.0001)​ #   log_reg.fit(train, train_labels) LogisticRegression(C=0.0001, class_weight=None, dual=False, fit_intercept=True, intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1, penalty='l2', random_state=None, solver='liblinear', tol=0.0001, verbose=0, warm_start=False)      .  prdict_proba     mx 2,  m -  ,   -  0,  -  1.    ( ). log_reg_pred = log_reg.predict_proba(test)[:, 1] 

अब आप कागल को अपलोड करने के लिए एक फ़ाइल बना सकते हैं। ग्राहक आईडी से डेटा फ्रेम बनाएं और बिना रिटर्न की संभावना और इसे अपलोड करें।

 submit = app_test[['SK_ID_CURR']] submit['TARGET'] = log_reg_pred​ submit.head() 

SK_ID_CURR TARGET
0 100001 0.087954
1 100005 0.163151
2 100013 0.109923
3 100028 0.077124
4 100038 0.151694

 submit.to_csv('log_reg_baseline.csv', index = False) 

इसलिए, हमारे टाइटैनिक कार्य का परिणाम: 0.673, आज के लिए सबसे अच्छा परिणाम 0.802 है।

बेहतर मॉडल - यादृच्छिक वन

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

 from sklearn.ensemble import RandomForestClassifier​ #   random_forest = RandomForestClassifier(n_estimators = 100, random_state = 50)​ #     random_forest.fit(train, train_labels)​ #     predictions = random_forest.predict_proba(test)[:, 1]​ #     submit = app_test[['SK_ID_CURR']] submit['TARGET'] = predictions​ #  submit.to_csv('random_forest_baseline.csv', index = False) 

यादृच्छिक वन परिणाम थोड़ा बेहतर है - 0.683

बहुपद सुविधाओं के साथ प्रशिक्षण मॉडल

अब जब हमारे पास एक मॉडल है। जो कम से कम कुछ करता है - यह हमारे बहुपद संकेतों का परीक्षण करने का समय है। आइए उनके साथ भी ऐसा ही करें और परिणाम की तुलना करें।

 poly_features_names = list(app_train_poly.columns)​ #         imputer = Imputer(strategy = 'median')​ poly_features = imputer.fit_transform(app_train_poly) poly_features_test = imputer.transform(app_test_poly)​ #  scaler = MinMaxScaler(feature_range = (0, 1))​ poly_features = scaler.fit_transform(poly_features) poly_features_test = scaler.transform(poly_features_test)​ random_forest_poly = RandomForestClassifier(n_estimators = 100, random_state = 50) #     random_forest_poly.fit(poly_features, train_labels)​ #  predictions = random_forest_poly.predict_proba(poly_features_test)[:, 1]​ #    submit = app_test[['SK_ID_CURR']] submit['TARGET'] = predictions​ #   submit.to_csv('random_forest_baseline_engineered.csv', index = False) 

बहुपद सुविधाओं के साथ एक यादृच्छिक वन का परिणाम बदतर हो गया है - 0.633। जो उनके उपयोग की आवश्यकता पर सवाल उठाता है।

धीरे-धीरे बूस्ट

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

 from lightgbm import LGBMClassifier​ clf = LGBMClassifier() clf.fit(train, train_labels)​ predictions = clf.predict_proba(test)[:, 1]​ #    submit = app_test[['SK_ID_CURR']] submit['TARGET'] = predictions​ #   submit.to_csv('lightgbm_baseline.csv', index = False) 

लाइट जीबीएम का परिणाम 0.735 है, जो अन्य सभी मॉडलों को पीछे छोड़ देता है।

मॉडल व्याख्या - सुविधाओं का महत्व

किसी मॉडल की व्याख्या करने का सबसे आसान तरीका सुविधाओं के महत्व को देखना है (जो सभी मॉडल नहीं कर सकते हैं)। चूंकि हमारे क्लासिफायरियर ने सरणी को संसाधित किया है, इसलिए इस सरणी के कॉलम के अनुसार कॉलम नामों को फिर से सेट करने में कुछ काम लगेगा।

 #      def show_feature_importances(model, features): plt.figure(figsize = (12, 8)) #          results = pd.DataFrame({'feature': features, 'importance': model.feature_importances_}) results = results.sort_values('importance', ascending = False) #  print(results.head(10)) print('\n     0.01 = ', np.sum(results['importance'] > 0.01)) #  results.head(20).plot(x = 'feature', y = 'importance', kind = 'barh', color = 'red', edgecolor = 'k', title = 'Feature Importances'); return results #         feature_importances = show_feature_importances(clf, features) 

उम्मीद की जा सकती है, सबसे महत्वपूर्ण सभी एक ही 4 सुविधाओं मॉडल करने के लिए। विशेषताओं का महत्व मॉडल व्याख्या का सबसे अच्छा तरीका नहीं है, लेकिन यह आपको मुख्य कारकों को समझने की अनुमति देता है जो मॉडल भविष्यवाणियों के लिए उपयोग करता हैfeature importance
28 EXT_SOURCE_1 310
30 EXT_SOURCE_3 282
29 EXT_SOURCE_2 271
7 DAYS_BIRTH 192
3 AMT_CREDIT 161
4 AMT_ANNUITY 142
5 AMT_GOODS_PRICE 129
8 DAYS_EMPLOYED 127
10 DAYS_ID_PUBLISH 102
9 DAYS_REGISTRATION 69

0.01 = 158

अन्य तालिकाओं से डेटा जोड़ना

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

 import gc​ #del app_train, app_test, train_labels, application_train, application_test, poly_features, poly_features_test​ gc.collect() import pandas as pd import numpy as np​ from sklearn.preprocessing import MinMaxScaler, LabelEncoder from sklearn.model_selection import train_test_split, KFold from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix from sklearn.feature_selection import VarianceThreshold​ from lightgbm import LGBMClassifier 

डेटा आयात करें, तुरंत लक्ष्य कॉलम को एक अलग कॉलम में हटा दें

 data = pd.read_csv('../input/application_train.csv') test = pd.read_csv('../input/application_test.csv') prev = pd.read_csv('../input/previous_application.csv') buro = pd.read_csv('../input/bureau.csv') buro_balance = pd.read_csv('../input/bureau_balance.csv') credit_card = pd.read_csv('../input/credit_card_balance.csv') POS_CASH = pd.read_csv('../input/POS_CASH_balance.csv') payments = pd.read_csv('../input/installments_payments.csv')​ #Separate target variable y = data['TARGET'] del data['TARGET'] 

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

 categorical_features = [col for col in data.columns if data[col].dtype == 'object']​ one_hot_df = pd.concat([data,test]) one_hot_df = pd.get_dummies(one_hot_df, columns=categorical_features)​ data = one_hot_df.iloc[:data.shape[0],:] test = one_hot_df.iloc[data.shape[0]:,]​ print ('  ', data.shape) print ('  ', test.shape) 

(307511, 245)
(48744, 245)

मासिक ऋण शेष पर क्रेडिट ब्यूरो डेटा।

 buro_balance.head() 

MONTHS_BALANCE - ऋण के लिए आवेदन की तिथि से पहले की महीनों की संख्या। "स्थितियों" पर करीब से नज़र डालें

 buro_balance.STATUS.value_counts() 

C 13646993
0 7499507
X 5810482
1 242347
5 62406
2 23419
3 8924
4 5847
Name: STATUS, dtype: int64

स्टेटस का अर्थ निम्न है:

- बंद, यानी चुकाया हुआ ऋण। X एक अज्ञात स्थिति है। 0 - वर्तमान ऋण, कोई विलंब नहीं। 1 - 1-30 दिनों की देरी, 2 - 31-60 दिनों की देरी, और इसी तरह स्थिति 5 तक - ऋण को तीसरे पक्ष को बेच दिया जाता है या लिखा जाता है।

यहाँ, उदाहरण के लिए, निम्नलिखित संकेतों को अलग किया जा सकता है: buro_grouped_size - डेटाबेस में प्रविष्टियों की संख्या buro_grouped_max - अधिकतम ऋण शेष buro_grouped_min - न्यूनतम ऋण शेष राशि

और इन सभी ऋण स्थितियों को एन्कोड किया जा सकता है (हम अनस्टैक विधि का उपयोग करते हैं, और फिर प्राप्त आंकड़ों को buoc तालिका में शामिल करते हैं। SK_ID_BUREAU यहां और वहां समान है।

 buro_grouped_size = buro_balance.groupby('SK_ID_BUREAU')['MONTHS_BALANCE'].size() buro_grouped_max = buro_balance.groupby('SK_ID_BUREAU')['MONTHS_BALANCE'].max() buro_grouped_min = buro_balance.groupby('SK_ID_BUREAU')['MONTHS_BALANCE'].min()​ buro_counts = buro_balance.groupby('SK_ID_BUREAU')['STATUS'].value_counts(normalize = False) buro_counts_unstacked = buro_counts.unstack('STATUS') buro_counts_unstacked.columns = ['STATUS_0', 'STATUS_1','STATUS_2','STATUS_3','STATUS_4','STATUS_5','STATUS_C','STATUS_X',] buro_counts_unstacked['MONTHS_COUNT'] = buro_grouped_size buro_counts_unstacked['MONTHS_MIN'] = buro_grouped_min buro_counts_unstacked['MONTHS_MAX'] = buro_grouped_max​ buro = buro.join(buro_counts_unstacked, how='left', on='SK_ID_BUREAU') del buro_balance gc.collect() 

क्रेडिट ब्यूरो पर सामान्य जानकारी

 buro.head() 

(पहले 7 कॉलम दिखाए गए हैं)

बहुत सारे डेटा हैं जो सामान्य तौर पर, आप बस एक-हॉट-एन्कोडिंग के साथ सांकेतिक शब्दों में बदलना करने के लिए प्रयास कर सकते हैं, SK_ID_CURR द्वारा समूह, औसत और, उसी तरह, मुख्य तालिका के साथ जुड़ने की तैयारी करें

 buro_cat_features = [bcol for bcol in buro.columns if buro[bcol].dtype == 'object'] buro = pd.get_dummies(buro, columns=buro_cat_features) avg_buro = buro.groupby('SK_ID_CURR').mean() avg_buro['buro_count'] = buro[['SK_ID_BUREAU', 'SK_ID_CURR']].groupby('SK_ID_CURR').count()['SK_ID_BUREAU'] del avg_buro['SK_ID_BUREAU'] del buro gc.collect() 

पिछले अनुप्रयोगों पर डेटा

 prev.head() 

इसी तरह, हम श्रेणीगत विशेषताओं को एन्कोड करते हैं, औसत करते हैं और वर्तमान आईडी से जोड़ते हैं।

 prev_cat_features = [pcol for pcol in prev.columns if prev[pcol].dtype == 'object'] prev = pd.get_dummies(prev, columns=prev_cat_features) avg_prev = prev.groupby('SK_ID_CURR').mean() cnt_prev = prev[['SK_ID_CURR', 'SK_ID_PREV']].groupby('SK_ID_CURR').count() avg_prev['nb_app'] = cnt_prev['SK_ID_PREV'] del avg_prev['SK_ID_PREV'] del prev gc.collect() 

क्रेडिट कार्ड का बैलेंस

 POS_CASH.head() 

 POS_CASH.NAME_CONTRACT_STATUS.value_counts() 

Active 9151119
Completed 744883
Signed 87260
Demand 7065
Returned to the store 5461
Approved 4917
Amortized debt 636
Canceled 15
XNA 2
Name: NAME_CONTRACT_STATUS, dtype: int64

हम स्पष्ट विशेषताओं को कूटबद्ध करते हैं और संयोजन के लिए एक तालिका तैयार करते हैं

 le = LabelEncoder() POS_CASH['NAME_CONTRACT_STATUS'] = le.fit_transform(POS_CASH['NAME_CONTRACT_STATUS'].astype(str)) nunique_status = POS_CASH[['SK_ID_CURR', 'NAME_CONTRACT_STATUS']].groupby('SK_ID_CURR').nunique() nunique_status2 = POS_CASH[['SK_ID_CURR', 'NAME_CONTRACT_STATUS']].groupby('SK_ID_CURR').max() POS_CASH['NUNIQUE_STATUS'] = nunique_status['NAME_CONTRACT_STATUS'] POS_CASH['NUNIQUE_STATUS2'] = nunique_status2['NAME_CONTRACT_STATUS'] POS_CASH.drop(['SK_ID_PREV', 'NAME_CONTRACT_STATUS'], axis=1, inplace=True) 

कार्ड डेटा

 credit_card.head() 

(पहले 7 कॉलम)

समान काम

 credit_card['NAME_CONTRACT_STATUS'] = le.fit_transform(credit_card['NAME_CONTRACT_STATUS'].astype(str)) nunique_status = credit_card[['SK_ID_CURR', 'NAME_CONTRACT_STATUS']].groupby('SK_ID_CURR').nunique() nunique_status2 = credit_card[['SK_ID_CURR', 'NAME_CONTRACT_STATUS']].groupby('SK_ID_CURR').max() credit_card['NUNIQUE_STATUS'] = nunique_status['NAME_CONTRACT_STATUS'] credit_card['NUNIQUE_STATUS2'] = nunique_status2['NAME_CONTRACT_STATUS'] credit_card.drop(['SK_ID_PREV', 'NAME_CONTRACT_STATUS'], axis=1, inplace=True) 

भुगतान डेटा

 payments.head() 

(पहले 7 कॉलम दिखाए गए हैं)

आइए तीन टेबल बनाएं - इस टेबल से औसत, न्यूनतम और अधिकतम मान।

 avg_payments = payments.groupby('SK_ID_CURR').mean() avg_payments2 = payments.groupby('SK_ID_CURR').max() avg_payments3 = payments.groupby('SK_ID_CURR').min() del avg_payments['SK_ID_PREV'] del payments gc.collect() 

तालिका में शामिल हों

 data = data.merge(right=avg_prev.reset_index(), how='left', on='SK_ID_CURR') test = test.merge(right=avg_prev.reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(right=avg_buro.reset_index(), how='left', on='SK_ID_CURR') test = test.merge(right=avg_buro.reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(POS_CASH.groupby('SK_ID_CURR').mean().reset_index(), how='left', on='SK_ID_CURR') test = test.merge(POS_CASH.groupby('SK_ID_CURR').mean().reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(credit_card.groupby('SK_ID_CURR').mean().reset_index(), how='left', on='SK_ID_CURR') test = test.merge(credit_card.groupby('SK_ID_CURR').mean().reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(right=avg_payments.reset_index(), how='left', on='SK_ID_CURR') test = test.merge(right=avg_payments.reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(right=avg_payments2.reset_index(), how='left', on='SK_ID_CURR') test = test.merge(right=avg_payments2.reset_index(), how='left', on='SK_ID_CURR')​ data = data.merge(right=avg_payments3.reset_index(), how='left', on='SK_ID_CURR') test = test.merge(right=avg_payments3.reset_index(), how='left', on='SK_ID_CURR') del avg_prev, avg_buro, POS_CASH, credit_card, avg_payments, avg_payments2, avg_payments3 gc.collect() print ('  ', data.shape) print ('  ', test.shape) print ('  ', y.shape) 

(307511, 504)
(48744, 504)
(307511,)

और, वास्तव में, हम इस दोगुनी तालिका को धीरे-धीरे बढ़ाने के साथ मारेंगे!

 from lightgbm import LGBMClassifier​ clf2 = LGBMClassifier() clf2.fit(data, y)​ predictions = clf2.predict_proba(test)[:, 1]​ #    submission = test[['SK_ID_CURR']] submission['TARGET'] = predictions​ #   submission.to_csv('lightgbm_full.csv', index = False) 

परिणाम 0.770 है।

ठीक है, अंत में, आइए सिलवटों के साथ एक और अधिक जटिल तकनीक का प्रयास करें, क्रॉस-वैलिडेशन करें और सबसे अच्छा पुनरावृत्ति चुनें।

 folds = KFold(n_splits=5, shuffle=True, random_state=546789) oof_preds = np.zeros(data.shape[0]) sub_preds = np.zeros(test.shape[0])​ feature_importance_df = pd.DataFrame()​ feats = [f for f in data.columns if f not in ['SK_ID_CURR']]​ for n_fold, (trn_idx, val_idx) in enumerate(folds.split(data)): trn_x, trn_y = data[feats].iloc[trn_idx], y.iloc[trn_idx] val_x, val_y = data[feats].iloc[val_idx], y.iloc[val_idx] clf = LGBMClassifier( n_estimators=10000, learning_rate=0.03, num_leaves=34, colsample_bytree=0.9, subsample=0.8, max_depth=8, reg_alpha=.1, reg_lambda=.1, min_split_gain=.01, min_child_weight=375, silent=-1, verbose=-1, ) clf.fit(trn_x, trn_y, eval_set= [(trn_x, trn_y), (val_x, val_y)], eval_metric='auc', verbose=100, early_stopping_rounds=100 #30 ) oof_preds[val_idx] = clf.predict_proba(val_x, num_iteration=clf.best_iteration_)[:, 1] sub_preds += clf.predict_proba(test[feats], num_iteration=clf.best_iteration_)[:, 1] / folds.n_splits fold_importance_df = pd.DataFrame() fold_importance_df["feature"] = feats fold_importance_df["importance"] = clf.feature_importances_ fold_importance_df["fold"] = n_fold + 1 feature_importance_df = pd.concat([feature_importance_df, fold_importance_df], axis=0) print('Fold %2d AUC : %.6f' % (n_fold + 1, roc_auc_score(val_y, oof_preds[val_idx]))) del clf, trn_x, trn_y, val_x, val_y gc.collect()​ print('Full AUC score %.6f' % roc_auc_score(y, oof_preds))​ test['TARGET'] = sub_preds​ test[['SK_ID_CURR', 'TARGET']].to_csv('submission_cross.csv', index=False) 

Full AUC score 0.785845

कागल पर अंतिम स्कोर 0.783

आगे कहाँ जाना है

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

मुझे उम्मीद है कि इस छोटे संकलन ने आपको डेटा पर शोध करने और भविष्य कहनेवाला मॉडल तैयार करने के आधुनिक तरीके दिखाए हैं। डेटाटेन्स सीखें, प्रतियोगिताओं में भाग लें, मस्त रहें!

और फिर से गुठली के लिंक जो मुझे इस लेख को तैयार करने में मदद करते हैं। लेख को जीथब पर लैपटॉप के रूप में भी पोस्ट किया गया है , आप इसे डाउनलोड कर सकते हैं, डेटासेट और चला सकते हैं और प्रयोग कर सकते हैं।

कोहेर्सन करेंगे। यहां शुरू करें: एक सौम्य परिचय
सांबन। HomeCreditRisk: व्यापक EDA + आधार रेखा [0.772]
Gabriel Preda. Home Credit Default Risk Extensive EDA
Pavan Raj. Loan repayers v/s Loan defaulters — HOME CREDIT
Lem Lordje Ko. 15 lines: Just EXT_SOURCE_x
Shanth. HOME CREDIT — BUREAU DATA — FEATURE ENGINEERING
Dmitriy Kisil. Good_fun_with_LigthGBM