Compartir a través de

Implementación del modelo de análisis de datos en la aplicación de Windows con las API de Windows ML

En la parte anterior de este tutorial, ha aprendido a compilar y exportar un modelo en formato ONNX. Ahora, le mostraremos cómo insertar el modelo exportado en una aplicación de Windows y ejecutarlo localmente en un dispositivo mediante una llamada a las API de Windows ML.

Cuando hayamos terminado, tendrá una aplicación de análisis de datos en funcionamiento.

Acerca de la aplicación de ejemplo

En este paso del tutorial, creará una aplicación que puede analizar datos tabulares de Irises. La aplicación le permitirá agregar el archivo de Excel con la información de entrada necesaria o escribir manualmente los parámetros de entrada: la longitud y el ancho del sepal y el pétalo de Iris en cm. Estas características se procesarán mediante un modelo ONNX de red neuronal almacenado localmente que creó y entrenó en la parte anterior. En función de la salida del modelo, la aplicación mostrará el tipo iris correcto.

Aquí le guiaremos por ese proceso.

Nota:

Si decide usar el ejemplo de código predefinido, puede clonar el archivo de solución. Clone el repositorio, vaya a este ejemplo y abra el archivo Iris Data Analysis.csproj con Visual Studio. Salte a la parte Iniciar la aplicación de esta página para verlo en uso.

A continuación, le guiaremos sobre cómo crear la aplicación y agregar código de Windows ML.

Creación de una aplicación de Escritorio de Windows ML (C#)

Para realizar una aplicación de Windows ML en funcionamiento, deberá hacer lo siguiente:

  • Cargue un modelo de Machine Learning.
  • Enlace las entradas y salidas del modelo.
  • Evalúe el modelo y muestre resultados significativos.

También deberá crear una interfaz de usuario básica para proporcionar una mejor experiencia de usuario.

Abrir un nuevo proyecto en Visual Studio

  1. Comencemos. Abra Visual Studio y elija Create a new project.

Creación de un proyecto de Visual Studio

  1. En la barra de búsqueda, elija C# como idioma, Windows como plataforma de destino y Dektop como tipo de proyecto. Seleccione NUnit Test Project (.NET Core) como tipo de proyecto y seleccione next para abrir una ventana de configuración para el proyecto.

Creación de una nueva aplicación de proyecto de prueba de NUnit

  1. En la ventana de configuración, haga lo siguiente:
  • Póngale un nombre al proyecto. Aquí, lo llamamos Iris Data Analysis.
  • Elija la ubicación del proyecto.
  • Si usa VS2019, asegúrese de que Create directory for solution está activado.
  • Si está usando VS2017, asegúrese de que Place solution and project in the same directory no esté activado.

Presione create para crear el proyecto. Puede que se abra la ventana de versión mínima de destino. Asegúrese de que la versión mínima esté establecida en Windows 10, versión 1809 (10.0; compilación 17763) o posterior.

  1. Una vez creado el proyecto, vaya a la carpeta del proyecto, abra la carpeta [….\DataClassifier\Assets] y copie Network.onnx el archivo en esta ubicación.

Exploración de la solución de proyecto

Vamos a explorar la solución del proyecto.

Visual Studio creó automáticamente varios archivos de código cs dentro del Explorador de soluciones. MainPage.xaml contiene el código XAML de la GUI y MainPage.xaml.cs contiene el código de la aplicación. Si has creado una aplicación para UWP antes, estos archivos deberían estar muy familiarizados contigo.

Aunque hemos agregado el Network.onnx archivo a la carpeta assets, es necesario agregarlo correctamente a este proyecto.

  1. Haga clic con el botón derecho en la carpeta Activos del Explorador de soluciones y seleccione Add > Existing Item.
  2. Vaya a la carpeta Assets dentro de Iris Data Analysis [….\Iris Data Analysis \Assets], busque el Network.onnx model que copió anteriormente y seleccione Add.
  3. Para asegurarse de que el modelo se compila al compilar la aplicación, haga clic con el botón derecho en el Network.onnx archivo y seleccione Properties. Establecer Build Action en Content.

También deberá crear un nuevo archivo de clase de código cs para dar cabida a algún código de aprendizaje automático adicional, que incluye clases y métodos que llamarán a las API de Windows ML.

  1. Haga clic con el botón derecho en el nombre de la solución en Visual Studio y elija add y new item. En la ventana abierta, seleccione Class y asígnele un nombre: aquí, usamos IrisModel.cs. Aparecerá un nuevo archivo de clase dentro del proyecto.

Agregue un nuevo archivo de clase al proyecto de VS .

Creación de código de Machine Learning

En este paso, crearemos todas las clases y métodos que llamarán a las API de Windows Machine Learning. Esto le permitirá cargar, enlazar y evaluar un modelo de aprendizaje automático de ONNX en el proyecto.

  1. Haga doble clic en el IrisModel.cs archivo.

  2. Reemplace las instrucciones using por las siguientes para acceder a todas las APIs que necesitas.

using System;
using System.Linq;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Storage;

Inicialización de clases de aprendizaje automático

Tendremos que agregar varias clases a IrisModel.cs para ayudarle a interactuar con las API de Windows Machine Learning.

Para obtener acceso al modelo de Machine Learning entrenado, usaremos la LearningModel clase . Esta clase forma parte del Windows.AI.MachineLearning espacio de nombres y representa un modelo de Machine Learning entrenado. Una vez creada la instancia, LearningModel es el objeto principal que se usa para interactuar con las API de Windows ML.

Para evaluar el modelo de aprendizaje, tendrá que crear una sesión de evaluación. Para ello, use la LearningModelSession clase . Esta clase se usa para evaluar modelos de aprendizaje automático y enlaza el modelo a un dispositivo que, a continuación, ejecuta y evalúa el modelo. Al crear una sesión con esta API, también puede seleccionar un dispositivo para ejecutar el modelo (el valor predeterminado es la CPU).

Además, deberá especificar las etiquetas de la salida de los modelos de Machine Learning. Puede conectar esas etiquetas a la salida prevista del modelo más adelante.

Nota:

Para más información sobre LearningModel y LearningModelSession, revise la documentación de la clase LearningModel y la documentación de la clase LearningModelSession.

  1. Copie el código siguiente en el IrisModel.cs archivo.
class IrisModel
    {
        private LearningModel _learning_model;
        private LearningModelSession _session;
        private String[] _labels = { "Iris-setosa", "Iris-versicolor", "Iris-virginica"};

Cargar el modelo

A continuación, deberá cargar el modelo de Machine Learning y crear una sesión, lo que hará con las clases que acaba de definir. Para cargar el modelo, usará varios métodos estáticos de la LearningModel clase ; en nuestro caso, usaremos LoadFromStorageFileAsync, lo que le permite cargar un modelo ONNX de forma ISorageFile asincrónica.

Nota:

Para más información sobre formas adicionales de cargar un modelo, consulte la documentación de carga de un modelo.

  1. Copie el código siguiente en el IrisModel.cs archivo.
public async Task Initialize()
{
    // Load and create the model and session
    var modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets//Network.onnx"));
    _learning_model = await LearningModel.LoadFromStorageFileAsync(modelFile);
    _session = new LearningModelSession(_learning_model);
}

Definición del tensor de entrada del modelo

Ahora, definiremos la entrada correcta en función de los requisitos del modelo. El modelo de red que creó en la parte anterior tiene cuatro valores de entrada. Cada valor de entrada representa los tamaños posibles de cuatro características de iris: longitud del sépalo en cm, ancho del sépalo en cm, longitud pétala en cm y ancho pétalo en cm. En función de esta entrada, el modelo devolverá el tipo de iris que mejor se adapte a esos parámetros. Tendrá que limitar el tamaño de los valores de entrada a los valores lógicos válidos; en este tutorial, usaremos lo siguiente:

  • longitud de los sépalos - 1 cm a 100 cm
  • ancho del sepal : de 1cm a 8 cm
  • longitud de pétalo – 0,5 cm a 10 cm
  • ancho de pétalo – 0,1cm a 5 cm
  1. Copie el código siguiente en el IrisModel.cs archivo.
private float _sepal_length = 1.0f;
public float Sepal_Length
{
    get
    {
        return _sepal_length;
    }
    set
    {
        // validate range [1,10]
        if (value >= 1 && value <= 10)
        {
            _sepal_length = value;
        }
    }
}

private float _sepal_width = 1.0f;
public float Sepal_Width
{
    get
    {
        return _sepal_width;
    }
    set
    {
        // validate range [1, 8]
        if (value >= 1 && value <= 8)
        {
            _sepal_width = value;
        }
    }
}

private float _petal_length = 0.5f;
public float Petal_Length
{
    get
    {
        return _petal_length;
    }
    set
    {
        // validate range [0.5, 10]
        if (value >= 0.5 && value <= 10)
        {
            _petal_length = value;
        }
    }
}

private float _petal_width = 0.1f;
public float Petal_Width
{
    get
    {
        return _petal_width;
    }
    set
    {
        // validate range [0.1, 5]
        if (value >= 0.1 && value <= 5)
        {
            _petal_width = value;
        }
    }
}

Las API de Windows ML aceptan valores de entrada de las cuatro clases descriptivas compatibles con los modelos ONNX: tensores, secuencias, mapas e imágenes. En este caso, el modelo requiere un objeto tensor float de 32 bits con la forma float32[batch_size,4]. Dado que el tamaño del lote es 1, la forma de tensor de entrada es [1x4].

Para crear una entrada de tensor, usará la clase TensorFloat.

La TensorFloat clase forma parte del Windows.AI.MachineLearning espacio de nombres y se usa para definir un objeto de tensor flotante de 32 bits: un tensor de valores de punto flotante de 32 bits. Esta clase contiene varios métodos útiles para compilar un tensor. En su caso, usará el método CreateFromArray para construir una entrada de tensor del tamaño exacto que requiere su modelo. Agregaremos esa llamada dentro del método de evaluación.

Vincular y evaluar el modelo

Ahora que ha definido el tensor de entrada del modelo y ha creado una instancia del modelo y la sesión entrenados, es el momento de crear un método para enlazar y evaluar el modelo de aprendizaje automático entrenado.

Este método es la parte clave de una aplicación de aprendizaje automático. Incluye la tensorización de los valores de entrada y el enlace de la entrada del modelo. Usará este modelo más adelante en el código de la aplicación para evaluar el modelo.

Para enlazar la entrada y la salida, use la LearningModelBinding clase . Un modelo de aprendizaje automático tiene características de entrada y salida, que pasan información hacia y hacia fuera del modelo. Tenga en cuenta que las CARACTERÍSTICAS necesarias deben ser compatibles con las API de Windows ML. La clase LearningModelBinding se aplica a una clase LearningModelSession para enlazar valores a características de entrada y salida con nombre.

La LearningModelBinding clase tiene varios métodos predefinidos que puede usar para enlazar valores a esas características con nombre. Aquí, usará el Bind método para enlazar valores al modelo.

Para evaluar el modelo y recibir resultados de él, llame a los métodos de evaluación predefinidos pertinentes desde LearningModelSession, en su caso, el método Evaluate. Este método proporcionará la funcionalidad que necesita, evaluando el modelo de Machine Learning mediante los valores de características proporcionados por la LearningModelBinding clase .

Nota:

Para obtener información sobre otros métodos de evaluación para ejecutar el modelo, compruebe qué métodos se pueden implementar en LearningModelSession revisando la documentación de la clase LearningModelSession.

Extracción y visualización de los resultados

El modelo devuelve los valores predichos en formato tensor como un resultado float de Tensor. Ahora deberá extraer la salida del modelo y mostrar los resultados correctos. Para ello, convertirá el formato tensor en un vector mediante la ejecución de la función GetAsVectorView() en la salida predicha.

El modelo devuelve tres valores de probabilidad, cada uno que representa un tipo de iris específico. Deberá devolver la etiqueta con la probabilidad más alta.

  1. Copie el código siguiente en el IrisModel.cs archivo.
internal String Evaluate()
{
    // input tensor shape is [1x4]
    long[] shape = new long[2];
    shape[0] = 1;
    shape[1] = 4;

    // set up the input tensor
    float[] input_data = new float[4];
    input_data[0] = _sepal_length;
    input_data[1] = _sepal_width;
    input_data[2] = _petal_length;
    input_data[3] = _petal_width;
    TensorFloat tensor_float = TensorFloat.CreateFromArray(shape, input_data);

    // bind the tensor to "input"
    var binding = new LearningModelBinding(_session);
    binding.Bind("input", tensor_float);

    // evaluate
    var results = _session.Evaluate(binding, "");

    // get the results
    TensorFloat prediction = (TensorFloat)results.Outputs.First().Value;
    var prediction_data = prediction.GetAsVectorView();

    // find the highest predicted value
    int max_index = 0;
    float max_value = 0;
    for (int i = 0; i < prediction_data.Count; i++)
    {
        var val = prediction_data.ElementAt(i);
        if (val > max_value)
        {
            max_value = val;
            max_index = i;
        }
    }

    // return the label corresponding to the highest predicted value
    return _labels.ElementAt(max_index);
}

Ya ha completado la parte de aprendizaje automático del código. Ahora, puede integrar fácilmente el modelo con la aplicación Windows. En la última parte de este tutorial, hemos proporcionado una GUI básica de Windows y un código de control para probar el modelo mediante los métodos que ya ha creado.

Creación de la GUI de la aplicación

  1. Para crear un código de aplicación de GUI para la aplicación, haga doble clic en el MainPage.xaml archivo de código y abra una plantilla predefinida para la GUI.

  2. Copie y pegue el código siguiente en MainPage.xaml, debajo de la “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939"> línea .

    <Grid Margin="30,30,30,30">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <TextBlock x:Name="title" HorizontalAlignment="Left" Text="Data Analysis App - Windows ML" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="32" TextDecorations="Underline" FontWeight="Bold"/>
        <TextBlock x:Name="subtitle" HorizontalAlignment="Left" Text="Provide the input :" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="20" Grid.Row="1" FontWeight="Bold"/>
        <Grid Grid.Row="2">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="sepal_length" Text="sepal length in mm [range of 10 - 100]:" VerticalAlignment="Center"/>
            <TextBlock x:Name="sepal_width" Text="sepal width in mm [range of 10 - 80]:" VerticalAlignment="Center" Grid.Row="1"/>
            <TextBlock x:Name="petal_length" Text="petal length in mm [range of 5 - 100]:" VerticalAlignment="Center" Grid.Row="2"/>
            <TextBlock x:Name="petal_width" Text="sepal width in mm [range of 1 - 50]:" VerticalAlignment="Center" Grid.Row="3"/>

            <Slider x:Name="sepal_length_input" Minimum="10" Maximum="100" Orientation="Horizontal" Grid.Column="1" Width="200" ValueChanged="sepal_length_input_ValueChanged"/>
            <Slider x:Name="sepal_width_input" Minimum="10" Maximum="80" Orientation="Horizontal" Grid.Row="1" Grid.Column="1" Width="200" ValueChanged="sepal_width_input_ValueChanged"/>
            <Slider x:Name="petal_length_input" Minimum="5" Maximum="100" Orientation="Horizontal" Grid.Row="2" Grid.Column="1" Width="200" ValueChanged="petal_length_input_ValueChanged"/>
            <Slider x:Name="petal_width_input" Minimum="1" Maximum="50" Orientation="Horizontal" Grid.Row="3" Grid.Column="1" Width="200" ValueChanged="petal_width_input_ValueChanged"/>
        </Grid>
        <TextBlock x:Name="output" Text="Output:" FontSize="20" FontWeight="Bold" Grid.Row="3"/>
        <Grid Grid.Row="4">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="output_subtitle" Text="Based on the information provided, the Iris type is:"/>
            <TextBlock x:Name="model_output" Text="Model output" FontStyle="Italic"  Grid.Column="1" Margin="10,0,0,0"/>
        </Grid>
    </Grid>

Creación del control de aplicación

El código de control de aplicación, MainPage.xaml.cs, incluye el método principal para ejecutar la aplicación y varios pasos para ejecutar el modelo y ejecutar la salida:

  1. Creará una instancia de un nuevo objeto de la IrisModel clase que creó anteriormente en este tutorial.
  2. Llamará al método Evaluate() que creó en la parte anterior del modelo. Este método se aplicará cuatro veces, uno en cada uno de los parámetros de entrada: longitud del sépalo, ancho del sépalo, longitud de pétalo y ancho de pétalo.

La aplicación mostrará el resultado en función del algoritmo de predicción de aprendizaje automático.

  1. Para crear un código de control de aplicación, haga doble clic en el MainPage.xaml.cs archivo de código y agregue el código siguiente.
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace Iris_Data_Analysis
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private IrisModel _iris_model;

        public MainPage()
        {
            this.InitializeComponent();
            _iris_model = new IrisModel();
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            _iris_model.Initialize();
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }

        private void sepal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Length = (float)sepal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void sepal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Width = (float)sepal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Length = (float)petal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Width = (float)petal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }
    }
}

Inicio de la aplicación

Ahora está listo para iniciar la aplicación y ver los resultados.

Habilite el modo de desarrollador y pruebe la aplicación desde Visual Studio. Asegúrese de que los menús desplegables de la barra de herramientas superior estén configurados a Debug. Cambie la plataforma de soluciones a x64 para ejecutar el proyecto en la máquina local si el dispositivo es de 64 bits o a x86 si el dispositivo es de 32 bits.

La GUI de la aplicación incluye cuatro controles deslizantes para cambiar la entrada de los parámetros necesarios. Cualquier cambio en la entrada generará una nueva salida basada en el algoritmo de predicción. La salida se muestra debajo de los controles deslizantes de entrada.

Puede ver que, dada la entrada de longitud del sépalo = 40 mm, ancho del sépalo = 50, longitud del pétalo = 75 y ancho del pétalo = 15, ¡la aplicación generó una entrada del tipo Iris-versicolor!

Clasificación correcta en la aplicación

Resumen

Acaba de crear su primera aplicación de Windows Machine Learning, desde la creación del modelo hasta la ejecución correcta.

Recursos adicionales

Para obtener más información sobre los temas mencionados en este tutorial, visite los siguientes recursos: