.NET, TensorFlow y los molinos de viento de Kaggle: el viaje comienza

Esta es una serie de artículos sobre mi viaje en curso en el bosque oscuro de las competencias de Kaggle como desarrollador de .NET.

Me centraré en redes neuronales (casi) puras en este y en los siguientes artículos. Significa que la mayoría de las partes aburridas de la preparación del conjunto de datos, como completar valores perdidos, selección de características, análisis de valores atípicos, etc. será omitido intencionalmente.

La pila tecnológica será C # + TensorFlow tf.keras API. A partir de hoy también requerirá Windows. Los modelos más grandes en los próximos artículos pueden necesitar una GPU adecuada para que su tiempo de entrenamiento permanezca cuerdo.

¡Vamos a predecir los precios inmobiliarios!

Los precios de la vivienda son una gran competencia para los principiantes. Su conjunto de datos es pequeño, no hay reglas especiales, la tabla de clasificación pública tiene muchos participantes y puede enviar hasta 4 entradas por día.

Regístrese en Kaggle, si aún no lo ha hecho, únase a esta competencia y descargue los datos. El objetivo es predecir el precio de venta (columna SalePrice) para las entradas en test.csv . El archivo contiene train.csv , que tiene alrededor de 1500 entradas con un precio de venta conocido para entrenar. Comenzaremos cargando ese conjunto de datos y explorándolo un poco antes de entrar en las redes neuronales.

Analizar datos de entrenamiento

¿Dije que omitiremos la preparación del conjunto de datos? Mentí! Tienes que echar un vistazo al menos una vez.

Para mi sorpresa, no encontré una manera fácil de cargar un archivo .csv en la biblioteca de clases estándar .NET, así que instalé un paquete NuGet, llamado CsvHelper . Para simplificar la manipulación de datos, también obtuve mi nuevo paquete de extensión LINQ favorito MoreLinq .




Los datos se ven así (solo unas pocas filas y columnas):

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

Después de cargar los datos, debemos eliminar la columna Id , ya que en realidad no está relacionada con los precios de la vivienda:

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

Analizando los tipos de datos de columna

DataTable no deduce automáticamente los tipos de datos de las columnas y supone que todas son cadenas. Entonces, el siguiente paso es determinar lo que realmente tenemos. Para cada columna, calculé las siguientes estadísticas: número de valores distintos, cuántos de ellos son enteros y cuántos de ellos son números de coma flotante (un código fuente con todos los métodos auxiliares se vinculará al final del artículo):

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

Columnas numéricas

Resulta que la mayoría de las columnas son en realidad ints, pero dado que las redes neuronales funcionan principalmente en números flotantes, las convertiremos a dobles de todos modos.

Columnas categóricas

Otras columnas describen categorías a las que pertenecía la propiedad en venta. Ninguno de ellos tiene demasiados valores diferentes, lo cual es bueno. Para usarlos como entrada para nuestra futura red neuronal, también deben convertirse al doble .

Inicialmente, simplemente les asigné números de 0 a distinctValueCount - 1, pero eso no tiene mucho sentido, ya que en realidad no hay progresión de "Fachada: Azul" a "Fachada: Verde" a "Fachada: Blanco". Tan temprano que cambié eso a lo que se llama una codificación de un solo punto , donde cada valor único obtiene una columna de entrada separada. Por ejemplo, "Fachada: Azul" se convierte en [1,0,0], y "Fachada: Blanco" se convierte en [0,0,1].

Reuniéndolos a todos

Con eso en mente, construí el siguiente ValueNormalizer , que toma información sobre los valores dentro de la columna y devuelve una función, que transforma un valor (una cadena ) en un vector de características numéricas para la red neuronal ( doble [] ):


Ahora tenemos los datos convertidos a un formato, adecuado para una red neuronal. Es hora de construir uno.

Construye una red neuronal

A partir de hoy, necesitaría usar una máquina Windows para eso.

Si ya tiene Python y TensorFlow 1.1x instalados, todo lo que necesita es

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

en tu archivo .csproj moderno. De lo contrario, consulte el manual Gradient para hacer la configuración inicial.

Una vez que el paquete está en funcionamiento, podemos crear nuestra primera red profunda poco profunda.

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

Esto creará una red neuronal no entrenada con 3 capas de neuronas y una capa de abandono, que ayuda a prevenir el sobreajuste.

Alimentar los datos

TensorFlow espera sus datos en matrices NumPy o tensores existentes. Estoy convirtiendo DataRows en matrices 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); 

En el código anterior, convertimos cada DataRow en un ndarray al tomar cada celda y aplicar el ValueNormalizer correspondiente a su columna. Luego colocamos todas las filas en otro ndarray , obteniendo una matriz de matrices.

No se necesita tal transformación para las salidas, donde simplemente convertimos los valores del tren a otro ndarray .

Es hora de bajar el gradiente

Con esta configuración, todo lo que necesitamos hacer para entrenar nuestra red es llamar a la función de ajuste del modelo:

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

Esta llamada realmente reservará el último 7.5% del conjunto de entrenamiento para la validación, luego repita las siguientes 2000 veces:

1. dividir el resto de entradas de tren en lotes
2. alimentar estos lotes uno por uno en la red neuronal
3. calcular error usando la función de pérdida que definimos anteriormente
4. propaga el error por los gradientes de las conexiones neuronales individuales, ajustando los pesos

Durante el entrenamiento, generará el error de la red en los datos que dejó de lado para la validación como val_loss y el error en los datos de entrenamiento en sí mismo como una pérdida . En general, si val_loss se vuelve mucho mayor que la pérdida , significa que la red comenzó a sobreajustarse. Abordaré eso con más detalle en los siguientes artículos.

Si hiciste todo correctamente, una raíz cuadrada de una de tus pérdidas debería ser del orden de 20000.

Sumisión

No hablaré mucho sobre generar el archivo para enviar aquí. El código para calcular las salidas es 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); 

que utiliza principalmente funciones, que se definieron anteriormente.

Luego, debe escribirlos en un archivo .csv, que es simplemente una lista de Id, pares de valores pronosticados.

Cuando envíe su resultado, debería obtener una puntuación del orden de 0.17, que estaría en algún lugar en el último trimestre de la tabla de clasificación pública. Pero bueno, si fuera tan simple como una red de 3 capas con 27 neuronas, esos molestos científicos de datos no obtendrían compensaciones totales de $ 300k + / a de las principales compañías estadounidenses

Terminando

El código fuente completo para esta entrada (con todos los ayudantes, y algunas de las partes comentadas de mis anteriores exploraciones y experimentos) es de aproximadamente 200 líneas en el PasteBin .

En el próximo artículo, verás a mis travesuras tratando de llegar al 50% superior de esa tabla de clasificación pública. Va a ser la aventura de un viajero aficionado, una pelea con The Windmill of Overfitting con la única herramienta que tiene el peregrino: un modelo más grande (por ejemplo, ¡NN profundo, recuerda, sin ingeniería manual de características!). Será menos un tutorial de codificación, y más una búsqueda de pensamiento con matemáticas realmente maliciosas y una conclusión extraña. Estén atentos!

Enlaces

Kaggle
Concurso de precios de la vivienda en Kaggle
Tutorial de regresión de TensorFlow
Página de inicio de TensorFlow
Referencia de la API de TensorFlow
Gradiente (enlace TensorFlow)