.NET, TensorFlow, और Kaggle की पवन चक्कियां - यात्रा शुरू होती है

यह .NET डेवलपर के रूप में कागल प्रतियोगिताओं के अंधेरे जंगल में मेरी चल रही यात्रा के बारे में लेखों की एक श्रृंखला है।

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

टेक स्टैक C # + TensorFlow tf.keras API होगा। आज तक इसे विंडोज की भी आवश्यकता होगी। भविष्य के लेखों में बड़े मॉडल को अपने प्रशिक्षण समय के लिए एक उपयुक्त GPU की आवश्यकता हो सकती है।

चलो अचल संपत्ति की कीमतों की भविष्यवाणी करते हैं!

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

काग्ले पर रजिस्टर करें, यदि आपने अभी तक ऐसा नहीं किया है, तो इस प्रतियोगिता में शामिल हों, और डेटा डाउनलोड करें। लक्ष्य परीक्षण में प्रविष्टियों के लिए बिक्री मूल्य (सेलप्राइस कॉलम) की भविष्यवाणी करना है । पुरालेख में train.csv शामिल है, जिसमें लगभग 1500 प्रविष्टियाँ हैं, जिन पर बिक्री करने के लिए ज्ञात बिक्री मूल्य है। तंत्रिका नेटवर्क में आने से पहले, हम उस डेटासेट को लोड करने और उसे थोड़ा-बहुत एक्सप्लोर करने से शुरू करेंगे।

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

क्या मैंने कहा कि हम डेटासेट तैयार करना छोड़ देंगे? मैंने झूठ बोला! आपको कम से कम एक बार देख लेना है।

अपने आश्चर्य के लिए, मुझे .NET मानक क्लास लाइब्रेरी में एक .csv फ़ाइल लोड करने का एक आसान तरीका नहीं मिला, इसलिए मैंने एक NuGet पैकेज स्थापित किया, जिसे CsvHelper कहा जाता है। डेटा हेरफेर को आसान बनाने के लिए, मुझे अपना नया पसंदीदा LINQ एक्सटेंशन पैकेज MoreLinq भी मिला।




डेटा इस तरह दिखता है (केवल कुछ पंक्तियाँ और स्तंभ):

ईद	MSSubClass	MSZoning	LotFrontage	LotArea
1	60	आर एल	65	8450
2	20	आर एल	80	9600
3	60	आर एल	68	11250
4	70	आर एल	60	9550

डेटा लोड करने के बाद, हमें Id कॉलम को हटाने की आवश्यकता है, क्योंकि यह वास्तव में घर की कीमतों से असंबंधित है:

 var trainData = LoadData("train.csv"); trainData.Columns.Remove("Id"); 

कॉलम डेटा प्रकारों का विश्लेषण

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

 var values = rows.Select(row => (string)row[column]); double floats = values.Percentage(v => double.TryParse(v, out _)); double ints = values.Percentage(v => int.TryParse(v, out _)); int distincts = values.Distinct().Count(); 

संख्यात्मक स्तंभ

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

श्रेणीबद्ध स्तंभ

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

प्रारंभ में, मैंने केवल संख्याओं को 0 से विशिष्टव्यूकाउंट - 1 तक उन्हें सौंपा था, लेकिन इससे बहुत अधिक मतलब नहीं है, क्योंकि वास्तव में "मुखौटा: हरा" के माध्यम से "मुखौटा: हरा" के माध्यम से वास्तव में कोई प्रगति नहीं है। इतनी जल्दी मैंने इसे बदल दिया कि जिसे एक-हॉट एन्कोडिंग कहा जाता है, जहां प्रत्येक अद्वितीय मूल्य को एक अलग इनपुट कॉलम मिलता है। जैसे "मुखौटा: नीला" [1,0,0] बन जाता है, और "मुखौटा: सफेद" बन जाता है [0,0,1]।

उन सभी को एक साथ मिल रहा है

इसे ध्यान में रखते हुए, मैंने निम्नलिखित ValueNormalizer का निर्माण किया, जो कॉलम के अंदर के मूल्यों के बारे में कुछ जानकारी लेता है, और एक फ़ंक्शन देता है, जो एक मान (एक स्ट्रिंग ) को न्यूरल नेटवर्क ( डबल [] ) के लिए एक संख्यात्मक सुविधा वेक्टर में बदल देता है:


अब हमें डेटा को एक प्रारूप में परिवर्तित कर दिया गया है, जो तंत्रिका नेटवर्क के लिए उपयुक्त है। यह एक का निर्माण करने का समय है।

एक तंत्रिका नेटवर्क बनाएँ

आज तक, आपको उसके लिए एक विंडोज मशीन का उपयोग करना होगा।

यदि आपके पास पहले से ही Python और TensorFlow 1.1x स्थापित है, तो आपको बस जरूरत है

 <PackageReference Include="Gradient" Version="0.1.10-tech-preview3" /> 

अपनी आधुनिक .csproj फ़ाइल में। अन्यथा, प्रारंभिक सेटअप करने के लिए ग्रेडिएंट मैनुअल का संदर्भ लें।

एक बार पैकेज उठने और चलने के बाद, हम अपना पहला उथला गहरा नेटवर्क बना सकते हैं।

 using tensorflow; using tensorflow.keras; using tensorflow.keras.layers; using tensorflow.train; ... var model = new Sequential(new Layer[] { new Dense(units: 16, activation: tf.nn.relu_fn), new Dropout(rate: 0.1), new Dense(units: 10, activation: tf.nn.relu_fn), new Dense(units: 1, activation: tf.nn.relu_fn), }); model.compile(optimizer: new AdamOptimizer(), loss: "mean_squared_error"); 

यह 3 न्यूरॉन परतों और एक ड्रॉपआउट परत के साथ एक अप्रशिक्षित तंत्रिका नेटवर्क बनाएगा, जो ओवरफिटिंग को रोकने में मदद करता है।

डाटा फीड करें

TensorFlow अपने डेटा को या तो NumPy सरणियों, या मौजूदा टेंसरों में अपेक्षा करता है। मैं DataRows को NumPy सरणियों में परिवर्तित कर रहा हूं:

 using numpy; ... const string predict = "SalePrice"; ndarray GetInputs(IEnumerable<DataRow> rowSeq) { return np.array(rowSeq.Select(row => np.array( columnTypes .Where(c => c.column.ColumnName != predict) .SelectMany(column => column.normalizer( row.Table.Columns.Contains(column.column.ColumnName) ? (string)row[column.column.ColumnName] : "-1")) .ToArray())) .ToArray() ); } var predictColumn = columnTypes.Single(c => c.column.ColumnName == predict); ndarray trainOutputs = np.array(predictColumn.trainValues .AsDouble() .Select(v => v ?? -1) .ToArray()); ndarray trainInputs = GetInputs(trainRows); 

ऊपर दिए गए कोड में हम प्रत्येक DataRow को एक ndarray में बदलकर उसमें प्रत्येक सेल लेते हैं, और इसके कॉलम के अनुरूप ValueNormalizer को लागू करते हैं। फिर हम सभी पंक्तियों को एक और ndarray में डालते हैं, जिससे सरणी का एक सरणी प्राप्त होता है।

आउटपुट के लिए इस तरह के परिवर्तन की आवश्यकता नहीं होती है, जहाँ हम ट्रेन के मूल्यों को दूसरे ndarray में बदलते हैं ।

ढाल नीचे जाने का समय

इस सेटअप के साथ, हम सभी को अपने नेटवर्क को प्रशिक्षित करने के लिए मॉडल के फिट फ़ंक्शन को कॉल करने की आवश्यकता है :

 model.fit(trainInputs, trainOutputs, epochs: 2000, validation_split: 0.075, verbose: 2); 

यह कॉल वास्तव में सत्यापन के लिए निर्धारित प्रशिक्षण के अंतिम 7.5% को अलग कर देगा, फिर निम्नलिखित 2000 बार दोहराएगा:

1. ट्रेन के बाकी हिस्सों को चमगादड़ों में विभाजित करें
2. तंत्रिका नेटवर्क में एक-एक करके इन बैचों को खिलाएं
3. ऊपर बताए गए नुकसान फ़ंक्शन का उपयोग करके गणना की गई त्रुटि
4. व्यक्तिगत न्यूरॉन कनेक्शन के ग्रेडिएंट्स के माध्यम से त्रुटि को बैकप्रेगेट करें, वजन को समायोजित करें

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

यदि आपने सब कुछ सही ढंग से किया है, तो आपके नुकसान में से एक का एक वर्गमूल 20000 के आदेश पर होना चाहिए।

प्रस्तुत

मैं यहाँ प्रस्तुत करने के लिए फ़ाइल बनाने के बारे में ज्यादा बात नहीं करूँगा। आउटपुट की गणना करने के लिए कोड सरल है:

 const string SubmissionInputFile = "test.csv"; DataTable submissionData = LoadData(SubmissionInputFile); var submissionRows = submissionData.Rows.Cast<DataRow>(); ndarray submissionInputs = GetInputs(submissionRows); ndarray sumissionOutputs = model.predict(submissionInputs); 

जो ज्यादातर कार्यों का उपयोग करता है, जिसे पहले परिभाषित किया गया था।

फिर आपको उन्हें एक .csv फ़ाइल में लिखने की ज़रूरत है, जो कि बस ईद की एक सूची है, पूर्वानुमानित जोड़े जोड़े।

जब आप अपना परिणाम प्रस्तुत करते हैं, तो आपको 0.17 के आदेश पर एक अंक प्राप्त करना चाहिए, जो कि सार्वजनिक लीडरबोर्ड तालिका के अंतिम तिमाही में कहीं होगा। लेकिन हे, अगर यह 27 न्यूरॉन्स के साथ 3 परत नेटवर्क के रूप में सरल था, तो उन pesky डेटा वैज्ञानिकों को प्रमुख अमेरिकी कंपनियों से $ 300k + / y कुल मुआवजा नहीं मिलेगा।

लपेटता हुआ

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

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

लिंक

Kaggle
कागल पर हाउस प्राइस प्रतियोगिता
TensorFlow प्रतिगमन ट्यूटोरियल
TensorFlow मुख पृष्ठ
TensorFlow एपीआई संदर्भ
ग्रेडिएंट (TensorFlow बाइंडिंग)