Compartir vía

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

  • Artículo

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. Puede crear un proyecto, agregar etiquetas, entrenar el proyecto y usar 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 compilar y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador.

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

Requisitos previos

  • Suscripción a Azure. Puede crear una de forma 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 un recurso de 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 han 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. Deberá obtener las claves para el recurso de entrenamiento y el recurso de predicción, junto con los puntos de conexión de 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.

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.

Importante

Si usa una clave de API, almacénela de forma segura en otro lugar, como en Azure Key Vault. No incluya la clave de API directamente en el código ni la exponga nunca públicamente.

Para más información acerca de la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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, es posible que tenga que reiniciar los programas en ejecución que lean las variables de entorno, incluida la ventana de la consola.

Instalación

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 nuevo proyecto, instale la biblioteca cliente haciendo clic con el botón derecho en la solución del proyecto en la Explorador de soluciones y seleccionando Administrar paquetes NuGet. Seleccione Examinar en el administrador de paquetes que se abre y, a continuación, active 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 elija Instalar.

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. Estos se implementan 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 muestra 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 entrena 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. Es posible 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")));
}

A continuación, defina un método para cargar las imágenes, aplicando 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 TrainProject, use el parámetro trainingParameters Construya un 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

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

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

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

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 compilar y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador.

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 de (entrenamiento) y (predicción)

Requisitos previos

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 han 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. Deberá obtener las claves para el recurso de entrenamiento y el recurso de predicción, junto con los puntos de conexión de 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.

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.

Importante

Si usa una clave de API, almacénela de forma segura en otro lugar, como en Azure Key Vault. No incluya la clave de API directamente en el código ni la exponga nunca públicamente.

Para más información acerca de la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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, es posible que tenga que reiniciar los programas en ejecución que lean las variables de entorno, incluida la ventana de la consola.

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, necesita 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 la ejecución del repositorio:

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 predicción hasta que se publique.

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 la aplicación con el siguiente comando:

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

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

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

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 compilar y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador.

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 para (entrenamiento) y (predicción)| Artefacto (Maven) para (entrenamiento) y (predicción) | Ejemplos

Requisitos previos

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 han 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. Deberá obtener las claves para el recurso de entrenamiento y el recurso de predicción, junto con los puntos de conexión de 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.

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.

Importante

Si usa una clave de API, almacénela de forma segura en otro lugar, como en Azure Key Vault. No incluya la clave de API directamente en el código ni la exponga nunca públicamente.

Para más información acerca de la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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, es posible que tenga que reiniciar los programas en ejecución que lean las variables de entorno, incluida la ventana de la consola.

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 el entorno 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

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 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

En el método main, cree una instancia de los clientes de entrenamiento y predicción mediante el punto de conexión y las 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

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.

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.

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

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?
  • 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. Puede crear un proyecto, agregar etiquetas, entrenar el proyecto y usar 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 compilar y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador.

Use la biblioteca cliente de Custom Vision para Node.js 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 para (entrenamiento) y (predicción) | Paquete (npm) para (entrenamiento) y (predicción) | Ejemplos

Requisitos previos

  • Suscripción a Azure. Puede crear una de forma 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.

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 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. Deberá obtener las claves para el recurso de entrenamiento y el recurso de predicción, junto con los puntos de conexión de 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.

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.

Importante

Si usa una clave de API, almacénela de forma segura en otro lugar, como en Azure Key Vault. No incluya la clave de API directamente en el código ni la exponga nunca públicamente.

Para más información acerca de la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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, es posible que tenga que reiniciar los programas en ejecución que lean las variables de entorno, incluida la ventana de la consola.

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. Presione ENTRAR varias veces para completar el proceso.

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, necesita 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 actualiza 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

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

Debe cambiar la ruta de acceso a las imágenes (sampleDataRoot) en función de dónde descargó el repositorio de ejemplos del SDK de Python de los 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 predicción hasta que se publique.

// 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.

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

En esta guía se muestra cómo se pueden realizar todos los pasos del proceso de detección de objetos 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

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 compilar y entrenar un modelo de clasificación sin escribir código, consulte la guía basada en explorador.

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

Requisitos previos

  • Suscripción a Azure. Puede crear una de forma 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.

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 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. Deberá obtener las claves para el recurso de entrenamiento y el recurso de predicción, junto con los puntos de conexión de 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.

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.

Importante

Si usa una clave de API, almacénela de forma segura en otro lugar, como en Azure Key Vault. No incluya la clave de API directamente en el código ni la exponga nunca públicamente.

Para más información acerca de la seguridad de los servicios de AI, consulte Autenticación de solicitudes a los servicios de Azure AI.

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, es posible que tenga que reiniciar los programas en ejecución que lean las variables de entorno, incluida la ventana de la consola.

Instalación

Instalación de la biblioteca cliente

Para escribir una aplicación de análisis de imágenes con Custom Vision para Python, necesita 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

Cree instancias de clientes de entrenamiento y predicción mediante su punto de conexión y claves. Cree ApiKeyServiceClientCredentials objetos con las claves y úselos con el punto de conexión para crear un CustomVisionTrainingClient y 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.

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.

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:

Debe cambiar la ruta de acceso a las imágenes en función de dónde descargó el repositorio de ejemplos del SDK de Python de los servicios de Azure AI.

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 train_project, establezca el parámetro opcional selected_tags en una lista de las cadenas de identificador 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 predicción hasta que se publique. 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 la aplicación con el siguiente comando:

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

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

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

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 la API de REST 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

Requisitos previos

  • Suscripción a Azure. Puede crear una de forma 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.
    • Necesita 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.
    • 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 la clave 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, establezca otros parámetros de dirección URL para configurar qué tipo de modelo usa el proyecto. Consulte la Creación de API del proyecto para ver las opciones.

Aparece una respuesta JSON como en el ejemplo 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 siguiente comando para definir las etiquetas en las que 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".

Aparece una respuesta JSON como en el ejemplo 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 en las imágenes etiquetadas que cargó y devuelve un identificador para la iteración del proyecto actual.

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 en la carpeta Prueba 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 aplicó 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"
    }
  ]
}

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.

Captura de pantalla de un panel denominado Mi nuevo proyecto con el icono de papelera.

Contenido relacionado

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