.NET, TensorFlow und die Windmühlen von Kaggle - die Reise beginnt

Dies ist eine Reihe von Artikeln über meine weitere Reise in den dunklen Wald der Kaggle- Wettbewerbe als .NET-Entwickler.

Ich werde mich in diesem und den folgenden Artikeln auf (fast) reine neuronale Netze konzentrieren. Dies bedeutet, dass die meisten langweiligen Teile der Datensatzvorbereitung, wie das Ausfüllen fehlender Werte, die Auswahl von Features, die Analyse von Ausreißern usw. wird absichtlich übersprungen.

Der Tech-Stack ist C # + TensorFlow tf.keras API. Ab heute wird auch Windows benötigt. Größere Modelle in zukünftigen Artikeln benötigen möglicherweise eine geeignete GPU, damit ihre Trainingszeit gesund bleibt.

Lassen Sie uns die Immobilienpreise vorhersagen!

House Prices ist ein großartiger Wettbewerb für Anfänger. Der Datensatz ist klein, es gibt keine besonderen Regeln, die öffentliche Rangliste hat viele Teilnehmer und Sie können bis zu 4 Einträge pro Tag einreichen.

Registrieren Sie sich bei Kaggle. Wenn Sie dies noch nicht getan haben, nehmen Sie an diesem Wettbewerb teil und laden Sie die Daten herunter. Ziel ist es, den Verkaufspreis (Spalte "Verkaufspreis") für Einträge in test.csv vorherzusagen . Das Archiv enthält train.csv , das ungefähr 1500 Einträge mit bekanntem Verkaufspreis zum Trainieren enthält. Wir beginnen mit dem Laden dieses Datensatzes und untersuchen ihn ein wenig, bevor wir uns mit neuronalen Netzen befassen.

Trainingsdaten analysieren

Habe ich gesagt, wir werden die Datensatzvorbereitung überspringen? Ich habe gelogen! Sie müssen mindestens einmal einen Blick darauf werfen.

Zu meiner Überraschung fand ich keine einfache Möglichkeit, eine CSV-Datei in die .NET-Standardklassenbibliothek zu laden, und installierte daher ein NuGet-Paket namens CsvHelper . Um die Datenmanipulation zu vereinfachen, habe ich auch mein neues Lieblings-LINQ-Erweiterungspaket MoreLinq erhalten .




Die Daten sehen folgendermaßen aus (nur wenige Zeilen und Spalten):

Id	MSSubClass	Msoning	LotFrontage	Lotarea
1	60	RL	65	8450
2	20	RL	80	9600
3	60	RL	68	11250
4	70	RL	60	9550

Nach dem Laden der Daten müssen wir die ID- Spalte entfernen, da sie eigentlich nichts mit den Immobilienpreisen zu tun hat:

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

Analysieren der Spaltendatentypen

DataTable leitet Datentypen der Spalten nicht automatisch ab und geht davon aus, dass es sich nur um Zeichenfolgen handelt. Der nächste Schritt besteht also darin, festzustellen, was wir tatsächlich haben. Für jede Spalte habe ich die folgenden Statistiken berechnet: Anzahl der unterschiedlichen Werte, wie viele davon sind Ganzzahlen und wie viele davon sind Gleitkommazahlen (ein Quellcode mit allen Hilfsmethoden wird am Ende des Artikels verknüpft):

 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(); 

Numerische Spalten

Es stellt sich heraus, dass die meisten Spalten tatsächlich Ints sind, aber da neuronale Netze hauptsächlich mit schwebenden Zahlen arbeiten, werden wir sie trotzdem in Doubles konvertieren.

Kategoriale Spalten

Andere Spalten beschreiben Kategorien, zu denen die zum Verkauf stehende Immobilie gehört. Keiner von ihnen hat zu viele verschiedene Werte, was gut ist. Um sie als Eingabe für unser zukünftiges neuronales Netzwerk zu verwenden, müssen sie ebenfalls in double konvertiert werden.

Anfangs habe ich ihnen einfach Zahlen von 0 bis differentValueCount - 1 zugewiesen, aber das macht wenig Sinn, da es eigentlich keinen Fortschritt von "Fassade: Blau" über "Fassade: Grün" zu "Fassade: Weiß" gibt. So früh habe ich das in eine sogenannte One-Hot-Codierung geändert, bei der jeder eindeutige Wert eine separate Eingabespalte erhält. ZB wird "Fassade: Blau" zu [1,0,0] und "Fassade: Weiß" zu [0,0,1].

Sie alle zusammenbringen

Vor diesem Hintergrund habe ich den folgenden ValueNormalizer erstellt , der einige Informationen zu den Werten in der Spalte enthält und eine Funktion zurückgibt, die einen Wert (eine Zeichenfolge ) in einen numerischen Merkmalsvektor für das neuronale Netzwerk ( double [] ) umwandelt:


Jetzt haben wir die Daten in ein Format konvertiert, das für ein neuronales Netzwerk geeignet ist. Es ist Zeit, einen zu bauen.

Bauen Sie ein neuronales Netzwerk auf

Ab heute müssten Sie dafür einen Windows-Computer verwenden.

Wenn Sie Python und TensorFlow 1.1x bereits installiert haben, brauchen Sie nur

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

in Ihrer modernen .csproj-Datei. Andernfalls lesen Sie das Gradient-Handbuch , um die Ersteinrichtung durchzuführen.

Sobald das Paket betriebsbereit ist, können wir unser erstes flaches, tiefes Netzwerk erstellen.

 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"); 

Dadurch wird ein untrainiertes neuronales Netzwerk mit 3 Neuronenschichten und einer Dropout-Schicht erstellt, um eine Überanpassung zu verhindern.

Füttere die Daten

TensorFlow erwartet seine Daten entweder in NumPy-Arrays oder in vorhandenen Tensoren. Ich konvertiere DataRows in NumPy-Arrays:

 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); 

Im obigen Code konvertieren wir jede DataRow in ein ndarray, indem wir jede Zelle darin nehmen und den ValueNormalizer anwenden, der ihrer Spalte entspricht. Dann fügen wir alle Zeilen in ein anderes ndarray ein und erhalten ein Array von Arrays.

Für Ausgaben, bei denen wir nur Zugwerte in ein anderes ndarray konvertieren, ist keine solche Transformation erforderlich.

Zeit, den Gradienten hinunterzukommen

Bei diesem Setup müssen wir lediglich die Anpassungsfunktion des Modells aufrufen, um unser Netzwerk zu trainieren:

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

Dieser Aufruf legt tatsächlich die letzten 7,5% des Trainingssatzes für die Validierung beiseite und wiederholt dann die folgenden 2000 Male:

1. Teilen Sie den Rest von trainInputs in Stapel auf
2. Diese Chargen einzeln in das neuronale Netzwerk einspeisen
3. Berechnen Sie den Fehler mit der oben definierten Verlustfunktion
4. Backpropagieren Sie den Fehler durch die Gradienten einzelner Neuronenverbindungen und passen Sie die Gewichte an

Während des Trainings wird der Netzwerkfehler für die zur Validierung reservierten Daten als val_loss und der Fehler für die Trainingsdaten selbst als Verlust ausgegeben . Wenn val_loss viel größer als der Verlust wird , bedeutet dies im Allgemeinen, dass das Netzwerk überanpasst. Ich werde darauf in den folgenden Artikeln näher eingehen.

Wenn Sie alles richtig gemacht haben, sollte eine Quadratwurzel eines Ihrer Verluste in der Größenordnung von 20000 liegen.

Einreichung

Ich werde nicht viel über das Generieren der Datei sprechen, die hier eingereicht werden soll. Der Code zum Berechnen von Ausgaben ist einfach:

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

die meistens Funktionen verwendet, die zuvor definiert wurden.

Dann müssen Sie sie in eine CSV-Datei schreiben, die einfach eine Liste von ID- und Predicted_Wert-Paaren ist.

Wenn Sie Ihr Ergebnis einreichen, sollten Sie eine Punktzahl in der Größenordnung von 0,17 erhalten, die sich irgendwo im letzten Viertel der öffentlichen Rangliste befindet. Aber hey, wenn es so einfach wäre wie ein 3-Schicht-Netzwerk mit 27 Neuronen, würden diese lästigen Datenwissenschaftler von den großen US-Unternehmen keine Gesamtvergütung von über 300.000 USD pro Jahr erhalten

Einpacken

Der vollständige Quellcode für diesen Eintrag (mit allen Helfern und einigen auskommentierten Teilen meiner früheren Erkundungen und Experimente) enthält ungefähr 200 Zeilen im PasteBin .

Im nächsten Artikel werden Sie sehen, wie meine Spielereien versuchen, in die Top 50% dieser öffentlichen Rangliste zu gelangen. Es wird ein Abenteuer für Amateurgesellen, ein Kampf mit The Windmill of Overfitting mit dem einzigen Werkzeug, das der Wanderer hat - einem größeren Modell (z. B. Deep NN, denken Sie daran, kein manuelles Feature-Engineering!). Es wird weniger ein Coding-Tutorial sein, sondern eher eine Gedankensuche mit wirklich krummer Mathematik und einer seltsamen Schlussfolgerung. Bleib dran!

Links

Kaggle
Hauspreiswettbewerb auf Kaggle
TensorFlow-Regressions-Tutorial
TensorFlow-Homepage
TensorFlow API-Referenz
Gradient (TensorFlow-Bindung)