Inicio rápido: Creación de un proyecto de clasificación de imágenes con la biblioteca cliente de Custom Vision o la API REST

Artículo
01/21/2024

Introducción a la biblioteca cliente de Custom Vision para .NET. Siga estos pasos para instalar el paquete y probar el código de ejemplo a fin de crear un modelo de clasificación de imágenes. Podrá crear un proyecto, agregar etiquetas, entrenar el proyecto y utilizar la dirección URL del punto de conexión de predicción del proyecto para probarlo mediante programación. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Si desea crear y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador en su lugar.

Documentación de referencia | Código fuente de la biblioteca (entrenamiento)(predicción) | Paquete (NuGet) (entrenamiento)(predicción) | Ejemplos

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita
El IDE de Visual Studio o la versión actual de .NET Core.
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Vaya a Azure Portal. Si los recursos de Custom Vision que ha creado en la sección Requisitos previos se ha implementado correctamente, seleccione el botón Ir al recurso en Pasos siguientes. Puede encontrar sus claves y puntos de conexión en las páginas de clave y punto de conexión de los recursos, en administración de recursos. Necesitará obtener las claves de los recursos de entrenamiento y predicción, junto con los puntos de conexión de la API.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso de predicción en Azure Portal, que aparece como Id. de recurso.

Sugerencia

También use https://www.customvision.ai/ para obtener estos valores. Después de iniciar sesión, seleccione el icono Configuración en la parte superior derecha. En las páginas Configuración, puede ver todas las claves, identificadores de recurso y puntos de conexión.

Precaución

No incluya la clave directamente en el código ni la exponga nunca públicamente. Consulte el artículo de Seguridad de servicios de Azure AI para ver más opciones de autenticación, como Azure Key Vault.

Para establecer las variables de entorno, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y entorno de desarrollo.

Para establecer la variable de entorno VISION_TRAINING KEY, reemplace your-training-key por una de las claves del recurso de entrenamiento.
Para establecer la variable de entorno VISION_TRAINING_ENDPOINT, reemplace your-training-endpoint por el punto de conexión del recurso de entrenamiento.
Para establecer la variable de entorno VISION_PREDICTION_KEY, reemplace your-prediction-key por una de las claves del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_ENDPOINT, reemplace your-prediction-endpoint por el punto de conexión del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_RESOURCE_ID, reemplace your-resource-id por el id. de recurso del recurso de predicción.

Windows
Linux

setx VISION_TRAINING_KEY your-training-key

setx VISION_TRAINING_ENDPOINT your-training-endpoint

setx VISION_PREDICTION_KEY your-prediction-key

setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint

setx VISION_PREDICTION_RESOURCE_ID your-resource-id

Después de agregar las variables de entorno, puede que tenga que reiniciar todos los programas en ejecución que leerán la variable de entorno, incluida la ventana de consola.

export VISION_TRAINING_KEY=your-training-key

export VISION_TRAINING_ENDPOINT=your-training-endpoint

export VISION_PREDICTION_KEY=your-prediction-key

export VISION_PREDICTION_ENDPOINT=your-prediction-endpoint

export VISION_PREDICTION_RESOURCE_ID=your-resource-id

Después de agregar las variables de entorno ejecute source ~/.bashrc en la ventana de consola para que los cambios surtan efecto.

Creación de una aplicación de C#

En Visual Studio, cree una aplicación de .NET Core.

Instalación de la biblioteca cliente

Después de crear un proyecto, instale la biblioteca cliente; para ello, haga clic con el botón derecho en la solución del proyecto en el Explorador de soluciones y seleccione Administrar paquetes NuGet. En el administrador de paquetes que se abre, seleccione Examinar, marque Incluir versión preliminar y busque Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training y Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction. Seleccione la versión más reciente y, luego, Instalar.

Creación de una aplicación de C#

En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando dotnet new para crear una nueva aplicación de consola con el nombre custom-vision-quickstart. Este comando crea un sencillo proyecto de C#, "Hola mundo", con un solo archivo de origen: program.cs.

dotnet new console -n custom-vision-quickstart

Cambie el directorio a la carpeta de aplicaciones recién creada. Para compilar la aplicación:

dotnet build

La salida de la compilación no debe contener advertencias ni errores.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Instalación de la biblioteca cliente

Dentro del directorio de aplicaciones, instale la biblioteca cliente de Custom Vision para .NET con el siguiente comando:

dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training --version 2.0.0
dotnet add package Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction --version 2.0.0

Sugerencia

¿Desea ver todo el archivo de código de inicio rápido de una vez? Puede encontrarlo en GitHub, que contiene los ejemplos de código de este inicio rápido.

En el directorio del proyecto, abra el archivo program.cs y agregue lo siguiente mediante directivas using:

using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;

En el método Main de la aplicación, cree variables que recuperen las claves y los puntos de conexión del recurso de las variables de entorno. También declarará algunos objetos básicos para usarlos más adelante.

// Retrieve the environment variables for your credentials:
private static string trainingEndpoint = Environment.GetEnvironmentVariable("VISION_TRAINING_ENDPOINT");

private static string trainingKey = Environment.GetEnvironmentVariable("VISION_TRAINING_KEY");
private static string predictionEndpoint = Environment.GetEnvironmentVariable("VISION_PREDICTION_ENDPOINT");
private static string predictionKey = Environment.GetEnvironmentVariable("VISION_PREDICTION_KEY");

private static string predictionResourceId = Environment.GetEnvironmentVariable("VISION_PREDICTION_RESOURCE_ID");

private static List<string> hemlockImages;
private static List<string> japaneseCherryImages;
private static Tag hemlockTag;
private static Tag japaneseCherryTag;
private static Iteration iteration;
private static string publishedModelName = "treeClassModel";
private static MemoryStream testImage;

En el método Main de la aplicación, agregue llamadas para los métodos que se usan en este inicio rápido. Las implementará más adelante.

CustomVisionTrainingClient trainingApi = AuthenticateTraining(trainingEndpoint, trainingKey);
CustomVisionPredictionClient predictionApi = AuthenticatePrediction(predictionEndpoint, predictionKey);

Project project = CreateProject(trainingApi);
AddTags(trainingApi, project);
UploadImages(trainingApi, project);
TrainProject(trainingApi, project);
PublishIteration(trainingApi, project);
TestIteration(predictionApi, project);
DeleteProject(trainingApi, project);

Autenticar el cliente

En un nuevo método, cree instancias de clientes de entrenamiento y predicción mediante el punto de conexión y las claves.

private static CustomVisionTrainingClient AuthenticateTraining(string endpoint, string trainingKey)
{
    // Create the Api, passing in the training key
    CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(trainingKey))
    {
        Endpoint = endpoint
    };
    return trainingApi;
}
private static CustomVisionPredictionClient AuthenticatePrediction(string endpoint, string predictionKey)
{
    // Create a prediction endpoint, passing in the obtained prediction key
    CustomVisionPredictionClient predictionApi = new CustomVisionPredictionClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials(predictionKey))
    {
        Endpoint = endpoint
    };
    return predictionApi;
}

Creación de un proyecto de Custom Vision

Este siguiente fragmento de código crea un proyecto de clasificación de imágenes. El proyecto creado se mostrará en el sitio web de Custom Vision. Consulte el método CreateProject para especificar otras opciones al crear el proyecto (explicadas en la guía del portal web Compilación de un clasificador).

private static Project CreateProject(CustomVisionTrainingClient trainingApi)
{
    // Create a new project
    Console.WriteLine("Creating new project:");
    return trainingApi.CreateProject("My New Project");
}

Adición de etiquetas al proyecto

Este método define las etiquetas en las que se va a entrenar el modelo.

private static void AddTags(CustomVisionTrainingClient trainingApi, Project project)
{
    // Make two tags in the new project
    hemlockTag = trainingApi.CreateTag(project.Id, "Hemlock");
    japaneseCherryTag = trainingApi.CreateTag(project.Id, "Japanese Cherry");
}

Carga y etiquetado de imágenes

En primer lugar, descargue las imágenes de ejemplo de este proyecto. Guarde el contenido de la carpeta de imágenes de ejemplo en el dispositivo local.

Luego, defina un método auxiliar para cargar las imágenes en este directorio. Puede que tenga que editar el argumento GetFiles para que apunte a la ubicación donde se guardan las imágenes.

private static void LoadImagesFromDisk()
{
    // this loads the images to be uploaded from disk into memory
    hemlockImages = Directory.GetFiles(Path.Combine("Images", "Hemlock")).ToList();
    japaneseCherryImages = Directory.GetFiles(Path.Combine("Images", "Japanese_Cherry")).ToList();
    testImage = new MemoryStream(File.ReadAllBytes(Path.Combine("Images", "Test", "test_image.jpg")));
}

Luego, defina un método para cargar las imágenes y aplique etiquetas según su ubicación de carpeta (las imágenes ya están ordenadas). Puede cargar imágenes y etiquetarlas de forma iterativa o en un lote (hasta 64 por lote). Este fragmento de código contiene ejemplos de ambos casos.

private static void UploadImages(CustomVisionTrainingClient trainingApi, Project project)
{
    // Add some images to the tags
    Console.WriteLine("\tUploading images");
    LoadImagesFromDisk();

    // Images can be uploaded one at a time
    foreach (var image in hemlockImages)
    {
        using (var stream = new MemoryStream(File.ReadAllBytes(image)))
        {
            trainingApi.CreateImagesFromData(project.Id, stream, new List<Guid>() { hemlockTag.Id });
        }
    }

    // Or uploaded in a single batch 
    var imageFiles = japaneseCherryImages.Select(img => new ImageFileCreateEntry(Path.GetFileName(img), File.ReadAllBytes(img))).ToList();
    trainingApi.CreateImagesFromFiles(project.Id, new ImageFileCreateBatch(imageFiles, new List<Guid>() { japaneseCherryTag.Id }));

}

Entrenamiento del proyecto

Este método crea la primera iteración de entrenamiento del proyecto. Se consulta el servicio hasta que finaliza el entrenamiento.

private static void TrainProject(CustomVisionTrainingClient trainingApi, Project project)
{
    // Now there are images with tags start training the project
    Console.WriteLine("\tTraining");
    iteration = trainingApi.TrainProject(project.Id);

    // The returned iteration will be in progress, and can be queried periodically to see when it has completed
    while (iteration.Status == "Training")
    {
        Console.WriteLine("Waiting 10 seconds for training to complete...");
        Thread.Sleep(10000);

        // Re-query the iteration to get it's updated status
        iteration = trainingApi.GetIteration(project.Id, iteration.Id);
    }
}

Sugerencia

Entrenamiento con etiquetas seleccionadas

Opcionalmente, puede entrenar solo en un subconjunto de las etiquetas aplicadas. Es posible que desee hacer esto si aún no ha aplicado suficientes etiquetas de un tipo determinado, pero tiene bastantes de las otras. En la llamada a TrainProject, use el parámetro trainingParameters. Construya un parámetro TrainingParameters y establezca su propiedad SelectedTags en una lista de identificadores de las etiquetas que desea usar. El modelo se entrenará para reconocer solo las etiquetas de esa lista.

Publicación de la iteración actual

Este método hace que la iteración actual del modelo esté disponible para realizar consultas. Puede usar el nombre del modelo como referencia para enviar solicitudes de predicción. Debe escribir su propio valor para predictionResourceId. Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso en Azure Portal, que aparece como Id. de recurso.

private static void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
    trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
    Console.WriteLine("Done!\n");

    // Now there is a trained endpoint, it can be used to make a prediction
}

Prueba del punto de conexión de la predicción

Esta parte del script carga la imagen de prueba, consulta el punto de conexión del modelo y envía los datos de la predicción a la consola.

private static void TestIteration(CustomVisionPredictionClient predictionApi, Project project)
{

    // Make a prediction against the new project
    Console.WriteLine("Making a prediction:");
    var result = predictionApi.ClassifyImage(project.Id, publishedModelName, testImage);

    // Loop over each prediction and write out the results
    foreach (var c in result.Predictions)
    {
        Console.WriteLine($"\t{c.TagName}: {c.Probability:P1}");
    }
}

Ejecución de la aplicación

IDE de Visual Studio
CLI

Ejecute la aplicación haciendo clic en el botón Depurar en la parte superior de la ventana del IDE.

Ejecute la aplicación desde el directorio de la aplicación con el comando dotnet run.

dotnet run

Cuando se ejecuta la aplicación, se debería abrir una ventana de consola y escribir la salida siguiente:

Creating new project:
        Uploading images
        Training
Done!

Making a prediction:
        Hemlock: 95.0%
        Japanese Cherry: 0.0%

Luego puede comprobar que la imagen de prueba (que se encuentra en imágenes/Test/) se ha etiquetado correctamente. Para salir de la aplicación, presione cualquier tecla. También puede volver al sitio web de Custom Vision y ver el estado actual del proyecto recién creado.

Limpieza de recursos

Si desea implementar su propio proyecto de clasificación de imágenes (o probar un proyecto de detección de objetos), puede que desee eliminar el proyecto de identificación de árboles de este ejemplo. Una suscripción gratuita sirve para dos proyectos de Custom Vision.

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Ahora ha realizado cada paso del proceso de clasificación de imágenes en el código. En este ejemplo se ejecuta una sola iteración de entrenamiento, pero a menudo necesitará entrenar y probar el modelo varias veces para hacerlo más preciso.

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
El código fuente correspondiente a este ejemplo se encuentra disponible en GitHub.
Documentación de referencia del SDK

En este artículo se proporciona información y un ejemplo de código que pueden ayudarle a empezar a utilizar la biblioteca cliente de Custom Vision para Go para crear un modelo de clasificación de imágenes. Podrá crear un proyecto, agregar etiquetas, entrenar el proyecto y utilizar la dirección URL del punto de conexión de predicción del proyecto para probarlo mediante programación. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Si desea crear y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador en su lugar.

Use la biblioteca cliente de Custom Vision para Go para:

Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Documentación de referencia (entrenamiento)(predicción)

Prerrequisitos

Una suscripción a Azure: cree una cuenta gratuita
Go 1.8+
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción y obtener las claves y el punto de conexión.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso de predicción en Azure Portal, que aparece como Id. de recurso.

Sugerencia

Precaución

Para establecer las variables de entorno, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y entorno de desarrollo.

Para establecer la variable de entorno VISION_TRAINING KEY, reemplace your-training-key por una de las claves del recurso de entrenamiento.
Para establecer la variable de entorno VISION_TRAINING_ENDPOINT, reemplace your-training-endpoint por el punto de conexión del recurso de entrenamiento.
Para establecer la variable de entorno VISION_PREDICTION_KEY, reemplace your-prediction-key por una de las claves del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_ENDPOINT, reemplace your-prediction-endpoint por el punto de conexión del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_RESOURCE_ID, reemplace your-resource-id por el id. de recurso del recurso de predicción.

Windows
Linux

setx VISION_TRAINING_KEY your-training-key

setx VISION_TRAINING_ENDPOINT your-training-endpoint

setx VISION_PREDICTION_KEY your-prediction-key

setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint

setx VISION_PREDICTION_RESOURCE_ID your-resource-id

Después de agregar las variables de entorno, puede que tenga que reiniciar todos los programas en ejecución que leerán la variable de entorno, incluida la ventana de consola.

export VISION_TRAINING_KEY=your-training-key

export VISION_TRAINING_ENDPOINT=your-training-endpoint

export VISION_PREDICTION_KEY=your-prediction-key

export VISION_PREDICTION_ENDPOINT=your-prediction-endpoint

export VISION_PREDICTION_RESOURCE_ID=your-resource-id

Después de agregar las variables de entorno ejecute source ~/.bashrc en la ventana de consola para que los cambios surtan efecto.

Instalación

Instalación de la biblioteca cliente de Custom Vision

Para escribir una aplicación de análisis de imágenes con Custom Vision para Go, necesitará la biblioteca cliente del servicio Custom Vision. En PowerShell, ejecute el siguiente comando:

go get -u github.com/Azure/azure-sdk-for-go/...

O bien, si usa dep, dentro de su repositorio ejecute:

dep ensure -add github.com/Azure/azure-sdk-for-go

Obtención de las imágenes de ejemplo

En este ejemplo se utilizan las imágenes del repositorio Muestras de SDK de Python de servicios de Azure AI de GitHub. Clone o descargue este repositorio en el entorno de desarrollo. Recuerde la ubicación de la carpeta para un paso posterior.

Creación del proyecto de Custom Vision

Cree un archivo denominado sample.go en el directorio del proyecto que prefiera y ábralo en el editor de código que prefiera.

Para crear un proyecto de Custom Vision Service, agregue el siguiente código al script.

Consulte el método CreateProject para especificar otras opciones al crear el proyecto (explicadas en la guía del portal web Compilación de un clasificador).

import(
    "context"
    "bytes"
    "fmt"
    "io/ioutil"
    "path"
    "log"
    "time"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/training"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v3.0/customvision/prediction"
)

var (
    training_key string = os.Getenv("VISION_TRAINING_KEY")
    prediction_key string = os.Getenv("VISION_PREDICTION_KEY")
    prediction_resource_id = os.Getenv("VISION_PREDICTION_RESOURCE_ID")
    endpoint string = os.Getenv("VISION_ENDPOINT")    

    project_name string = "Go Sample Project"
    iteration_publish_name = "classifyModel"
    sampleDataDirectory = "<path to sample images>"
)

func main() {
    fmt.Println("Creating project...")

    ctx = context.Background()

    trainer := training.New(training_key, endpoint)

    project, err := trainer.CreateProject(ctx, project_name, "sample project", nil, string(training.Multilabel))
    if (err != nil) {
        log.Fatal(err)
    }

Creación de etiquetas en el proyecto

Para crear etiquetas de clasificación para el proyecto, agregue el código siguiente al final de sample.go:

// Make two tags in the new project
hemlockTag, _ := trainer.CreateTag(ctx, *project.ID, "Hemlock", "Hemlock tree tag", string(training.Regular))
cherryTag, _ := trainer.CreateTag(ctx, *project.ID, "Japanese Cherry", "Japanese cherry tree tag", string(training.Regular))

Carga y etiquetado de imágenes

Para agregar las imágenes de ejemplo al proyecto, inserte el siguiente código después de crear la etiqueta. Este código carga cada imagen con su etiqueta correspondiente. Puede cargar hasta 64 imágenes en un único lote.

Nota

Tendrá que cambiar la ruta de acceso a las imágenes en función de donde haya descargado anteriormente el proyecto Muestras de SDK Go de servicios de Azure AI.

fmt.Println("Adding images...")
japaneseCherryImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Japanese Cherry"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

hemLockImages, err := ioutil.ReadDir(path.Join(sampleDataDirectory, "Hemlock"))
if err != nil {
    fmt.Println("Error finding Sample images")
}

for _, file := range hemLockImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Hemlock", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))

    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ hemlockTag.ID.String() })
}

for _, file := range japaneseCherryImages {
    imageFile, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Japanese Cherry", file.Name()))
    imageData := ioutil.NopCloser(bytes.NewReader(imageFile))
    trainer.CreateImagesFromData(ctx, *project.ID, imageData, []string{ cherryTag.ID.String() })
}

Entrenamiento y publicación del proyecto

Este código crea la primera iteración del modelo de predicción y, después, publica dicha iteración en el punto de conexión de la predicción. El nombre que se da a la iteración publicada se puede utilizar para enviar solicitudes de predicción. Una iteración no está disponible en el punto de conexión de la predicción hasta que se publica.

fmt.Println("Training...")
iteration, _ := trainer.TrainProject(ctx, *project.ID)
for {
    if *iteration.Status != "Training" {
        break
    }
    fmt.Println("Training status: " + *iteration.Status)
    time.Sleep(1 * time.Second)
    iteration, _ = trainer.GetIteration(ctx, *project.ID, *iteration.ID)
}
fmt.Println("Training status: " + *iteration.Status)

trainer.PublishIteration(ctx, *project.ID, *iteration.ID, iteration_publish_name, prediction_resource_id))

Uso del punto de conexión de la predicción

Para enviar una imagen al punto de conexión de la predicción y recuperar la predicción, agregue el código siguiente al final del archivo:

    fmt.Println("Predicting...")
    predictor := prediction.New(prediction_key, endpoint)

    testImageData, _ := ioutil.ReadFile(path.Join(sampleDataDirectory, "Test", "test_image.jpg"))
    results, _ := predictor.ClassifyImage(ctx, *project.ID, iteration_publish_name, ioutil.NopCloser(bytes.NewReader(testImageData)), "")

    for _, prediction := range *results.Predictions    {
        fmt.Printf("\t%s: %.2f%%", *prediction.TagName, *prediction.Probability * 100)
        fmt.Println("")
    }
}

Ejecución de la aplicación

Ejecute sample.go.

go run sample.go

La salida de la aplicación debe ser similar al texto siguiente:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

A continuación, puede comprobar que la imagen de prueba (que se encuentra en <base_image_url>/images/Test/) se haya etiquetado correctamente. También puede volver al sitio web de Custom Vision y ver el estado actual del proyecto recién creado.

Limpieza de recursos

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Ya ha visto cómo todos los pasos del proceso de detección de objetos se pueden realizar en código. En este ejemplo se ejecuta una sola iteración de entrenamiento, pero a menudo necesitará entrenar y probar el modelo varias veces para hacerlo más preciso.

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
Documentación de referencia del SDK (entrenamiento)
Documentación de referencia del SDK (predicción)

Comience a usar la biblioteca cliente de Custom Vision para Java con el fin de crear un modelo de clasificación de imágenes. Siga estos pasos para instalar el paquete y probar el código de ejemplo para realizar tareas básicas. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Si desea crear y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador en su lugar.

Use la biblioteca cliente de Custom Vision para Java realizar las siguientes tareas:

Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Documentación de referencia | Código fuente de la biblioteca (entrenamiento)(predicción) | Artefacto (Maven) (entrenamiento)(predicción) | Ejemplos

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita.
La versión actual de Java Development Kit (JDK)
La herramienta de compilación de Gradle u otro administrador de dependencias.
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso de predicción en Azure Portal, que aparece como Id. de recurso.

Sugerencia

Precaución

Para establecer las variables de entorno, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y entorno de desarrollo.

Para establecer la variable de entorno VISION_TRAINING KEY, reemplace your-training-key por una de las claves del recurso de entrenamiento.
Para establecer la variable de entorno VISION_TRAINING_ENDPOINT, reemplace your-training-endpoint por el punto de conexión del recurso de entrenamiento.
Para establecer la variable de entorno VISION_PREDICTION_KEY, reemplace your-prediction-key por una de las claves del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_ENDPOINT, reemplace your-prediction-endpoint por el punto de conexión del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_RESOURCE_ID, reemplace your-resource-id por el id. de recurso del recurso de predicción.

Windows
Linux

setx VISION_TRAINING_KEY your-training-key

setx VISION_TRAINING_ENDPOINT your-training-endpoint

setx VISION_PREDICTION_KEY your-prediction-key

setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint

setx VISION_PREDICTION_RESOURCE_ID your-resource-id

Después de agregar las variables de entorno, puede que tenga que reiniciar todos los programas en ejecución que leerán la variable de entorno, incluida la ventana de consola.

export VISION_TRAINING_KEY=your-training-key

export VISION_TRAINING_ENDPOINT=your-training-endpoint

export VISION_PREDICTION_KEY=your-prediction-key

export VISION_PREDICTION_ENDPOINT=your-prediction-endpoint

export VISION_PREDICTION_RESOURCE_ID=your-resource-id

Después de agregar las variables de entorno ejecute source ~/.bashrc en la ventana de consola para que los cambios surtan efecto.

Instalación

Creación de un proyecto de Gradle

En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

mkdir myapp && cd myapp

Ejecute el comando gradle init desde el directorio de trabajo. Este comando creará archivos de compilación esenciales para Gradle, como build.gradle.kts, que se usa en tiempo de ejecución para crear y configurar la aplicación.

gradle init --type basic

Cuando se le solicite que elija un DSL, seleccione Kotlin.

Instalación de la biblioteca cliente

Busque build.gradle.kts y ábralo con el IDE o el editor de texto que prefiera. A continuación, cópielo en la siguiente configuración de compilación. Esta configuración define el proyecto como una aplicación Java cuyo punto de entrada es la clase CustomVisionQuickstart. Importa las bibliotecas de Custom Vision.

plugins {
    java
    application
}
application { 
    mainClassName = "CustomVisionQuickstart"
}
repositories {
    mavenCentral()
}
dependencies {
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-training", version = "1.1.0-preview.2")
    compile(group = "com.azure", name = "azure-cognitiveservices-customvision-prediction", version = "1.1.0-preview.2")
}

Creación de un archivo Java

En el directorio de trabajo, ejecute el siguiente comando para crear una carpeta de origen del proyecto:

mkdir -p src/main/java

Vaya a la nueva carpeta y cree un archivo denominado CustomVisionQuickstart.java. Ábralo en el editor o el IDE que prefiera y agregue las siguientes instrucciones import:

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

import com.google.common.io.ByteStreams;

import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Classifier;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Domain;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.DomainType;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateBatch;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.ImageFileCreateEntry;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Iteration;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Project;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Region;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.TrainProjectOptionalParameter;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.Trainings;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.CustomVisionTrainingManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.ImagePrediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.models.Prediction;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionClient;
import com.microsoft.azure.cognitiveservices.vision.customvision.prediction.CustomVisionPredictionManager;
import com.microsoft.azure.cognitiveservices.vision.customvision.training.models.Tag;

Sugerencia

¿Desea ver todo el archivo de código de inicio rápido de una vez? Puede encontrarlo en GitHub, que contiene los ejemplos de código de este inicio rápido.

En la clase CustomVisionQuickstart de la aplicación, cree variables que recuperen las claves y el punto de conexión del recurso de las variables de entorno.

// retrieve environment variables
final static String trainingApiKey = System.getenv("VISION_TRAINING_KEY");
final static String trainingEndpoint = System.getenv("VISION_TRAINING_ENDPOINT");
final static String predictionApiKey = System.getenv("VISION_PREDICTION_KEY");
final static String predictionEndpoint = System.getenv("VISION_PREDICTION_ENDPOINT");
final static String predictionResourceId = System.getenv("VISION_PREDICTION_RESOURCE_ID");

Importante

Vaya a Azure Portal. Si los recursos de Custom Vision que ha creado en la sección Requisitos previos se han implementado correctamente, seleccione el botón Ir al recurso en Pasos siguientes. Puede encontrar las claves y el punto de conexión en las páginas de clave y punto de conexión de los recursos. Necesitará obtener las claves de los recursos de entrenamiento y predicción, junto con el punto de conexión de API del recurso de entrenamiento.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso en Azure Portal, que aparece como Id. de recurso.

Importante

Recuerde quitar las claves del código cuando termine, y nunca las haga públicas. En el caso de producción, use una forma segura de almacenar sus credenciales y acceder a ellas, como Azure Key Vault. Consulte el artículo Seguridad de los servicios de Azure AI para más información.

En el método main de la aplicación, agregue llamadas para los métodos que se usan en este inicio rápido. Se definirán más adelante.

Project project = createProject(trainClient);
addTags(trainClient, project);
uploadImages(trainClient, project);
trainProject(trainClient, project);
publishIteration(trainClient, project);
testProject(predictor, project);

Modelo de objetos

Las siguientes clases e interfaces determinan algunas de las características principales de la biblioteca cliente de Custom Vision para Java.

Nombre	Descripción
CustomVisionTrainingClient	Esta clase controla la creación, el entrenamiento y la publicación de los modelos.
CustomVisionPredictionClient	Esta clase controla la consulta de las predicciones de clasificación de imágenes en los modelos.
ImagePrediction	Esta clase define una sola predicción en una sola imagen. Incluye las propiedades para el identificador y el nombre de objeto, y una puntuación de confianza.

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes tareas con la biblioteca cliente de Custom Vision para Java:

Autenticar el cliente
Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Autenticar el cliente

En el método main, cree instancias de clientes de entrenamiento y predicción mediante su punto de conexión y claves.

// Authenticate
CustomVisionTrainingClient trainClient = CustomVisionTrainingManager
        .authenticate(trainingEndpoint, trainingApiKey)
        .withEndpoint(trainingEndpoint);
CustomVisionPredictionClient predictor = CustomVisionPredictionManager
        .authenticate(predictionEndpoint, predictionApiKey)
        .withEndpoint(predictionEndpoint);

Creación de un proyecto de Custom Vision

Este método crea un proyecto de clasificación de imágenes. El proyecto creado se mostrará en el sitio web de Custom Vision que ha visitado anteriormente. Consulte las sobrecargas del método CreateProject para especificar otras opciones al crear el proyecto (explicadas en la guía del portal web Creación de un detector).

public static Project createProject(CustomVisionTrainingClient trainClient) {
    System.out.println("ImageClassification Sample");
    Trainings trainer = trainClient.trainings();

    System.out.println("Creating project...");
    Project project = trainer.createProject().withName("Sample Java Project").execute();

    return project;
}

Adición de etiquetas al proyecto

Este método define las etiquetas en las que se va a entrenar el modelo.

public static void addTags(CustomVisionTrainingClient trainClient, Project project) {

    Trainings trainer = trainClient.trainings();

    // create hemlock tag
    Tag hemlockTag = trainer.createTag().withProjectId(project.id()).withName("Hemlock").execute();
    // create cherry tag
    Tag cherryTag = trainer.createTag().withProjectId(project.id()).withName("Japanese Cherry").execute();
}

Carga y etiquetado de imágenes

En primer lugar, descargue las imágenes de ejemplo de este proyecto. Guarde el contenido de la carpeta de imágenes de ejemplo en el dispositivo local.

public static void uploadImages(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    System.out.println("Adding images...");
    for (int i = 1; i <= 10; i++) {
        String fileName = "hemlock_" + i + ".jpg";
        byte[] contents = GetImage("/Hemlock", fileName);
        AddImageToProject(trainer, project, fileName, contents, hemlockTag.id(), null);
    }

    for (int i = 1; i <= 10; i++) {
        String fileName = "japanese_cherry_" + i + ".jpg";
        byte[] contents = GetImage("/Japanese_Cherry", fileName);
        AddImageToProject(trainer, project, fileName, contents, cherryTag.id(), null);
    }
}

El fragmento de código anterior usa dos funciones auxiliares que recuperan las imágenes como flujos de recursos y las cargan en el servicio (puede cargar hasta 64 imágenes en un único lote).

private static void AddImageToProject(Trainings trainer, Project project, String fileName, byte[] contents,
        UUID tag, double[] regionValues) {
    System.out.println("Adding image: " + fileName);
    ImageFileCreateEntry file = new ImageFileCreateEntry().withName(fileName).withContents(contents);

    ImageFileCreateBatch batch = new ImageFileCreateBatch().withImages(Collections.singletonList(file));

    // If Optional region is specified, tack it on and place the tag there,
    // otherwise
    // add it to the batch.
    if (regionValues != null) {
        Region region = new Region().withTagId(tag).withLeft(regionValues[0]).withTop(regionValues[1])
                .withWidth(regionValues[2]).withHeight(regionValues[3]);
        file = file.withRegions(Collections.singletonList(region));
    } else {
        batch = batch.withTagIds(Collections.singletonList(tag));
    }

    trainer.createImagesFromFiles(project.id(), batch);
}

private static byte[] GetImage(String folder, String fileName) {
    try {
        return ByteStreams.toByteArray(CustomVisionSamples.class.getResourceAsStream(folder + "/" + fileName));
    } catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
    return null;
}

Entrenamiento del proyecto

Este método crea la primera iteración de entrenamiento del proyecto. Se consulta el servicio hasta que finaliza el entrenamiento.

public static void trainProject(CustomVisionTrainingClient trainClient, Project project) {
    System.out.println("Training...");
    Trainings trainer = trainClient.trainings();

    Iteration iteration = trainer.trainProject(project.id(), new TrainProjectOptionalParameter());

    while (iteration.status().equals("Training")) {
        System.out.println("Training Status: " + iteration.status());
        Thread.sleep(1000);
        iteration = trainer.getIteration(project.id(), iteration.id());
    }
    System.out.println("Training Status: " + iteration.status());
}

Publicación de la iteración actual

public static String publishIteration(CustomVisionTrainingClient trainClient, Project project) {
    Trainings trainer = trainClient.trainings();
    // The iteration is now trained. Publish it to the prediction endpoint.
    String publishedModelName = "myModel";
    trainer.publishIteration(project.id(), iteration.id(), publishedModelName, predictionResourceId);
}

Prueba del punto de conexión de la predicción

Este método carga la imagen de prueba, consulta el punto de conexión del modelo y envía los datos de la predicción a la consola.

// load test image
public static void testProject(CustomVisionPredictionClient predictor, Project project) {

    byte[] testImage = GetImage("/Test", "test_image.jpg");

    // predict
    ImagePrediction results = predictor.predictions().classifyImage().withProjectId(project.id())
            .withPublishedName(publishedModelName).withImageData(testImage).execute();

    for (Prediction prediction : results.predictions()) {
        System.out.println(String.format("\t%s: %.2f%%", prediction.tagName(), prediction.probability() * 100.0f));
    }
}

Ejecución de la aplicación

Puede compilar la aplicación con:

gradle build

Ejecute la aplicación con el comando gradle run:

gradle run

Limpieza de recursos

Si quiere limpiar y eliminar una suscripción de servicios de Azure AI, puede eliminar el recurso o el grupo de recursos. Al eliminar el grupo de recursos, también se elimina cualquier otro recurso que esté asociado a él.

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Ya ha visto que todos los pasos del proceso de clasificación de imágenes se pueden realizar mediante código. En este ejemplo se ejecuta una sola iteración de entrenamiento, pero a menudo necesitará entrenar y probar el modelo varias veces para hacerlo más preciso.

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
El código fuente correspondiente a este ejemplo se encuentra disponible en GitHub.

En esta guía se proporciona información y un ejemplo de código que pueden ayudarle a empezar a utilizar la biblioteca cliente de Custom Vision con Node.js para crear un modelo de clasificación de imágenes. Podrá crear un proyecto, agregar etiquetas, entrenar el proyecto y utilizar la dirección URL del punto de conexión de predicción del proyecto para probarlo mediante programación. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Si desea crear y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador en su lugar.

Use la biblioteca cliente de Custom Vision para .NET para hacer lo siguiente:

Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Documentación de referencia (entrenamiento)(predicción) | Código fuente de la biblioteca (entrenamiento)(predicción) | Paquete (npm) (entrenamiento)(predicción) | Ejemplos

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita
La versión actual de Node.js
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso de predicción en Azure Portal, que aparece como Id. de recurso.

Sugerencia

Precaución

Para establecer las variables de entorno, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y entorno de desarrollo.

Para establecer la variable de entorno VISION_TRAINING KEY, reemplace your-training-key por una de las claves del recurso de entrenamiento.
Para establecer la variable de entorno VISION_TRAINING_ENDPOINT, reemplace your-training-endpoint por el punto de conexión del recurso de entrenamiento.
Para establecer la variable de entorno VISION_PREDICTION_KEY, reemplace your-prediction-key por una de las claves del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_ENDPOINT, reemplace your-prediction-endpoint por el punto de conexión del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_RESOURCE_ID, reemplace your-resource-id por el id. de recurso del recurso de predicción.

Windows
Linux

setx VISION_TRAINING_KEY your-training-key

setx VISION_TRAINING_ENDPOINT your-training-endpoint

setx VISION_PREDICTION_KEY your-prediction-key

setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint

setx VISION_PREDICTION_RESOURCE_ID your-resource-id

Después de agregar las variables de entorno, puede que tenga que reiniciar todos los programas en ejecución que leerán la variable de entorno, incluida la ventana de consola.

export VISION_TRAINING_KEY=your-training-key

export VISION_TRAINING_ENDPOINT=your-training-endpoint

export VISION_PREDICTION_KEY=your-prediction-key

export VISION_PREDICTION_ENDPOINT=your-prediction-endpoint

export VISION_PREDICTION_RESOURCE_ID=your-resource-id

Después de agregar las variables de entorno ejecute source ~/.bashrc en la ventana de consola para que los cambios surtan efecto.

Instalación

Creación de una aplicación Node.js

En una ventana de la consola (como cmd, PowerShell o Bash), cree un directorio para la aplicación y vaya a él.

mkdir myapp && cd myapp

Ejecute el comando npm init para crear una aplicación de nodo con un archivo package.json.

npm init

Instalación de la biblioteca cliente

Para escribir una aplicación de análisis de imágenes con Custom Vision para Node.js, necesitará los paquetes NPM de Custom Vision. Para instalarlos ,ejecute el comando siguiente en PowerShell:

npm install @azure/cognitiveservices-customvision-training
npm install @azure/cognitiveservices-customvision-prediction

el archivo package.json de la aplicación se actualizará con las dependencias.

Cree un archivo llamado index.js e importe las bibliotecas siguientes:

const util = require('util');
const fs = require('fs');
const TrainingApi = require("@azure/cognitiveservices-customvision-training");
const PredictionApi = require("@azure/cognitiveservices-customvision-prediction");
const msRest = require("@azure/ms-rest-js");

Sugerencia

¿Desea ver todo el archivo de código de inicio rápido de una vez? Puede encontrarlo en GitHub, que contiene los ejemplos de código de este inicio rápido.

Cree variables para el punto de conexión y las claves de Azure del recurso.

// retrieve environment variables
const trainingKey = process.env["VISION_TRAINING_KEY"];
const trainingEndpoint = process.env["VISION_TRAINING_ENDPOINT"];

const predictionKey = process.env["VISION_PREDICTION_KEY"];
const predictionResourceId = process.env["VISION_PREDICTION_RESOURCE_ID"];
const predictionEndpoint = process.env["VISION_PREDICTION_ENDPOINT"];

Agregue también campos para el nombre del proyecto y un parámetro de tiempo de espera para las llamadas asincrónicas.

const publishIterationName = "classifyModel";
const setTimeoutPromise = util.promisify(setTimeout);

Modelo de objetos

Nombre	Descripción
TrainingAPIClient	Esta clase controla la creación, el entrenamiento y la publicación de los modelos.
PredictionAPIClient	Esta clase controla la consulta de las predicciones de clasificación de imágenes en los modelos.
Predicción	Esta interfaz define una sola predicción en una sola imagen. Incluye las propiedades para el identificador y el nombre de objeto, y una puntuación de confianza.

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes tareas con la biblioteca cliente de Custom Vision para JavaScript:

Autenticar el cliente
Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Autenticar el cliente

Cree una instancia de objetos de cliente con la clave y el punto de conexión. Cree un objeto ApiKeyCredentials con la clave, y úselo con el punto de conexión para crear un objeto TrainingAPIClient y un objeto PredictionAPIClient.

const credentials = new msRest.ApiKeyCredentials({ inHeader: { "Training-key": trainingKey } });
const trainer = new TrainingApi.TrainingAPIClient(credentials, trainingEndpoint);
const predictor_credentials = new msRest.ApiKeyCredentials({ inHeader: { "Prediction-key": predictionKey } });
const predictor = new PredictionApi.PredictionAPIClient(predictor_credentials, predictionEndpoint);

Creación de un proyecto de Custom Vision

Inicie una nueva función para incluir todas las llamadas a funciones de Custom Vision. Para crear un nuevo proyecto del servicio Custom Vision, agregue el siguiente código.

(async () => {
    console.log("Creating project...");
    const sampleProject = await trainer.createProject("Sample Project");

Adición de etiquetas al proyecto

Para crear etiquetas de clasificación para el proyecto, agregue el código siguiente a la función:

const hemlockTag = await trainer.createTag(sampleProject.id, "Hemlock");
const cherryTag = await trainer.createTag(sampleProject.id, "Japanese Cherry");

Carga y etiquetado de imágenes

En primer lugar, descargue las imágenes de ejemplo de este proyecto. Guarde el contenido de la carpeta de imágenes de ejemplo en el dispositivo local.

Para agregar las imágenes de ejemplo al proyecto, inserte el siguiente código después de crear la etiqueta. Este código carga cada imagen con su etiqueta correspondiente.

const sampleDataRoot = "Images";

console.log("Adding images...");
let fileUploadPromises = [];

const hemlockDir = `${sampleDataRoot}/Hemlock`;
const hemlockFiles = fs.readdirSync(hemlockDir);
hemlockFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${hemlockDir}/${file}`), { tagIds: [hemlockTag.id] }));
});

const cherryDir = `${sampleDataRoot}/Japanese_Cherry`;
const japaneseCherryFiles = fs.readdirSync(cherryDir);
japaneseCherryFiles.forEach(file => {
    fileUploadPromises.push(trainer.createImagesFromData(sampleProject.id, fs.readFileSync(`${cherryDir}/${file}`), { tagIds: [cherryTag.id] }));
});

await Promise.all(fileUploadPromises);

Importante

Tendrá que cambiar la ruta de acceso a las imágenes (sampleDataRoot) en función del lugar en el que descargó anteriormente el repositorio de muestras del SDK de Python de servicios de Azure AI.

Entrenamiento del proyecto

Este código crea la primera iteración del modelo de predicción.

console.log("Training...");
let trainingIteration = await trainer.trainProject(sampleProject.id);

// Wait for training to complete
console.log("Training started...");
while (trainingIteration.status == "Training") {
    console.log("Training status: " + trainingIteration.status);
    await setTimeoutPromise(1000, null);
    trainingIteration = await trainer.getIteration(sampleProject.id, trainingIteration.id)
}
console.log("Training status: " + trainingIteration.status);

Publicación de la iteración actual

Este código publica la iteración entrenada en el punto de conexión de predicción. El nombre que se da a la iteración publicada se puede utilizar para enviar solicitudes de predicción. Una iteración no está disponible en el punto de conexión de la predicción hasta que se publica.

// Publish the iteration to the end point
await trainer.publishIteration(sampleProject.id, trainingIteration.id, publishIterationName, predictionResourceId);

Prueba del punto de conexión de la predicción

Para enviar una imagen al punto de conexión de la predicción y recuperar la predicción, agregue el código siguiente a la función.

const testFile = fs.readFileSync(`${sampleDataRoot}/Test/test_image.jpg`);

const results = await predictor.classifyImage(sampleProject.id, publishIterationName, testFile);

// Show results
console.log("Results:");
results.predictions.forEach(predictedResult => {
    console.log(`\t ${predictedResult.tagName}: ${(predictedResult.probability * 100.0).toFixed(2)}%`);
});

A continuación, cierre la función de Custom Vision y llámela.

})()

Ejecución de la aplicación

Ejecute la aplicación con el comando node en el archivo de inicio rápido.

node index.js

La salida de la aplicación debe ser similar al texto siguiente:

Creating project...
Adding images...
Training...
Training started...
Training status: Training
Training status: Training
Training status: Training
Training status: Completed
Results:
         Hemlock: 94.97%
         Japanese Cherry: 0.01%

A continuación, compruebe que la imagen de prueba (que se encuentra en <sampleDataRoot>/Test/) se haya etiquetado correctamente. También puede volver al sitio web de Custom Vision y ver el estado actual del proyecto recién creado.

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
El código fuente correspondiente a este ejemplo se encuentra disponible en GitHub.
Documentación de referencia del SDK (entrenamiento)
Documentación de referencia del SDK (predicción)

Introducción a la biblioteca cliente de Custom Vision para Python. Siga estos pasos para instalar el paquete y probar el código de ejemplo a fin de crear un modelo de clasificación de imágenes. Podrá crear un proyecto, agregar etiquetas, entrenar el proyecto y utilizar la dirección URL del punto de conexión de predicción del proyecto para probarlo mediante programación. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Si desea crear y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador en su lugar.

Use la biblioteca cliente de Custom Vision para Python con los fines siguientes:

Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Documentación de referencia | Código fuente de la biblioteca | Paquete (PyPI) | Ejemplos

Prerrequisitos

Una suscripción a Azure: cree una cuenta gratuita
Python 3.x
- La instalación de Python debe incluir pip. Puede comprobar si tiene pip instalado mediante la ejecución de pip --version en la línea de comandos. Para obtener pip, instale la versión más reciente de Python.
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.

Creación de variables de entorno

En este ejemplo, escribirá las credenciales en variables de entorno del equipo local que ejecuta la aplicación.

Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso de predicción en Azure Portal, que aparece como Id. de recurso.

Sugerencia

Precaución

Para establecer las variables de entorno, abra una ventana de consola y siga las instrucciones correspondientes a su sistema operativo y entorno de desarrollo.

Para establecer la variable de entorno VISION_TRAINING KEY, reemplace your-training-key por una de las claves del recurso de entrenamiento.
Para establecer la variable de entorno VISION_TRAINING_ENDPOINT, reemplace your-training-endpoint por el punto de conexión del recurso de entrenamiento.
Para establecer la variable de entorno VISION_PREDICTION_KEY, reemplace your-prediction-key por una de las claves del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_ENDPOINT, reemplace your-prediction-endpoint por el punto de conexión del recurso de predicción.
Para establecer la variable de entorno VISION_PREDICTION_RESOURCE_ID, reemplace your-resource-id por el id. de recurso del recurso de predicción.

Windows
Linux

setx VISION_TRAINING_KEY your-training-key

setx VISION_TRAINING_ENDPOINT your-training-endpoint

setx VISION_PREDICTION_KEY your-prediction-key

setx VISION_PREDICTION_ENDPOINT your-prediction-endpoint

setx VISION_PREDICTION_RESOURCE_ID your-resource-id

Después de agregar las variables de entorno, puede que tenga que reiniciar todos los programas en ejecución que leerán la variable de entorno, incluida la ventana de consola.

export VISION_TRAINING_KEY=your-training-key

export VISION_TRAINING_ENDPOINT=your-training-endpoint

export VISION_PREDICTION_KEY=your-prediction-key

export VISION_PREDICTION_ENDPOINT=your-prediction-endpoint

export VISION_PREDICTION_RESOURCE_ID=your-resource-id

Después de agregar las variables de entorno ejecute source ~/.bashrc en la ventana de consola para que los cambios surtan efecto.

Instalación

Instalación de la biblioteca cliente

Para escribir una aplicación de análisis de imágenes con Custom Vision para Python, necesitará la biblioteca cliente de Custom Vision. Después de instalar Python, ejecute el siguiente comando en PowerShell o en una ventana de consola:

pip install azure-cognitiveservices-vision-customvision

Creación de una nueva aplicación de Python

Cree un archivo de Python e importe las bibliotecas siguientes.

from azure.cognitiveservices.vision.customvision.training import CustomVisionTrainingClient
from azure.cognitiveservices.vision.customvision.prediction import CustomVisionPredictionClient
from azure.cognitiveservices.vision.customvision.training.models import ImageFileCreateBatch, ImageFileCreateEntry, Region
from msrest.authentication import ApiKeyCredentials
import os, time, uuid

Sugerencia

¿Desea ver todo el archivo de código de inicio rápido de una vez? Puede encontrarlo en GitHub, que contiene los ejemplos de código de este inicio rápido.

Cree variables para el punto de conexión y las claves de Azure del recurso.

# retrieve environment variables
ENDPOINT = os.environ["VISION_TRAINING_ENDPOINT"]
training_key = os.environ["VISION_TRAINING_KEY"]
prediction_key = os.environ["VISION_PREDICTION_KEY"]
prediction_resource_id = os.environ["VISION_PREDICTION_RESOURCE_ID"]

Modelo de objetos

Nombre	Descripción
CustomVisionTrainingClient	Esta clase controla la creación, el entrenamiento y la publicación de los modelos.
CustomVisionPredictionClient	Esta clase controla la consulta de las predicciones de clasificación de imágenes en los modelos.
ImagePrediction	Esta clase define una sola predicción de objetos en una sola imagen. Se incluyen las propiedades del identificador y el nombre del objeto, la ubicación del rectángulo delimitador del objeto y una puntuación de confianza.

Ejemplos de código

Estos fragmentos de código muestran cómo realizar las siguientes tareas con la biblioteca cliente de Custom Vision para Python:

Autenticar el cliente
Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Autenticar el cliente

Cree instancias de clientes de entrenamiento y predicción mediante su punto de conexión y claves. Cree objetos ApiKeyServiceClientCredentials con sus claves y úselos con el punto de conexión para crear un objeto CustomVisionTrainingClient y un objeto CustomVisionPredictionClient.

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)

Creación de un proyecto de Custom Vision

Para crear un proyecto de Custom Vision Service, agregue el siguiente código al script.

Consulte el método create_project para especificar otras opciones al crear el proyecto (explicadas en la guía del portal web Compilación de un clasificador).

publish_iteration_name = "classifyModel"

credentials = ApiKeyCredentials(in_headers={"Training-key": training_key})
trainer = CustomVisionTrainingClient(ENDPOINT, credentials)

# Create a new project
print ("Creating project...")
project_name = uuid.uuid4()
project = trainer.create_project(project_name)

Adición de etiquetas al proyecto

Para agregar etiquetas de clasificación al proyecto, utilice el código siguiente:

# Make two tags in the new project
hemlock_tag = trainer.create_tag(project.id, "Hemlock")
cherry_tag = trainer.create_tag(project.id, "Japanese Cherry")

Carga y etiquetado de imágenes

En primer lugar, descargue las imágenes de ejemplo de este proyecto. Guarde el contenido de la carpeta de imágenes de ejemplo en el dispositivo local.

base_image_location = os.path.join (os.path.dirname(__file__), "Images")

print("Adding images...")

image_list = []

for image_num in range(1, 11):
    file_name = "hemlock_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Hemlock", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[hemlock_tag.id]))

for image_num in range(1, 11):
    file_name = "japanese_cherry_{}.jpg".format(image_num)
    with open(os.path.join (base_image_location, "Japanese_Cherry", file_name), "rb") as image_contents:
        image_list.append(ImageFileCreateEntry(name=file_name, contents=image_contents.read(), tag_ids=[cherry_tag.id]))

upload_result = trainer.create_images_from_files(project.id, ImageFileCreateBatch(images=image_list))
if not upload_result.is_batch_successful:
    print("Image batch upload failed.")
    for image in upload_result.images:
        print("Image status: ", image.status)
    exit(-1)

Nota

Tendrá que cambiar la ruta de acceso a las imágenes en función del lugar en el que descargó anteriormente el repositorio de muestras del SDK de servicios de Azure AI de Python.

Entrenamiento del proyecto

Este código crea la primera iteración del modelo de predicción.

print ("Training...")
iteration = trainer.train_project(project.id)
while (iteration.status != "Completed"):
    iteration = trainer.get_iteration(project.id, iteration.id)
    print ("Training status: " + iteration.status)
    print ("Waiting 10 seconds...")
    time.sleep(10)

Sugerencia

Entrenamiento con etiquetas seleccionadas

Opcionalmente, puede entrenar solo en un subconjunto de las etiquetas aplicadas. Es posible que desee hacer esto si aún no ha aplicado suficientes etiquetas de un tipo determinado, pero tiene bastantes de las otras. En la llamada a train_project , establezca el parámetro opcional selected_tags en una lista de las cadenas de identificadores de las etiquetas que desea usar. El modelo se entrenará para reconocer solo las etiquetas de esa lista.

Publicación de la iteración actual

Una iteración no está disponible en el punto de conexión de la predicción hasta que se publica. El siguiente código hace que la iteración actual del modelo esté disponible para realizar consultas.

# The iteration is now trained. Publish it to the project endpoint
trainer.publish_iteration(project.id, iteration.id, publish_iteration_name, prediction_resource_id)
print ("Done!")

Prueba del punto de conexión de la predicción

Para enviar una imagen al punto de conexión de la predicción y recuperar la predicción, agregue el código siguiente al final del archivo:

# Now there is a trained endpoint that can be used to make a prediction
prediction_credentials = ApiKeyCredentials(in_headers={"Prediction-key": prediction_key})
predictor = CustomVisionPredictionClient(ENDPOINT, prediction_credentials)

with open(os.path.join (base_image_location, "Test/test_image.jpg"), "rb") as image_contents:
    results = predictor.classify_image(
        project.id, publish_iteration_name, image_contents.read())

    # Display the results.
    for prediction in results.predictions:
        print("\t" + prediction.tag_name +
              ": {0:.2f}%".format(prediction.probability * 100))

Ejecución de la aplicación

Ejecute CustomVisionQuickstart.py.

python CustomVisionQuickstart.py

La salida de la aplicación debe ser similar al texto siguiente:

Creating project...
Adding images...
Training...
Training status: Training
Training status: Completed
Done!
        Hemlock: 93.53%
        Japanese Cherry: 0.01%

A continuación, compruebe que la imagen de prueba (que se encuentra en <ubicación_de_la_imagen_base>) se haya etiquetado correctamente. También puede volver al sitio web de Custom Vision y ver el estado actual del proyecto recién creado.

Limpieza de recursos

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
El código fuente correspondiente a este ejemplo se encuentra disponible en GitHub.
Documentación de referencia del SDK

Introducción a la API REST de Custom Vision Siga estos pasos para llamar a la API y crear un modelo de clasificación de imágenes. Podrá crear un proyecto, agregar etiquetas, entrenar el proyecto y utilizar la dirección URL del punto de conexión de predicción del proyecto para probarlo mediante programación. Utilice este ejemplo como plantilla para crear su propia aplicación de reconocimiento de imágenes.

Nota

Custom Vision se usa con más facilidad mediante un SDK de biblioteca cliente o mediante instrucciones basadas en el explorador.

Use la biblioteca cliente de Custom Vision para .NET para hacer lo siguiente:

Creación de un proyecto de Custom Vision
Adición de etiquetas al proyecto
Carga y etiquetado de imágenes
Entrenamiento del proyecto
Publicación de la iteración actual
Prueba del punto de conexión de la predicción

Requisitos previos

Una suscripción a Azure: cree una cuenta gratuita
Una vez que tenga la suscripción de Azure, cree un recurso de Custom Vision en Azure Portal para crear un recurso de entrenamiento y predicción y obtener las claves y el punto de conexión. Espere a que se implemente y haga clic en el botón Ir al recurso.
- Necesitará la clave y el punto de conexión de los recursos que cree para conectar la aplicación a Custom Vision. En una sección posterior de este mismo inicio rápido pegará la clave y el punto de conexión en el código siguiente.
- Puede usar el plan de tarifa gratis (F0) para probar el servicio y actualizarlo más adelante a un plan de pago para producción.
PowerShell versión 6.0, o superior, o una aplicación de la línea de comandos similar.

Creación de un proyecto de Custom Vision

Usará un comando similar al siguiente para crear un proyecto de clasificación de imágenes. El proyecto creado se mostrará en el sitio web de Custom Vision.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects?name={name}"

Copie el comando en un editor de texto y realice los cambios siguientes:

Reemplace {subscription key} por una clave de Face válida.
Reemplace {endpoint} por el punto de conexión correspondiente a la clave.

Nota

Los nuevos recursos creados después del 1 de julio de 2019 usarán nombres de subdominio personalizados. Para obtener más información y una lista completa de puntos finales regionales, consulte Nombres de subdominios personalizados para los servicios de Azure AI.
Reemplace {name} por el nombre del proyecto.
Opcionalmente, puede establecer otros parámetros de dirección URL para configurar qué tipo de modelo usará el proyecto. Consulte la API CreatProject para ver las opciones.

Recibirá una respuesta JSON como la siguiente. Guarde el valor del elemento "id" del proyecto en una ubicación temporal.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "settings": {
    "domainId": "00000000-0000-0000-0000-000000000000",
    "classificationType": "Multiclass",
    "targetExportPlatforms": [
      "CoreML"
    ],
    "useNegativeSet": true,
    "detectionParameters": "string",
    "imageProcessingSettings": {
      "augmentationMethods": {}
    }
  },
  "created": "string",
  "lastModified": "string",
  "thumbnailUri": "string",
  "drModeEnabled": true,
  "status": "Succeeded"
}

Adición de etiquetas al proyecto

Use el comando siguiente para definir las etiquetas con las que va a entrenar el modelo.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/tags?name={name}"

Inserte de nuevo su propia clave y la dirección URL del punto de conexión.
Reemplace {projectId} por su propio identificador de proyecto.
Reemplace {name} por el nombre de la etiqueta que desea usar.

Repita este proceso para todas las etiquetas que quiera usar en el proyecto. Si usa las imágenes de ejemplo proporcionadas, agregue las etiquetas "Hemlock" y "Japanese Cherry".

Recibirá una respuesta JSON como la siguiente. Guarde el valor del elemento "id" de cada etiqueta en una ubicación temporal.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "description": "string",
  "type": "Regular",
  "imageCount": 0
}

Carga y etiquetado de imágenes

A continuación, descargue las imágenes de ejemplo de este proyecto. Guarde el contenido de la carpeta de imágenes de ejemplo en el dispositivo local.

Use el siguiente comando para cargar las imágenes y aplicar las etiquetas; una vez para las imágenes correspondientes a "Hemlock" y por separado para las imágenes correspondientes a "Japanese Cherry". Para más opciones, consulte la API CreateImagesFromData.

curl -v -X POST -H "Content-Type: multipart/form-data" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/images?tagIds={tagArray}"
--data-ascii "{binary data}"

Inserte de nuevo su propia clave y la dirección URL del punto de conexión.
Reemplace {projectId} por su propio identificador de proyecto.
Reemplace {tagArray} por el identificador de una etiqueta.
A continuación, rellene el cuerpo de la solicitud con los datos binarios de las imágenes que desea etiquetar.

Entrenamiento del proyecto

Este método entrena el modelo con las imágenes etiquetadas que ha cargado y devuelve un identificador para la iteración actual del proyecto.

curl -v -X POST -H "Content-Type: application/json" -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/train"

Inserte de nuevo su propia clave y la dirección URL del punto de conexión.
Reemplace {projectId} por su propio identificador de proyecto.
Reemplace {tagArray} por el identificador de una etiqueta.
A continuación, rellene el cuerpo de la solicitud con los datos binarios de las imágenes que desea etiquetar.
Opcionalmente, puede usar otros parámetros de dirección URL. Consulte la API TrainProject para ver las opciones.

Sugerencia

Entrenamiento con etiquetas seleccionadas

Opcionalmente, puede entrenar solo en un subconjunto de las etiquetas aplicadas. Es posible que desee hacer esto si aún no ha aplicado suficientes etiquetas de un tipo determinado, pero tiene bastantes de las otras. Agregue el contenido JSON opcional al cuerpo de la solicitud. Rellene la matriz "selectedTags" con los identificadores de las etiquetas que desea usar.

{
  "selectedTags": [
    "00000000-0000-0000-0000-000000000000"
  ]
}

La respuesta JSON contiene información sobre el proyecto entrenado, incluido el identificador de iteración ("id"). Guarde este valor para el siguiente paso.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "name": "string",
  "status": "string",
  "created": "string",
  "lastModified": "string",
  "trainedAt": "string",
  "projectId": "00000000-0000-0000-0000-000000000000",
  "exportable": true,
  "exportableTo": [
    "CoreML"
  ],
  "domainId": "00000000-0000-0000-0000-000000000000",
  "classificationType": "Multiclass",
  "trainingType": "Regular",
  "reservedBudgetInHours": 0,
  "trainingTimeInMinutes": 0,
  "publishName": "string",
  "originalPublishResourceId": "string"
}

Publicación de la iteración actual

Este método hace que la iteración actual del modelo esté disponible para realizar consultas. Use el nombre del modelo devuelto como referencia para enviar solicitudes de predicción.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

Inserte de nuevo su propia clave y la dirección URL del punto de conexión.
Reemplace {projectId} por su propio identificador de proyecto.
Reemplace {iterationId} por el identificador devuelto en el paso anterior.
Reemplace {publishedName} por el nombre que le gustaría asignar al modelo de predicción.
Reemplace {predictionId} por su propio identificador de recurso de predicción. Encontrará el identificador del recurso de predicción en la pestaña de Propiedades del recurso en Azure Portal, que aparece como Id. de recurso.
Opcionalmente, puede usar otros parámetros de dirección URL. Consulte la API PublishIteration.

Prueba del punto de conexión de la predicción

Por último, use este comando para probar el modelo entrenado mediante la carga de una nueva imagen para que la clasifique con etiquetas. Puede usar la imagen de la carpeta "Test" de los archivos de ejemplo que descargó anteriormente.

curl -v -X POST -H "Training-key: {subscription key}" "https://{endpoint}/customvision/v3.3/Training/projects/{projectId}/iterations/{iterationId}/publish?publishName={publishName}&predictionId={predictionId}"

Inserte de nuevo su propia clave y la dirección URL del punto de conexión.
Reemplace {projectId} por su propio identificador de proyecto.
Reemplace {publishedName} por el valor que usó en el paso anterior.
Agregue los datos binarios de la imagen local al cuerpo de la solicitud.
Opcionalmente, puede usar otros parámetros de dirección URL. Consulte la API ClassifyImage.

La respuesta JSON devuelta enumera cada una de las etiquetas que el modelo ha aplicado a la imagen, junto con las puntuaciones de probabilidad de cada etiqueta.

{
  "id": "00000000-0000-0000-0000-000000000000",
  "project": "00000000-0000-0000-0000-000000000000",
  "iteration": "00000000-0000-0000-0000-000000000000",
  "created": "string",
  "predictions": [
    {
      "probability": 0.0,
      "tagId": "00000000-0000-0000-0000-000000000000",
      "tagName": "string",
      "boundingBox": {
        "left": 0.0,
        "top": 0.0,
        "width": 0.0,
        "height": 0.0
      },
      "tagType": "Regular"
    }
  ]
}

En el sitio web de Custom Vision, vaya a Proyectos y seleccione la papelera en My New Project.

Screenshot of a panel labeled My New Project with a trash can icon.

Pasos siguientes

Ahora ha realizado todos los pasos del proceso de clasificación de imágenes con la API REST. En este ejemplo se ejecuta una sola iteración de entrenamiento, pero a menudo necesitará entrenar y probar el modelo varias veces para hacerlo más preciso.

Prueba y reentrenamiento del modelo

¿Qué es Custom Vision?
Documentación de referencia de la API (entrenamiento)
Documentación de referencia de la API (predicción)