.NET, TensorFlow et les moulins à vent de Kaggle - le voyage commence

Il s'agit d'une série d'articles sur mon voyage en cours dans la forêt sombre des compétitions Kaggle en tant que développeur .NET.

Je me concentrerai sur les réseaux de neurones (presque) purs dans cet article et les suivants. Cela signifie que la plupart des parties ennuyeuses de la préparation de l'ensemble de données, comme le remplissage des valeurs manquantes, la sélection des fonctionnalités, l'analyse des valeurs aberrantes, etc. sera intentionnellement ignoré.

La pile technologique sera l'API C # + TensorFlow tf.keras . À ce jour, il faudra également Windows. Les modèles plus grands dans les futurs articles peuvent avoir besoin d'un GPU approprié pour que leur temps de formation reste sain.

Prédisons les prix de l'immobilier!

Les prix des maisons sont une grande compétition pour les novices. Son jeu de données est petit, il n'y a pas de règles spéciales, le classement public a de nombreux participants et vous pouvez soumettre jusqu'à 4 entrées par jour.

Inscrivez-vous sur Kaggle, si vous ne l'avez pas encore fait, rejoignez ce concours et téléchargez les données. L'objectif est de prédire le prix de vente (colonne SalePrice) pour les entrées dans test.csv . L'archive contient train.csv , qui compte environ 1500 entrées avec un prix de vente connu pour s'entraîner. Nous allons commencer par charger cet ensemble de données et l'explorer un peu avant d'entrer dans les réseaux de neurones.

Analyser les données d'entraînement

Ai-je dit que nous allons sauter la préparation de l'ensemble de données? J'ai menti! Vous devez jeter un oeil au moins une fois.

À ma grande surprise, je n'ai pas trouvé de moyen facile de charger un fichier .csv dans la bibliothèque de classes standard .NET, j'ai donc installé un package NuGet, appelé CsvHelper . Pour simplifier la manipulation des données, j'ai également obtenu mon nouveau package d'extension LINQ préféré MoreLinq .




Les données ressemblent à ceci (seulement quelques lignes et colonnes):

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

Après le chargement des données, nous devons supprimer la colonne Id , car elle n'est en fait pas liée au prix des maisons:

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

Analyse des types de données de colonne

DataTable n'infère pas automatiquement les types de données des colonnes et suppose qu'il s'agit de toutes les chaînes. La prochaine étape consiste donc à déterminer ce que nous avons réellement. Pour chaque colonne, j'ai calculé les statistiques suivantes: nombre de valeurs distinctes, combien d'entre elles sont des nombres entiers et combien d'entre elles sont des nombres à virgule flottante (un code source avec toutes les méthodes d'assistance sera lié à la fin de l'article):

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

Colonnes numériques

Il s'avère que la plupart des colonnes sont en fait des entiers, mais comme les réseaux de neurones fonctionnent principalement sur des nombres flottants, nous les convertirons de toute façon en doubles.

Colonnes catégorielles

D'autres colonnes décrivent les catégories auxquelles appartenait la propriété en vente. Aucun d'entre eux n'a trop de valeurs différentes, ce qui est bien. Pour les utiliser comme entrée pour notre futur réseau de neurones, ils doivent également être convertis pour doubler .

Initialement, je leur ai simplement attribué des numéros de 0 à distinctValueCount - 1, mais cela n'a pas beaucoup de sens, car il n'y a en fait aucune progression de "Facade: Blue" à "Facade: Green" en "Facade: White". Donc, au début, j'ai changé cela en ce qu'on appelle un codage à chaud , où chaque valeur unique obtient une colonne d'entrée distincte. Par exemple, «Facade: Blue» devient [1,0,0] et «Facade: White» devient [0,0,1].

Les réunir tous

Dans cet esprit, j'ai construit le ValueNormalizer suivant, qui prend quelques informations sur les valeurs à l'intérieur de la colonne, et renvoie une fonction, qui transforme une valeur (une chaîne ) en un vecteur d' entité numérique pour le réseau de neurones ( double [] ):


Nous avons maintenant les données converties dans un format adapté à un réseau de neurones. Il est temps d'en construire un.

Construisez un réseau de neurones

À partir d'aujourd'hui, vous devrez utiliser une machine Windows pour cela.

Si vous avez déjà installé Python et TensorFlow 1.1x, tout ce dont vous avez besoin est

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

dans votre fichier .csproj moderne. Sinon, reportez-vous au manuel Gradient pour effectuer la configuration initiale.

Une fois le package opérationnel, nous pouvons créer notre premier réseau profond peu profond.

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

Cela créera un réseau neuronal non formé avec 3 couches de neurones et une couche de décrochage, ce qui aidera à éviter le surapprentissage.

Nourrir les données

TensorFlow attend ses données soit dans des tableaux NumPy, soit dans des tenseurs existants. Je convertis DataRows en tableaux 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); 

Dans le code ci-dessus, nous convertissons chaque DataRow en ndarray en prenant chaque cellule qu'il contient et en appliquant le ValueNormalizer correspondant à sa colonne. Ensuite, nous mettons toutes les lignes dans un autre ndarray , obtenant un tableau de tableaux.

Aucune transformation de ce type n'est nécessaire pour les sorties, où nous convertissons simplement les valeurs du train en un autre ndarray .

Il est temps de descendre le gradient

Avec cette configuration, tout ce que nous devons faire pour former notre réseau est d'appeler la fonction d' ajustement du modèle:

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

Cet appel annulera en fait les 7,5% restants de l'ensemble de formation pour validation, puis répétera les 2000 fois suivantes:

1. diviser le reste du train Entrées en lots
2. alimenter ces lots un par un dans le réseau neuronal
3. erreur de calcul en utilisant la fonction de perte que nous avons définie ci-dessus
4. rétropropagation de l'erreur à travers les gradients des connexions neuronales individuelles, en ajustant les poids

Pendant la formation, il affichera l'erreur du réseau sur les données qu'il a mises de côté pour validation en tant que val_loss et l'erreur sur les données de formation elles-mêmes comme une simple perte . Généralement, si val_loss devient beaucoup plus important que la perte , cela signifie que le réseau a commencé à sur-ajuster. J'aborderai cela plus en détail dans les articles suivants.

Si vous avez tout fait correctement, une racine carrée de l'une de vos pertes devrait être de l'ordre de 20000.

Soumission

Je ne parlerai pas beaucoup de la génération du fichier à soumettre ici. Le code pour calculer les sorties est simple:

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

qui utilise principalement des fonctions, qui ont été définies précédemment.

Ensuite, vous devez les écrire dans un fichier .csv, qui est simplement une liste de paires Id, preded_value.

Lorsque vous soumettez votre résultat, vous devriez obtenir un score de l'ordre de 0,17, qui se situerait quelque part dans le dernier quart du tableau du classement public. Mais bon, si c'était aussi simple qu'un réseau à 3 couches avec 27 neurones, ces scientifiques de données embêtants n'obtiendraient pas 300k $ + / an de compensations totales des grandes entreprises américaines

Envelopper

Le code source complet de cette entrée (avec tous les assistants et certaines des parties commentées de mes explorations et expériences précédentes) est d'environ 200 lignes sur le PasteBin .

Dans le prochain article, vous verrez mes manigances essayer d'atteindre le top 50% de ce classement public. Ce sera une aventure de compagnon amateur, un combat avec The Windmill of Overfitting avec le seul outil dont dispose le vagabond - un modèle plus grand (par exemple, NN profond, rappelez-vous, pas d'ingénierie manuelle des fonctionnalités!). Ce sera moins un tutoriel de codage, et plus une quête de pensée avec des mathématiques vraiment croches et une conclusion étrange. Restez à l'écoute!

Les liens

Kaggle
Concours des prix des logements sur Kaggle
Tutoriel de régression TensorFlow
Page d'accueil de TensorFlow
Référence de l'API TensorFlow
Dégradé (liaison TensorFlow)