Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
En este tutorial se muestra cómo crear un modelo de regresión mediante ML.NET para predecir precios, en concreto, tarifas de taxi de la ciudad de Nueva York.
En este tutorial, aprenderá a:
- Preparación y comprensión de los datos
- Carga y transformación de los datos
- Elección de un algoritmo de aprendizaje
- Entrenamiento del modelo
- Evaluación del modelo
- Uso del modelo para predicciones
Prerrequisitos
- Visual Studio 2022 o posterior con la carga de trabajo Desarrollo de escritorio de .NET instalada.
Creación de una aplicación de consola
Cree una aplicación de consola de C# denominada "TaxiFarePrediction".
Elija .NET 8 como marco de trabajo que se va a usar. Haga clic en el botón Crear.
Cree un directorio denominado Data en el proyecto para almacenar el conjunto de datos y los archivos de modelo.
Instale el Microsoft.ML y el paquete NuGet Microsoft.ML.FastTree :
Nota:
En este ejemplo se usa la versión estable más reciente de los paquetes NuGet mencionados a menos que se indique lo contrario.
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Administrar paquetes NuGet. Elija "nuget.org" como origen del paquete, seleccione la pestaña Examinar , busque Microsoft.ML, seleccione el paquete de la lista y seleccione Instalar. Seleccione el botón Aceptar en el cuadro de diálogo Vista previa de cambios y, a continuación, seleccione el botón Acepto en el cuadro de diálogo Aceptación de licencia si está de acuerdo con los términos de licencia de los paquetes enumerados. Haga lo mismo para el paquete NuGet Microsoft.ML.FastTree .
Preparación y comprensión de los datos
Descargue el conjunto de datos taxi-fare-train.csv y el conjunto de datos taxi-fare-test.csv y guárdelos en la carpeta Datos que ha creado en el paso anterior. Usamos estos conjuntos de datos para entrenar el modelo de aprendizaje automático y, a continuación, evaluar la precisión del modelo. Estos conjuntos de datos son originalmente del conjunto de datos NYC TLC Taxi Trip.
En el Explorador de soluciones, haga clic con el botón derecho en cada uno de los archivos *.csv y seleccione Propiedades. En Avanzado, cambie el valor de Copiar al directorio de salida a Copiar si es más reciente.
Abra el conjunto de datos taxi-fare-train.csv y examine los encabezados de columna de la primera fila. Eche un vistazo a cada una de las columnas. Comprenda los datos y decida qué columnas son características y cuál es la etiqueta.
label es la columna que desea predecir. Las entradas identificadas Featuresson las entradas que proporciona al modelo para predecir .Label
El conjunto de datos proporcionado contiene las columnas siguientes:
- vendor_id: El identificador del proveedor de taxis es una característica.
- rate_code: El tipo de tarifa del viaje de taxi es una característica.
- passenger_count: El número de pasajeros del viaje es una característica.
- trip_time_in_secs: Cantidad de tiempo que tomó el viaje. Quiere predecir la tarifa del viaje antes de que se complete el viaje. En ese momento, no sabes cuánto tiempo tardaría el viaje. Por lo tanto, el tiempo de viaje no es una característica y excluirá esta columna del modelo.
- trip_distance: La distancia del viaje es una característica.
- payment_type: El método de pago (efectivo o tarjeta de crédito) es una característica.
- fare_amount: La tarifa total de taxi pagada es la etiqueta.
Creación de clases de datos
Cree clases para los datos de entrada y las predicciones:
En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Agregar>nuevo elemento.
En el cuadro de diálogo Agregar nuevo elemento , seleccione Clase y cambie el campo Nombre a TaxiTrip.cs. A continuación, seleccione Agregar.
Agregue las siguientes
usingdirectivas al nuevo archivo:using Microsoft.ML.Data;
Quite la definición de clase existente y agregue el código siguiente, que tiene dos clases TaxiTrip y TaxiTripFarePrediction, al archivo TaxiTrip.cs :
public class TaxiTrip
{
[LoadColumn(0)]
public string? VendorId;
[LoadColumn(1)]
public string? RateCode;
[LoadColumn(2)]
public float PassengerCount;
[LoadColumn(3)]
public float TripTime;
[LoadColumn(4)]
public float TripDistance;
[LoadColumn(5)]
public string? PaymentType;
[LoadColumn(6)]
public float FareAmount;
}
public class TaxiTripFarePrediction
{
[ColumnName("Score")]
public float FareAmount;
}
TaxiTrip es la clase de datos de entrada y tiene definiciones para cada una de las columnas del conjunto de datos. Use el LoadColumnAttribute atributo para especificar los índices de las columnas de origen del conjunto de datos.
La TaxiTripFarePrediction clase representa los resultados previstos. Tiene un único campo float, FareAmount, con un ScoreColumnNameAttribute atributo aplicado. En el caso de la tarea de regresión, la columna Puntuación contiene valores de etiqueta previstos.
Nota:
Use el float tipo para representar valores de punto flotante en las clases de datos de entrada y predicción.
Definición de rutas de acceso de datos y modelos
Agregue las siguientes directivas adicionales using a la parte superior del archivo Program.cs :
using Microsoft.ML;
using TaxiFarePrediction;
Debe crear tres campos para almacenar las rutas de acceso a los archivos con conjuntos de datos y el archivo para guardar el modelo:
-
_trainDataPathcontiene la ruta de acceso al archivo con el conjunto de datos usado para entrenar el modelo. -
_testDataPathcontiene la ruta de acceso al archivo con el conjunto de datos usado para evaluar el modelo. -
_modelPathcontiene la ruta de acceso al archivo donde se almacena el modelo entrenado.
Agregue el siguiente código justo debajo de la sección usings para especificar esas rutas de acceso y para la _textLoader variable:
string _trainDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-train.csv");
string _testDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-test.csv");
string _modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "Model.zip");
Todas las operaciones de ML.NET se inician en la clase MLContext. Inicializar mlContext crea un nuevo entorno de ML.NET que se puede compartir entre los objetos de flujo de trabajo de creación de modelos. Es similar, conceptualmente, a DBContext en Entity Framework.
Inicialización de variables
Reemplace la Console.WriteLine("Hello World!") línea por el código siguiente para declarar e inicializar la mlContext variable:
MLContext mlContext = new MLContext(seed: 0);
Agregue lo siguiente como la siguiente línea de código para llamar al Train método :
var model = Train(mlContext, _trainDataPath);
El Train() método ejecuta las siguientes tareas:
- Carga los datos.
- Extrae y transforma los datos.
- Entrena el modelo.
- Devuelve el modelo.
El Train método entrena el modelo. Cree ese método justo debajo con el código siguiente:
ITransformer Train(MLContext mlContext, string dataPath)
{
}
Carga y transformación de datos
ML.NET usa la interfaz IDataView como una manera flexible y eficaz de describir datos tabulares numéricos o de texto.
IDataView puede cargar archivos de texto o en tiempo real (por ejemplo, archivos de registro o base de datos SQL). Agregue el código siguiente como primera línea del Train() método :
IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(dataPath, hasHeader: true, separatorChar: ',');
Como desea predecir la tarifa de taxi, la FareAmount columna es la Label que predecirá (la salida del modelo). Use la CopyColumnsEstimator clase de transformación para copiar FareAmounty agregue el código siguiente:
var pipeline = mlContext.Transforms.CopyColumns(outputColumnName: "Label", inputColumnName:"FareAmount")
El algoritmo que entrena el modelo requiere características numéricas, por lo que debe transformar los valores de datos categóricos (, VendorIdy RateCode) en números (PaymentTypeVendorIdEncoded, RateCodeEncodedy PaymentTypeEncoded). Para ello, use la clase de transformación OneHotEncodingTransformer , que asigna valores de clave numérica diferentes a los distintos valores de cada una de las columnas y agregue el código siguiente:
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "VendorIdEncoded", inputColumnName:"VendorId"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "RateCodeEncoded", inputColumnName: "RateCode"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "PaymentTypeEncoded", inputColumnName: "PaymentType"))
El último paso de la preparación de datos combina todas las columnas de características en la columna Características mediante la mlContext.Transforms.Concatenate clase de transformación . De forma predeterminada, un algoritmo de aprendizaje procesa solo las características de la columna Características . Agregue el código siguiente:
.Append(mlContext.Transforms.Concatenate("Features", "VendorIdEncoded", "RateCodeEncoded", "PassengerCount", "TripDistance", "PaymentTypeEncoded"))
Elección de un algoritmo de aprendizaje
Este problema consiste en predecir una tarifa de viaje de taxi en Nueva York. A primera vista, puede parecer depender simplemente de la distancia viajada. Sin embargo, los vendedores de taxis en Nueva York cobran diferentes cantidades por otros factores, como pasajeros adicionales o pagar con una tarjeta de crédito en lugar de efectivo. Quiere predecir el valor de precio, que es un valor real, en función de los otros factores del conjunto de datos. Para ello, elija una tarea de aprendizaje automático de regresión .
Anexe la tarea de aprendizaje automático FastTreeRegressionTrainer a las definiciones de transformación de datos agregando lo siguiente como la siguiente línea de código en Train():
.Append(mlContext.Regression.Trainers.FastTree());
Entrenamiento del modelo
Ajuste el modelo al entrenamiento dataview y devuelva el modelo entrenado agregando la siguiente línea de código en el Train() método :
var model = pipeline.Fit(dataView);
El método Fit() entrena el modelo mediante la transformación del conjunto de datos y la aplicación del entrenamiento.
Devuelve el modelo entrenado con la siguiente línea de código en el Train() método :
return model;
Evaluación del modelo
A continuación, evalúe el rendimiento del modelo con los datos de prueba para garantizar la calidad y la validación. Cree el Evaluate() método , justo después Train()de , con el código siguiente:
void Evaluate(MLContext mlContext, ITransformer model)
{
}
El Evaluate método ejecuta las siguientes tareas:
- Carga el conjunto de datos de prueba.
- Crea el evaluador de regresión.
- Evalúa el modelo y crea métricas.
- Muestra las métricas.
Agregue una llamada al nuevo método justo debajo de la Train llamada al método mediante el código siguiente:
Evaluate(mlContext, model);
Cargue el conjunto de datos de prueba mediante el método LoadFromTextFile(). Evalúe el modelo con este conjunto de datos como una comprobación de calidad agregando el código siguiente en el Evaluate método :
IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(_testDataPath, hasHeader: true, separatorChar: ',');
A continuación, transforme los Test datos agregando el código siguiente a Evaluate():
var predictions = model.Transform(dataView);
El método Transform() realiza predicciones para las filas de entrada del conjunto de datos de prueba.
El RegressionContext.Evaluate método calcula las métricas de calidad para el PredictionModel uso del conjunto de datos especificado. Devuelve un RegressionMetrics objeto que contiene las métricas generales calculadas por evaluadores de regresión.
Para mostrarlos para determinar la calidad del modelo, primero debe obtener las métricas. Agregue el código siguiente como la línea siguiente en el Evaluate método :
var metrics = mlContext.Regression.Evaluate(predictions, "Label", "Score");
Una vez que tenga el conjunto de predicciones, el método Evaluate() evalúa el modelo, que compara los valores previstos con el real Labels en el conjunto de datos de prueba y devuelve métricas sobre cómo funciona el modelo.
Agregue el código siguiente para evaluar el modelo y generar las métricas de evaluación:
Console.WriteLine();
Console.WriteLine($"*************************************************");
Console.WriteLine($"* Model quality metrics evaluation ");
Console.WriteLine($"*------------------------------------------------");
RSquared es otra métrica de evaluación de los modelos de regresión. RSquared toma valores entre 0 y 1. Cuanto más cerca se acerque su valor a 1, mejor será el modelo. Agregue el código siguiente al Evaluate método para mostrar el valor RSquared:
Console.WriteLine($"* RSquared Score: {metrics.RSquared:0.##}");
RMS es una de las métricas de evaluación del modelo de regresión. Cuanto menor sea, mejor será el modelo. Agregue el código siguiente al Evaluate método para mostrar el valor RMS:
Console.WriteLine($"* Root Mean Squared Error: {metrics.RootMeanSquaredError:0.##}");
Uso del modelo para predicciones
Cree el TestSinglePrediction método , justo después del Evaluate método , con el código siguiente:
void TestSinglePrediction(MLContext mlContext, ITransformer model)
{
}
El TestSinglePrediction método ejecuta las siguientes tareas:
- Crea un único comentario de los datos de prueba.
- Predice el importe de la tarifa basándose en los datos de prueba.
- Combina datos de prueba y predicciones para los informes.
- Muestra los resultados previstos.
Agregue una llamada al nuevo método justo debajo de la Evaluate llamada al método mediante el código siguiente:
TestSinglePrediction(mlContext, model);
PredictionEngine Use para predecir la tarifa agregando el código siguiente a TestSinglePrediction():
var predictionFunction = mlContext.Model.CreatePredictionEngine<TaxiTrip, TaxiTripFarePrediction>(model);
PredictionEngine es una API útil, que permite realizar una predicción en una sola instancia de datos.
PredictionEngine no es seguro para subprocesos. Es aceptable usarlo en entornos de un solo hilo o en prototipos. Para mejorar el rendimiento y la seguridad de los subprocesos en entornos de producción, use el PredictionEnginePool servicio , que crea un ObjectPool de PredictionEngine objetos para su uso en toda la aplicación. Consulte esta guía sobre cómo usar PredictionEnginePool en una API web de ASP.NET Core.
Nota:
PredictionEnginePool la extensión de servicio está actualmente en versión preliminar.
En este tutorial se utiliza un viaje de prueba de esta clase. Más adelante puede agregar otros escenarios para experimentar con el modelo. Agregue un viaje para probar la predicción del costo del modelo entrenado en el método mediante la TestSinglePrediction() creación de una instancia de TaxiTrip:
var taxiTripSample = new TaxiTrip()
{
VendorId = "VTS",
RateCode = "1",
PassengerCount = 1,
TripTime = 1140,
TripDistance = 3.75f,
PaymentType = "CRD",
FareAmount = 0 // To predict. Actual/Observed = 15.5
};
A continuación, prediga la tarifa en función de una sola instancia de los datos del viaje de taxi y pásela a PredictionEngine ; para ello, agregue lo siguiente como las siguientes líneas de código en el TestSinglePrediction() método :
var prediction = predictionFunction.Predict(taxiTripSample);
La función Predict() realiza una predicción en una sola instancia de datos.
Para mostrar la tarifa prevista del viaje especificado, agregue el código siguiente al TestSinglePrediction método :
Console.WriteLine($"**********************************************************************");
Console.WriteLine($"Predicted fare: {prediction.FareAmount:0.####}, actual fare: 15.5");
Console.WriteLine($"**********************************************************************");
Ejecute el programa para ver la tarifa de taxi prevista para su caso de prueba.
¡Felicidades! Ahora ha creado correctamente un modelo de aprendizaje automático para predecir tarifas de carreras de taxi, ha evaluado su precisión y lo ha utilizado para realizar predicciones. Puede encontrar el código fuente de este tutorial en el repositorio de GitHub dotnet/samples .
Pasos siguientes
En este tutorial, ha aprendido a:
- Preparación y comprensión de los datos
- Creación de una canalización de aprendizaje
- Carga y transformación de los datos
- Elección de un algoritmo de aprendizaje
- Entrenamiento del modelo
- Evaluación del modelo
- Uso del modelo para predicciones
Pase al siguiente tutorial para obtener más información.
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
