🍦 ↩️ 🚘 एमएल-ब्लिट्ज: पहले योग्यता दौर के कार्यों का विश्लेषण 🐂 🐃 🚋

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

अब हम आपके साथ क्वालिफिकेशन राउंड के कार्यों के विश्लेषण को सबसे पहले साझा करना चाहते हैं। दो प्रतिभागी इस प्रतियोगिता की सभी समस्याओं को हल करने में कामयाब रहे; 57 प्रतिभागियों ने कम से कम एक कार्य को हल किया, और 110 ने कार्य को पारित करने के लिए कम से कम एक प्रयास पूरा किया।

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

प्रतियोगियों के बीच सबसे लोकप्रिय प्रोग्रामिंग भाषा अपेक्षित रूप से अजगर थी, इसलिए मैंने इस भाषा का उपयोग उन सभी मामलों में भी किया जब कोड लिखना आवश्यक था।

मेरे सभी समाधान GitHub पर उपलब्ध हैं।

समस्या ए। निर्णायक स्टंप

कार्य
अजगर का हल
सी ++ समाधान

निर्णायक स्टंप मशीन सीखने के सबसे सरल निर्णायक कार्यों में से एक है। यह निम्नानुसार परिभाषित एक टुकड़ा करने योग्य स्थिर कार्य है:

f (x) = \ left \ {\ {start \ array} {ll} a, & \ quad x <c \\ b, & \ quad x \ ge c \ end {array} \ right।

$f (x) = \ left \ {\ {start \ array} {ll} a, & \ quad x <c \\ b, & \ quad x \ ge c \ end {array} \ right।$

इस समस्या में, प्रशिक्षण नमूने के लिए एक इष्टतम निर्णय स्टंप का निर्माण करना आवश्यक था। यानी दी गई संख्याओं के अनुसार $(x_1, y_1), \ ldots, (x_n, y_n)$ , द्विघात हानि कार्यात्मक के मूल्यों का अनुकूलन करने के लिए निर्णायक स्टंप के मापदंडों के इष्टतम मूल्यों को निर्धारित करना आवश्यक था।

Q (f, x, y) = s u m_{i = 1}^{n} (f (x_{i}) - y_{i})^{2}

$Q (f, x, y) = \ sum_ {i = 1} ^ {n} (f (x_i) - y_i) ^ 2$

उत्तर के रूप में इष्टतम मूल्यों को प्राप्त करना आवश्यक था $ए, बी, सी$ ।

निर्णय

इसलिए, हमें एक ज्ञात फ़ंक्शन के एक टुकड़े-टुकड़े-चिकनी निर्माण की आवश्यकता है। यदि पैरामीटर $सी$ ज्ञात तो पैरामीटर पाते हैं $एक$ और $ब$ काफी सरल है। आप संबंधित अनुकूलन समस्याओं के समाधान के रूप में गणितीय रूप से समाधान लिख सकते हैं। पैरामीटर $एक$ क्या उन वस्तुओं पर निर्णायक स्टंप की भविष्यवाणियों का परिमाण है $(x_i, y_i)$ जिसके लिए प्रशिक्षण नमूना $x_i <c$ । इसी तरह, $ब$ उन वस्तुओं पर भविष्यवाणियों का परिमाण है $(x_i, y_i)$ जिसके लिए प्रशिक्षण नमूना $x_i \ ge c$ ।

हम प्रशिक्षण सेट के संबंधित सबसेट के लिए संकेतन प्रस्तुत करते हैं: $एल (सी)$ एक बिंदु के बाईं ओर वस्तुओं का एक सबसेट है $सी$ । $आर (सी)$ - बिंदु के दाईं ओर वस्तुओं का सबसेट $सी$ ।

L (c) = \ {(x_i, y_i) | x_i <c \}

$L (c) = \ {(x_i, y_i) | x_i <c \}$

R (c) = \ {(x_i, y_i) | x_i \ ge c \}

$R (c) = \ {(x_i, y_i) | x_i \ ge c \}$

फिर इष्टतम मूल्य $एक$ सेट में उत्तरों के अंकगणितीय माध्य के बराबर होगा $एल (सी)$ , और इष्टतम मूल्य $ब$ - क्रमशः, सेट में उत्तरों के अंकगणितीय माध्य $आर (सी)$ ।

इसे निम्नानुसार उचित ठहराया जा सकता है

a = a r g m i n_{t i n m a t h b b R} s u m_{(x_{i}, y_{i})_{i} n (c)} (t - y_{i})^{2}

$a = \ arg \ min_ {t \ in \ mathbb {R}} {\ sum _ {(x_i, y_i) \ _ in (c)} (t - y_i) ^ 2}$

b = \ arg \ min_ {t \ in \ mathbb {R}} {\ _ _ {{(x_i, y_i) \ _ in R (c)} (t - y_i) ^ 2}

$b = \ arg \ min_ {t \ in \ mathbb {R}} {\ _ _ {{(x_i, y_i) \ _ in R (c)} (t - y_i) ^ 2}$

यह सर्वविदित है कि ऐसी अनुकूलन समस्याओं का उत्तर अंकगणितीय माध्य है:

a = \ frac {\ _ _ _ (x_i, y_i) \ _ में (c)} yii} {!! L (c) |}

$a = \ frac {\ _ _ _ (x_i, y_i) \ _ में (c)} yii} {!! L (c) |}$

b = \ frac {\ _ _ _ (x_i, y_i) \ _ in R (c)} yii} {!! L (c) |}

$b = \ frac {\ _ _ _ (x_i, y_i) \ _ in R (c)} yii} {!! L (c) |}$

यह साबित करने के लिए काफी आसान है। भविष्यवाणी मूल्य के संबंध में नुकसान कार्यात्मक का आंशिक व्युत्पन्न करें:

f r a c आ ं श ि क आ ं श ि क t s u m_{y_{i} n Y} (t - y)^{2} = 2 c d o t s u m_{y_{i} n Y} (t - y) = 2 c d o t | व ा ई | c d o t t - 2 c d o t s u m_{y i n Y} y

$\ frac {\ आंशिक} {\ आंशिक t} \ sum_ {y_ in Y} {(t - y) ^ 2} = 2 \ cdot \ sum_ {y \ _ in Y} {(t - y)} = 2 \ cdot | वाई | \ cdot t - 2 \ cdot \ sum_ {y \ in Y} {y}$

व्युत्पन्न को शून्य के बराबर करने के बाद, हम प्राप्त करते हैं

t = f r a c 1 | Y | s u m_{y i n Y} y

$t = \ frac {1} {| Y |} \ sum_ {y \ in Y} y$

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

तो अब यह स्पष्ट है कि मापदंडों को कैसे खोजना है $एक$ और $ब$ एक ज्ञात पैरामीटर के साथ $सी$ । यह समझने के लिए बना रहता है कि इष्टतम पैरामीटर मान कैसे पाया जाए $सी$ ।

ध्यान देने योग्य पहली बात: पैरामीटर $सी$ कोई भी वास्तविक मूल्य ले सकता है, लेकिन कई अलग-अलग विभाजन परिमित हैं। से नमूना सीखना $एन$ वस्तुओं को इससे अधिक नहीं तोड़ा जा सकता है $n + 1$ "बाएं" और "दाएं" भागों के तरीके। वास्तविकता में, इस तरह के विभाजन और भी कम हो सकते हैं: उदाहरण के लिए, कुछ वस्तुओं के लिए, विशेषताओं के मान मेल खा सकते हैं। इसके अलावा, विभाजन हमारे लिए समान हैं, जिसमें प्रशिक्षण सेट में सभी ऑब्जेक्ट बाईं ओर या दाईं ओर हैं।

सभी संभव विभाजन प्राप्त करने के लिए, आप गैर-घटती विशेषता द्वारा निर्धारित प्रशिक्षण की वस्तुओं को सॉर्ट कर सकते हैं:

(x_{i_{1}}, y_{i_{1}}), l d o t s (x_{i_{n}}, y_{i_{n}})

$(x_ {i_1}, y_ {i_1}), \ ldots (x_ {i_n}, y_ {i_n})$

x_{i_{1}} l e x_{i_{2}} l e l d o t s l e x_{i_{n}}

$x_ {i_1} \ le x_ {i_2} \ le \ ldots \ le x_ {i_n}$

अब यह स्पष्ट है कि संभावित दिलचस्प पैरामीटर मान $सी$ मात्राएँ हैं

f r a c x_{i_{1}} + x_{i_{2}} 2, f r a c x_{i_{2}} + x_{i_{3}} 2, l d o t s, f r a c x_{i_{n - 1}} + x_{i_{n}} 2

$\ frac {x_ {i_1} + x_ {i_2}} {2}, \ frac {x_ {i_2} + x_ {i_3}} {2}, \ ldots, \ frac {x_ {i_ {n-1}} + x_ {i_n}} {2}$

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

वह सब कुछ इस सवाल का है कि इस समाधान को प्रभावी कैसे बनाया जाए। वर्णित एल्गोरिदम के प्रत्यक्ष कार्यान्वयन से एल्गोरिथ्म की द्विघात जटिलता हो जाएगी, जो अस्वीकार्य है।

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

कार्यान्वयन

कार्यान्वयन में, मैं वेलफोर्ड विधि का उपयोग करूंगा, जैसा कि मुझे "मानक" सूत्रों का उपयोग करके गणना से अधिक पसंद है। इसके अलावा, मैं नुकीले और किसी भी अन्य पुस्तकालयों का उपयोग नहीं करूंगा कि अजगर भाषा के प्राथमिक निर्माणों का ज्ञान एक समाधान प्राप्त करने के लिए पर्याप्त है।

इसलिए, हमें वर्धित विचलन के औसत और योग की गणना करने में सक्षम होना चाहिए। ऐसा करने के लिए, हम दो वर्गों का वर्णन करते हैं:

class MeanCalculator: def __init__(self): self.Count = 0. self.Mean = 0. def Add(self, value, weight = 1.): self.Count += weight self.Mean += weight * (value - self.Mean) / self.Count def Remove(self, value, weight = 1.): self.Add(value, -weight) class SumSquaredErrorsCalculator: def __init__(self): self.MeanCalculator = MeanCalculator() self.SSE = 0. def Add(self, value, weight = 1.): curDiff = value - self.MeanCalculator.Mean self.MeanCalculator.Add(value, weight) self.SSE += weight * curDiff * (value - self.MeanCalculator.Mean) def Remove(self, value, weight = 1.): self.Add(value, -weight)

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

 class Instances: def __init__(self): self.Items = [] self.OverAllSSE = SumSquaredErrorsCalculator() def Read(self): fin = open('stump.in') for line in fin.readlines()[1:]: x, y = map(float, line.strip().split()) self.Items.append([x, y]) self.OverAllSSE.Add(y) self.Items.sort()

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

अब सबसे दिलचस्प बात: इष्टतम पैरामीटर मान खोजने की विधि।

आइए आरंभ के साथ शुरू करते हैं। प्रारंभिक स्थिति में, सभी ऑब्जेक्ट सही सबमिशन में हैं। फिर पैरामीटर $एक$ कुछ भी, पैरामीटर के बराबर हो सकता है $ब$ पूरे नमूने में औसत प्रतिक्रिया के बराबर, और पैरामीटर $सी$ ऐसे कि चयन में सभी वस्तुएं इसके अधिकार में हैं।

इसके अलावा, हम left और right चर को इनिशियलाइज़ करते हैं - वे क्रमशः बाएँ और दाएँ उपसमूहों के लिए आंकड़े संग्रहीत करेंगे।

 left = SumSquaredErrorsCalculator() right = self.OverAllSSE bestA = 0 bestB = right.MeanCalculator.Mean bestC = self.Items[0][0] bestQ = right.SSE

अब वृद्धिशील एल्गोरिथ्म पर चलते हैं। हम एक समय में चयन तत्वों को संसाधित करेंगे। प्रत्येक तत्व को बाईं सबसेट में स्थानांतरित किया जाता है। फिर आपको यह सत्यापित करने की आवश्यकता है कि संबंधित विभाजन वास्तव में मौजूद है - अर्थात, विशेषता का मूल्य अगले ऑब्जेक्ट की विशेषता के मूल्य से अलग है।

 for i in range(len(self.Items) - 1): item = self.Items[i] nextItem = self.Items[i + 1] left.Add(item[1]) right.Remove(item[1]) if item[0] == nextItem[0]: continue a = left.MeanCalculator.Mean b = right.MeanCalculator.Mean c = (item[0] + nextItem[0]) / 2 q = left.SSE + right.SSE if q < bestQ: bestA = a bestB = b bestC = c bestQ = q

अब केवल समाधान प्राप्त करने के लिए कोड की रचना करना शेष रह गया है:

 instances = Instances() instances.Read() a, b, c = instances.BestSplit() print >> open('stump.out', 'w'), a, b, c

मैं ध्यान देता हूं कि अजगर में प्रस्तुत समाधान वास्तव में प्रणाली द्वारा स्वीकार किया जाता है, लेकिन यह समाधान के समय में ऊपरी सीमा पर आता है: सबसे बड़े परीक्षणों को निष्पादित करने के लिए लगभग 800 मिलीसेकंड की आवश्यकता होती है। बेशक, अतिरिक्त पुस्तकालयों का उपयोग करके अधिक प्रभावशाली प्रदर्शन प्राप्त किया जा सकता है।

इसलिए, मैंने C ++ में प्रस्तावित एल्गोरिथ्म को भी लागू किया । यह समाधान सबसे खराब स्थिति में 60 मिलीसेकेंड में से एक परीक्षण पर खर्च किया गया।

समस्या बी गुणांकों की वसूली

कार्य
स्केलेर का उपयोग करके पायथन समाधान

सेटिंग्स को पुनर्स्थापित करने की आवश्यकता है $एक$ । $ब$ । $सी$ कार्यों $च$ प्रसिद्ध जोड़ों का एक सेट होने $(x_1, f (x_1)),$ $\ ldots,$ $(x_n, f (x_n))$ और यह जानते हुए कि फ़ंक्शन के मान निम्न सूत्र द्वारा निर्धारित किए गए हैं:

f (x) = B i g ((a + v a r e p s i l o n_{a}) s i n x + (b + v a r e p s i l o n_{b}) l n x B i g)^{2} + (c + v a r e p s i l o n_{c}) x^{2}

$f (x) = \ Big ((a + \ varepsilon_a) \ sin x + (b + \ varepsilon_b) \ ln x \ Big) ^ 2 + (c + \ varepsilon_c) x ^ 2$

निर्णय

यादृच्छिक चर को अनदेखा करते हुए कोष्ठक का विस्तार करें:

f (x) = a^{2} c d o t s i n^{2} (x) + b^{2} c d o t l n^{2} (x) + 2 a b c d o t s i n (x) c d o t l n (x) + c_{c} d o t x^{2}

$f (x) = a ^ 2 \ cdot \ sin ^ 2 (x) + b ^ 2 \ cdot \ ln ^ 2 (x) + 2ab \ cdot \ sin (x) \ cdot \ ln (x) + c \ _ cdot x ^ 2$

अब हमारे पास एक मुक्त गुणांक के बिना बहुआयामी रैखिक प्रतिगमन समस्या है। इस समस्या में विशेषताएँ मात्राएँ हैं $\ sin ^ 2 (x)$ । $\ ln ^ 2 (x)$ । $\ sin (x) \ cdot \ ln (x)$ । $x ^ 2$ ।

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

बहुआयामी रैखिक प्रतिगमन की समस्या को हल करते समय, कुछ गुणांक संशोधित सुविधाओं के साथ मिलेंगे। वास्तव में, फ़ंक्शन के लिए निम्नलिखित प्रतिनिधित्व मिलेगा $च$ :

f (x) = t_{1} c d o t s i n^{2} (x) + t_{2} c d o t l n^{2} (x) + t_{3} c d o t s i n (x) c d o t l n (x) + t 44 c d o t x^{2}

$f (x) = t_1 \ cdot \ sin ^ 2 (x) + t_2 \ cdot \ ln ^ 2 (x) + t_3 \ cdot \ sin (x) \ cdot \ ln (x) + t44 \ cdot x ^ 2$

उसके बाद, आप गुणांक पा सकते हैं $एक$ । $ब$ । $सी$ :

a = s q r t (t_{1}), b = s q r t (t_{2}), c = t_{4}

$a = \ sqrt (t_1), b = \ sqrt (t_2), c = t_4$

इसके अतिरिक्त, यह जाँचने योग्य है $2 \ cdot a \ cdot b \ लगभग t_3$

कार्यान्वयन

शुरू करने के लिए, आपको डेटा पढ़ना चाहिए और संकेत बनाने चाहिए:

 x = [] y = [] for line in open('data.txt'): xx, yy = map(float, line.strip().split()) x.append(xx) y.append(yy) features = [] for xx in x: curFeatures = [ math.sin(xx) ** 2, # a^2 math.log(xx) ** 2, # b^2 math.sin(xx) * math.log(xx), # 2ab xx ** 2 # c ] features.append(curFeatures)

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

 linearModel = lm.LinearRegression() linearModel.fit(features, y) coeffs = linearModel.coef_ a = math.sqrt(coeffs[0]) b = math.sqrt(coeffs[1]) c = coeffs[3] print "free coeff: ", linearModel.intercept_ print "2ab error: ", coeffs[2] - 2 * a * b print a, b, c

इस मामले में, यह पता चला कि मुक्त गुणांक -0.0007 है, और गणना में त्रुटि है $t_3$ 0.00135 की राशि। इस प्रकार, पाया गया समाधान पूरी तरह से सुसंगत है।

गुणांक के साथ अंतिम पंक्ति:

 3.14172883822 2.71842889253 3.999957864335599

समस्या के उत्तर के रूप में इसे प्रतिस्थापित करते हुए, हम अच्छी तरह से योग्य ओके पाते हैं!

टास्क सी। फ्रेशनेस डिटेक्टर

कार्य
कैटबॉस्ट का उपयोग करके एक समाधान प्राप्त करने के लिए स्क्रिप्ट

इस कार्य में, कारकों के मूल्यों और उद्देश्य फ़ंक्शन के मूल्यों के साथ एक तैयार नमूना होने के लिए, एक नए क्वेरी डिटेक्टर का निर्माण करना आवश्यक था। इनपुट फ़ाइल की प्रत्येक पंक्ति में एक अनुरोध वर्णित है। कारक अतीत में इस अनुरोध के कार्यों की आवृत्ति थे: अंतिम घंटे के लिए, दो घंटे, छह घंटे, 12, 24, 72 घंटे। उद्देश्य फ़ंक्शन द्विआधारी है: यदि एक क्लिक पर एक ताजा दस्तावेज़ बनाया गया था, तो यह एक है, अन्यथा यह शून्य है।

भविष्यवाणी के आधार पर, परीक्षण फ़ाइल की प्रत्येक पंक्ति के लिए या तो शून्य या एक को प्रदर्शित करना आवश्यक था। इसके अलावा एक परीक्षण किट पर पाने के लिए आवश्यक है $F_1$ -माता 0.25 पर।

निर्णय

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

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

 0 Auxiliary 1 Auxiliary 8 Target

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

 awk -F "\t" -vOFS="\t" '{print $0, 0}' fr_test.tsv > fr_test.fixed

अब आप कैटबॉस्टल को प्रशिक्षित कर सकते हैं

 catboost calc --input-path fr_test.fixed --cd fields.cd

उसके बाद, भविष्यवाणियां फ़ाइल output.tsv । हालांकि, ये भौतिक भविष्यवाणियां होंगी जिन्हें अभी भी बिनाराइज़ किया जाना है।

हम इस तथ्य से आगे बढ़ेंगे कि प्रशिक्षण और परीक्षण नमूनों में सकारात्मक उदाहरणों का हिस्सा मेल खाता है। प्रशिक्षण नमूने में, सभी प्रश्नों में से लगभग 3/4 में हाल के दस्तावेज़ों पर क्लिक होते हैं। इसलिए, हम वर्गीकरण थ्रेशोल्ड का चयन करते हैं ताकि परीक्षण नमूना से सभी अनुरोधों का लगभग 3/4 सकारात्मक पूर्वानुमान के साथ हो। उदाहरण के लिए, 0.04 की दहलीज के लिए, 200,000 में से 178925 हैं।

इसलिए, हम समाधान फ़ाइल को निम्नानुसार बनाते हैं:

 awk -F "\t" -vOFS="\t" 'NR > 1 {if ($2 > 0.04) print 1; else print 0}' output.tsv > solution.tsv

यहां पहली पंक्ति को छोड़ना आवश्यक था, क्योंकि कैटबॉस्ट अपने स्वयं के स्तंभ नामों को इसमें लिखता है।

इस प्रकार प्राप्त की गई solution.tsv फ़ाइल सत्यापन प्रणाली को भेजी जाती है और फैसले के रूप में एक वैध ओके प्राप्त करती है।

टास्क डी। फीचर चयन

कार्य
समाधान पाने के लिए स्क्रिप्ट

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

निर्णय

जैसा कि आप जानते हैं, लक्षणों का चयन करने के लिए कई प्रकार की विधियाँ हैं।

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

इसके अलावा, सुविधाओं का चयन करने के लिए मेरी अपनी स्क्रिप्ट है। यह स्क्रिप्ट एक लालची रणनीति को लागू करती है: हर बार नमूने में एक कारक जोड़ा जाता है, जैसे कि इसे सबसे अच्छे तरीके से जोड़ना एल्गोरिथ्म के लिए चलती नियंत्रण के अनुमान को प्रभावित करता है। हालांकि, प्रतियोगिता के संदर्भ में, ऐसी स्क्रिप्ट को चलाने के लिए या तो बहुत अधिक समय लगेगा या एक बड़ी कंप्यूटिंग क्लस्टर होगी।

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

पहले आपको मॉडल को प्रशिक्षित करने की आवश्यकता है:

 catboost fit --cd train.cd -f train.txt

फिर एक सुविधा मूल्यांकन चलाएँ:

 catboost fstr --input-path train.txt --cd train.cd

विशेषताओं का महत्व तब feature_strength.tsv फ़ाइल को लिखा जाएगा। पहले कॉलम में, संकेतों के महत्व को दर्ज किया जाएगा, दूसरे में - उनके नाम। फ़ाइल को तुरंत सुविधाओं के गैर-बढ़ते महत्व द्वारा सॉर्ट किया जाता है।

 head feature_strength.tsv 9.897213004 f193 9.669603844 f129 7.500907599 f292 5.903810044 f48 5.268100711 f337 2.508377813 f283 2.024904488 f111 1.933500313 f208 1.878848285 f345 1.652808387 f110

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

कहते हैं, यदि आप शीर्ष 50 संकेतों का चयन करते हैं, तो सार्वजनिक परीक्षण सेट पर आपको 3.6 अंक मिल सकते हैं; यदि आप शीर्ष 40, शीर्ष 30 या शीर्ष 20 चुनते हैं, तो आपको ठीक 4 अंक मिलते हैं। इसलिए, मैंने समाधान के रूप में शीर्ष 20 संकेतों को चुना - इस समाधान को एक बंद परीक्षण सूट पर 4 अंक प्राप्त हुए।

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

इसके अलावा, आपको फीचर स्पेस के आयाम को कम करने के अन्य तरीकों के बारे में याद रखने की आवश्यकता है - उदाहरण के लिए, सुविधाओं को निकालने के लिए तरीकों की एक विस्तृत विविधता है ।

एमएल-ब्लिट्ज: पहले योग्यता दौर के कार्यों का विश्लेषण

समस्या ए। निर्णायक स्टंप

समस्या बी गुणांकों की वसूली

टास्क सी। फ्रेशनेस डिटेक्टर

टास्क डी। फीचर चयन

More articles: