अजगर + पांडा + स्किकिट-लर्न बंडल का उपयोग करके क्रेडिट स्कोरिंग समस्या को हल करने का एक उदाहरण

परिचय

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

समस्या का डेटा और विवरण का विवरण

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


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

डेटा प्रीप्रोसेसिंग

आरंभ करने के लिए, स्रोत फ़ाइलों को डाउनलोड करें और उन्हें देखें:

from pandas import read_csv, DataFrame from sklearn.metrics import roc_curve from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier from sklearn.cross_validation import train_test_split from sklearn.naive_bayes import GaussianNB from sklearn.neighbors import KNeighborsClassifier from sklearn.decomposition import PCA import ml_metrics, string, re, pylab as pl SampleCustomers = read_csv("https://static.tcsbank.ru/documents/olymp/SAMPLE_CUSTOMERS.csv", ';') SampleAccounts = read_csv("https://static.tcsbank.ru/documents/olymp/SAMPLE_ACCOUNTS.csv",";",decimal =',') print SampleAccounts 

 SampleCustomers.head() 

	tcs_customer_id	बुरा	sample_type
0	1	NaN	कसौटी
1	2	0	गाड़ी
2	3	1	गाड़ी
3	4	0	गाड़ी
4	5	0	गाड़ी

कार्य की शर्तों से, हम यह मान सकते हैं कि नमूना खाता सेट में एक उधारकर्ता के लिए कई रिकॉर्ड हैं, आइए इसे देखें:

 SampleAccounts.tcs_customer_id.drop_duplicates().count(), SampleAccounts.tcs_customer_id.count() 

हमारी धारणा सही थी। 280,942 रिकॉर्ड्स के अनोखे कर्जदार 50,000। यह इस तथ्य के कारण है कि एक उधारकर्ता के पास कई ऋण हैं और उनमें से प्रत्येक के लिए विभिन्न ब्यूरो में अलग-अलग जानकारी है। इसलिए, आपको SampleAccounts पर रूपांतरण करने की आवश्यकता है ताकि एक पंक्ति एक उधारकर्ता से मेल खाती हो।
अब प्रत्येक उधारकर्ता के लिए सभी अद्वितीय ऋणों की एक सूची प्राप्त करते हैं:

 SampleAccounts[['tcs_customer_id','open_date','final_pmt_date','credit_limit','currency']].drop_duplicates() 

इसलिए, जब हमें ऋण की सूची प्राप्त हुई, तो हम सूची के प्रत्येक तत्व के लिए कुछ सामान्य जानकारी प्रदर्शित कर सकते हैं। यानी ऊपर सूचीबद्ध खेतों का एक गुच्छा लेना और इसे एक सूचकांक बनाना संभव होगा, जिसके खिलाफ हम आगे जोड़तोड़ करेंगे, लेकिन, दुर्भाग्य से, एक अप्रिय क्षण हमारे लिए इंतजार में है। यह इस तथ्य में शामिल है कि डेटासेट में 'अंतिम_pmt_date' फ़ील्ड में रिक्त मान हैं। आइए उनसे छुटकारा पाने की कोशिश करते हैं।
हमने इस क्षेत्र में ऋण की वास्तविक समापन तिथि निर्धारित की है, इसलिए, यदि यह है, और फ़ील्ड 'final_pmt_date' भरा नहीं है, तो आप इस मान को इसमें लिख सकते हैं। बाकी के लिए, बस 0 लिखें।

 SampleAccounts.final_pmt_date[SampleAccounts.final_pmt_date.isnull()] = SampleAccounts.fact_close_date[SampleAccounts.final_pmt_date.isnull()].astype(float) SampleAccounts.final_pmt_date.fillna(0, inplace=True) 

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

 sumtbl = SampleAccounts.pivot_table(['inf_confirm_date'], ['tcs_customer_id','open_date','final_pmt_date','credit_limit','currency'], aggfunc='max') sumtbl.head(15) 

					inf_confirm_date
tcs_customer_id	open_date	final_pmt_date	credit_limit	मुद्रा
1	39,261	39,629	19,421	RUB	39,924
	39,505	39,870	30000	RUB	39,862
	39,644	40,042	11,858	RUB	40043
	39,876	41701	300000	RUB	40,766
	39,942	40,308	19,691	RUB	40,435
	40,421	42,247	169,000	RUB	40,756
	40,428	51,386	10000	RUB	40,758
	40,676	41040	28,967	RUB	40,764
2	40,472	40,618	7551	RUB	40,661
	40,652	40,958	21,186	RUB	40,661
3	39,647	40,068	22694	RUB	40069
	40,604	0	20000	RUB	40,624
4	38,552	40,378	75000	RUB	40,479
	39,493	39,797	5000	RUB	39823
	39759	40123	6023	RUB	40125

अब हम प्राप्त तारीखों को मुख्य सेट में जोड़ें:

 SampleAccounts = SampleAccounts.merge(sumtbl, 'left', left_on=['tcs_customer_id','open_date','final_pmt_date','credit_limit','currency'], right_index=True, suffixes=('', '_max')) 

इसलिए, आगे हम उन स्तंभों को तोड़ेंगे जिनमें मापदंडों को कड़ाई से परिभाषित किया गया है, ताकि इन क्षेत्रों के प्रत्येक मान का एक अलग स्तंभ हो। शर्त के अनुसार, दिए गए मानों वाले कॉलम निम्न होंगे:

• pmt_string_84m
• pmt_freq
• टाइप
• स्थिति
• संबंध
• bureau_cd

उन्हें परिवर्तित करने के लिए कोड नीचे दिखाया गया है:

 #  pmt_string_84m vals = list(xrange(10)) + ['A','X'] PMTstr = DataFrame([{'pmt_string_84m_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.pmt_string_84m]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['pmt_string_84m'], axis=1) #  pmt_freq SampleAccounts.pmt_freq.fillna(7, inplace=True) SampleAccounts.pmt_freq[SampleAccounts.pmt_freq == 0] = 7 vals = list(range(1,8)) + ['A','B'] PMTstr = DataFrame([{'pmt_freq_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.pmt_freq]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['pmt_freq'], axis=1) #  type vals = [1,4,6,7,9,10,11,12,13,14,99] PMTstr = DataFrame([{'type_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.type]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['type'], axis=1) #  status vals = [0,12, 13, 14, 21, 52,61] PMTstr = DataFrame([{'status_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.status]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['status'], axis=1) #  relationship vals = [1,2,4,5,9] PMTstr = DataFrame([{'relationship_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.relationship]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['relationship'], axis=1) #  bureau_cd vals = [1,2,3] PMTstr = DataFrame([{'bureau_cd_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in SampleAccounts.bureau_cd]) SampleAccounts = SampleAccounts.join(PMTstr).drop(['bureau_cd'], axis=1) 

अगला कदम फ़ील्ड को 'fact_close_date' में बदलना है, जिसमें अंतिम वास्तविक भुगतान की तारीख शामिल है, ताकि इसमें केवल 2 मान हों:

• 0 - अंतिम भुगतान नहीं था
• 1 - आखिरी भुगतान था

मैंने यह प्रतिस्थापन इसलिए किया क्योंकि शुरू में यह क्षेत्र आधा भरा हुआ था।

 SampleAccounts.fact_close_date[SampleAccounts.fact_close_date.notnull()] = 1 SampleAccounts.fact_close_date.fillna(0, inplace=True) 

अब हमें अपने डेटा सेट से सभी ऋणों पर नवीनतम डेटा प्राप्त करने की आवश्यकता है। ऊपर प्राप्त "inf_confirm_date_max" फ़ील्ड हमें इसमें मदद करेगा। हमने इसके लिए सभी ब्यूरो में क्रेडिट जानकारी अपडेट करने की समय सीमा जोड़ी:

 PreFinalDS = SampleAccounts[SampleAccounts.inf_confirm_date == SampleAccounts.inf_confirm_date_max].drop_duplicates() 

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

 PreFinalDS = PreFinalDS.groupby(['tcs_customer_id','open_date','final_pmt_date','credit_limit','currency']).max().reset_index() 

हमारा डेटा विश्लेषण शुरू करने के लिए लगभग तैयार है। यह कुछ और क्रियाएं करने के लिए बनी हुई है:

1. अनावश्यक कॉलम हटा दें
2. रूबल में सभी क्रेडिट सीमाएं लाएं
3. ब्यूरो से मिली जानकारी के अनुसार प्रत्येक ऋण लेने वाले कितने ऋणों की गणना करता है

अनावश्यक स्तंभों की तालिका को साफ़ करके शुरू करें:

 PreFinalDS = PreFinalDS.drop(['bki_request_date', 'inf_confirm_date', 'pmt_string_start', 'interest_rate', 'open_date', 'final_pmt_date', 'inf_confirm_date_max'], axis=1) 

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

 curs = DataFrame([33.13,44.99,36.49,1], index=['USD','EUR','GHF','RUB'], columns=['crs']) PreFinalDS = PreFinalDS.merge(curs, 'left', left_on='currency', right_index=True) PreFinalDS.credit_limit = PreFinalDS.credit_limit * PreFinalDS.crs #     vals = ['RUB','USD','EUR','CHF'] PMTstr = DataFrame([{'currency_%s' % (str(j)): str(i).count(str(j)) for j in vals} for i in PreFinalDS.currency]) PreFinalDS = PreFinalDS.join(PMTstr).drop(['currency','crs'], axis=1) 

इसलिए, अंतिम समूह बनाने से पहले, हम अपने सेट में इकाइयों से भरा एक क्षेत्र जोड़ देंगे। यानी जब हम अंतिम समूहन करते हैं, तो उस पर दी गई राशि उधारकर्ता से ऋण की संख्या देगी:

 PreFinalDS['count_credit'] = 1 

अब जब हमारे पास डेटा सेट मात्रात्मक है, तो आप डेटा 0 में अंतराल भर सकते हैं और ग्राहक द्वारा अंतिम समूहन कर सकते हैं:

 PreFinalDS.fillna(0, inplace=True) FinalDF = PreFinalDS.groupby('tcs_customer_id').sum() FinalDF 

प्रारंभिक विश्लेषण

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

 SampleCustomers.set_index('tcs_customer_id', inplace=True) UnionDF = FinalDF.join(SampleCustomers) trainDF = UnionDF[UnionDF.sample_type == 'train'].drop(['sample_type'], axis=1) testDF = UnionDF[UnionDF.sample_type == 'test'].drop(['sample_type'], axis=1) 

अगला, आइए देखें कि संकेत एक दूसरे के साथ कैसे सहसंबंधित हैं, इसके लिए हम संकेतों के सहसंबंध गुणांक के साथ एक मैट्रिक्स का निर्माण करते हैं। पांडा के साथ, यह एक कमांड के साथ किया जा सकता है:

 CorrKoef = trainDF.corr() 

ऊपर की कार्रवाई के बाद, CorrKoef में 61x61 आकार का मैट्रिक्स होगा।
इसके पंक्तियों और स्तंभों में संबंधित फ़ील्ड नाम होंगे, और उनके चौराहे पर - सहसंबंध गुणांक का मूल्य। उदाहरण के लिए:

	fact_close_date
status_13	0.997362

एक मामला तब संभव है जब कोई सहसंबंध गुणांक नहीं है। इसका मतलब यह है कि ये क्षेत्र केवल एक समान मूल्य से भरे हुए हैं और विश्लेषण के दौरान छोड़ा जा सकता है। की जाँच करें:

 FieldDrop = [i for i in CorrKoef if CorrKoef[i].isnull().drop_duplicates().values[0]] 

आउटपुट पर, हमें उन फ़ील्ड्स की एक सूची मिली, जिन्हें हटाया जा सकता है:

• pmt_string_84m_6
• pmt_string_84m_8
• pmt_freq_5
• pmt_freq_A
• pmt_freq_B
• status_12

अगला कदम हमारे मैट्रिक्स का उपयोग करके उन क्षेत्रों को खोजना है जो एक दूसरे के साथ सहसंबंधित हैं (जिसके लिए सहसंबंध गुणांक 90% से अधिक है):

 CorField = [] for i in CorrKoef: for j in CorrKoef.index[CorrKoef[i] > 0.9]: if i <> j and j not in CorField and i not in CorField: CorField.append(j) print "%s-->%s: r^2=%f" % (i,j, CorrKoef[i][CorrKoef.index==j].values[0]) 

आउटपुट पर हमें निम्नलिखित मिलते हैं:

fact_close_date -> status_13: r ^ 2 = 0.997362
ttl_delq_5_29 -> ttl_delq_30: r ^ 2 = 0.954740
ttl_delq_5_29 -> pmt_string_84m_A: r ^ 2 = 0.925870
ttl_delq_30_59 -> pmt_string_84m_2: r ^ 2 = 0.903337
ttl_delq_90_plus -> pmt_string_84m_5: r ^ 2 = 0.978249
delq_balance -> max_delq_balance: r ^ 2 = 0.986967
pmt_freq_3 -> relationship_1: r ^ 2 = 0.909820
pmt_freq_3 -> Currency_RUB: r ^ 2 = 0.910620
pmt_freq_3 -> count_credit: r ^ 2 = 0.911109

इसलिए, पिछले चरण में हमें मिले रिश्तों के आधार पर, हम निम्नलिखित क्षेत्रों को हटाए गए सूची में जोड़ सकते हैं:

 FieldDrop =FieldDrop + ['fact_close_date','ttl_delq_30', 'pmt_string_84m_5', 'pmt_string_84m_A', 'pmt_string_84m_A', 'max_delq_balance', 'relationship_1', 'currency_RUB', 'count_credit'] newtr = trainDF.drop(FieldDrop, axis=1) 

मॉडल बनाना और चुनना

खैर, प्राथमिक डेटा क्या संसाधित है और अब हम मॉडल के निर्माण के लिए आगे बढ़ सकते हैं।
प्रशिक्षण सेट से वर्ग विशेषता अलग करें:

 target = newtr.bad.values train = newtr.drop('bad', axis=1).values 

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

 coder = PCA(n_components=20) train = coder.fit_transform(train) 

वर्गीकरण मॉडल को परिभाषित करने का समय आ गया है। आइए कुछ अलग एल्गोरिदम लेते हैं और एरिया अंडर आरओसी कर्व ( auc ) की विशेषताओं का उपयोग करके अपने काम के परिणामों की तुलना करते हैं। मॉडलिंग के लिए, निम्नलिखित एल्गोरिदम पर विचार किया जाएगा:

• बेतरतीब जंगल
• धीरे-धीरे बूस्ट
• निकटतम पड़ोसी विधि
• "नाइव" बायेसियन क्लासिफायरियर

 models = [] models.append(RandomForestClassifier(n_estimators=165, max_depth=4, criterion='entropy')) models.append(GradientBoostingClassifier(max_depth =4)) models.append(KNeighborsClassifier(n_neighbors=20)) models.append(GaussianNB()) 

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

 TRNtrain, TRNtest, TARtrain, TARtest = train_test_split(train, target, test_size=0.3, random_state=0) 

यह हमारे मॉडल को प्रशिक्षित करने और परिणाम का मूल्यांकन करने के लिए बनी हुई है।
Auc विशेषताओं की गणना करने के 2 तरीके हैं:

1. Rol_auc_score या auc फ़ंक्शन का उपयोग करके स्केलेर मॉड्यूल के मानक साधनों द्वारा
2. तृतीय-पक्ष ml_metrics पैकेज और auc () फ़ंक्शन का उपयोग करना

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

 plt.figure(figsize=(10, 10)) for model in models: model.fit(TRNtrain, TARtrain) pred_scr = model.predict_proba(TRNtest)[:, 1] fpr, tpr, thresholds = roc_curve(TARtest, pred_scr) roc_auc = ml_metrics.auc(TARtest, pred_scr) md = str(model) md = md[:md.find('(')] pl.plot(fpr, tpr, label='ROC fold %s (auc = %0.2f)' % (md, roc_auc)) pl.plot([0, 1], [0, 1], '--', color=(0.6, 0.6, 0.6)) pl.xlim([0, 1]) pl.ylim([0, 1]) pl.xlabel('False Positive Rate') pl.ylabel('True Positive Rate') pl.title('Receiver operating characteristic example') pl.legend(loc="lower right") pl.show() 

इसलिए, हमारे मॉडलों के विश्लेषण के परिणामों के अनुसार, हम कह सकते हैं कि ढाल को बढ़ावा देने ने अपना सर्वश्रेष्ठ दिखाया, इसकी सटीकता लगभग 69% है। तदनुसार, एक परीक्षण नमूने के प्रशिक्षण के लिए, हम इसे चुनेंगे। आइए परीक्षण नमूने में जानकारी भरें, इसे वांछित प्रारूप में पूर्व-प्रसंस्करण करें:

 #      FieldDrop.append('bad') test = testDF.drop(FieldDrop, axis=1).values test = coder.fit_transform(test) #  model = models[1] model.fit(train, target) #  testDF.bad = model.predict(test) 

निष्कर्ष

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