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 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
- Comencemos. Abra Visual Studio y elija
Create a new project
.
- En la barra de búsqueda, elija
C#
como idioma,Windows
como plataforma de destino yDektop
como tipo de proyecto. SeleccioneNUnit Test Project (.NET Core)
como tipo de proyecto y seleccionenext
para abrir una ventana de configuración para el proyecto.
- 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.
- Una vez creado el proyecto, vaya a la carpeta del proyecto, abra la carpeta
[….\DataClassifier\Assets]
y copieNetwork.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.
- Haga clic con el botón derecho en la carpeta Activos del Explorador de soluciones y seleccione
Add > Existing Item
. - Vaya a la carpeta Assets dentro de
Iris Data Analysis [….\Iris Data Analysis \Assets]
, busque elNetwork.onnx model
que copió anteriormente y seleccioneAdd
. - 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 seleccioneProperties
. EstablecerBuild Action
enContent
.
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.
- Haga clic con el botón derecho en el nombre de la solución en Visual Studio y elija
add
ynew item
. En la ventana abierta, seleccioneClass
y asígnele un nombre: aquí, usamosIrisModel.cs
. Aparecerá un nuevo archivo de clase dentro del proyecto.
.
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.
Haga doble clic en el
IrisModel.cs
archivo.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.
- 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.
- 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
- 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.
- 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
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.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:
- Creará una instancia de un nuevo objeto de la
IrisModel
clase que creó anteriormente en este tutorial. - 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.
- 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!
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:
- Herramientas de Windows ML: obtenga más información sobre herramientas como el panel de Windows ML, WinMLRunner y el generador de código mglen Windows ML.
- Modelo ONNX: obtenga más información sobre el formato ONNX.
- Rendimiento y memoria de Windows ML: obtenga más información sobre cómo administrar el rendimiento de las aplicaciones con Windows ML.
- Referencia de la API de Windows Machine Learning: obtenga más información sobre tres áreas de las API de Windows ML.