How to improve object judgment accuracy in ASP.NET Core with CustomVision

Question

I'm using the CustomVision in an ASP.NET Core project to judge the objects.

I trained the model with 20 dog and cat images, but the judgement result is useless.

If I present an image, this model only replies as nearly 50%:50% ratio of cat to dog.

Even I present other than dog and cat, the response is the same.

The code is as following:

using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.Models;
using TrainCred = Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials;
using PredCred = Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials;
namespace CustomVisionTrainSample
{
 class Program
 {
 // 共通設定
 private const string trainingEndpoint = "https://********.cognitiveservices.azure.com/";
 private const string trainingKey = "****************************************************************************";
 private const string predictionEndpoint = "https://**********-prediction.cognitiveservices.azure.com/";
 private const string predictionKey = "********************************************************************************";
 private static readonly Guid projectId = Guid.Parse("b933984e-1c7f-4ef6-8a25-5726b3c846f7");
 private const string publishName = "testmodel";
 private const string imagesFolder = @"C:\Images\CatsAndDogs\";
 private const string testImageFile = @"C:\Images\test_dog.jpg";
 static async Task Main(string[] args)
 {
 var trainer = new CustomVisionTrainingClient(
 new TrainCred(trainingKey))
 {
 Endpoint = trainingEndpoint
 };
 var projects = trainer.GetProjects();
 foreach (var proj in projects)
 {
 Console.WriteLine($"Name: {proj.Name}, ID: {proj.Id}");
 }
 if (args.Length == 0 || (!args.Contains("--training") && !args.Contains("--prediction")))
 {
 Console.WriteLine("Usage: CustomVisionApp --training | --prediction");
 return;
 }
 if (args.Contains("--training"))
 {
 await RunTrainingAsync();
 }
 else if (args.Contains("--prediction"))
 {
 await RunPredictionAsync();
 }
 }
 private static async Task RunTrainingAsync()
 {
 var trainer = new CustomVisionTrainingClient(new TrainCred(trainingKey))
 {
 Endpoint = trainingEndpoint
 };
 Console.WriteLine("Creating or getting project...");
 
 var project = trainer.CreateProject("CatsVsDogsProject");
 var catTag = trainer.CreateTag(project.Id, "Cat");
 var dogTag = trainer.CreateTag(project.Id, "Dog");
 Console.WriteLine("Uploading images...");
 foreach (var file in Directory.GetFiles(Path.Combine(imagesFolder, "Cat")))
 {
 using var stream = File.OpenRead(file);
 trainer.CreateImagesFromData(project.Id, stream, new[] { catTag.Id });
 }
 foreach (var file in Directory.GetFiles(Path.Combine(imagesFolder, "Dog")))
 {
 using var stream = File.OpenRead(file);
 trainer.CreateImagesFromData(project.Id, stream, new[] { dogTag.Id });
 }
 Console.WriteLine("Training started...");
 var iteration = trainer.TrainProject(project.Id);
 while (iteration.Status == "Training")
 {
 Console.WriteLine($" Status: {iteration.Status}");
 await Task.Delay(1000);
 iteration = trainer.GetIteration(project.Id, iteration.Id);
 }
 Console.WriteLine("Publishing iteration...");
 string predictionResourceId =
 "/subscriptions/*****************************************/resourceGroups/******************/providers/Microsoft.CognitiveServices/accounts/********-Prediction";
 trainer.PublishIteration(project.Id, iteration.Id, publishName, predictionResourceId);
 Console.WriteLine("Training and publish completed.");
 }
 private static async Task RunPredictionAsync()
 {
 var predictor = new CustomVisionPredictionClient(new PredCred(predictionKey))
 {
 Endpoint = predictionEndpoint
 };
 Console.WriteLine("Reading test image...");
 using var imageStream = File.OpenRead(testImageFile);
 Console.WriteLine("Running prediction...");
 var result = await predictor.ClassifyImageAsync(
 projectId,
 publishName,
 imageStream
 );
 Console.WriteLine("Predictions:");
 foreach (var p in result.Predictions)
 {
 Console.WriteLine($" {p.TagName}: {p.Probability:P1}");
 }
 }
 }
}

Please tell me how to improve the accuracy of this model if someone have the experience or knowledge for the customVision.

And please check the above code whether there's something missing.

Thanks in advance.

• Dasari Kamali: Try adding a lot more images per tag (at least 50+) and include a None or Other tag with images that aren't cats or dogs, that should help improve the model's accuracy.

Answer 1

The model was trained on just 20 images which is too few for reliable classification. To improve accuracy, use at least 50–100 clear, well-labeled images per class with varied lighting, angles and backgrounds.

This code worked fine for me and gave more accurate predictions for both cats and dogs.

using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training;
using Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction;
using TrainCred = Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials;
using PredCred = Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials;
namespace CustomVisionTrainSample
{
 class Program
 {
 private const string trainingEndpoint = "<TrainingEndpoint>";
 private const string trainingKey = "<TrainingKey>";
 private const string predictionEndpoint = "<PredictionEndpoint>";
 private const string predictionKey = "<PredictionKey>";
 private const string predictionResourceId = "<PredictionResourceId>";
 private const string publishName = "CatsDogsModel";
 private const string imagesFolder = @"Images";
 private const string testImageFile = @"Images\Test\test_dog.jpg";
 static async Task Main(string[] args)
 {
 if (args.Length == 0)
 {
 Console.WriteLine("No arguments provided. Running training followed by prediction");
 await RunTrainingAndPredictionAsync();
 return;
 }
 if (args.Contains("--training"))
 await RunTrainingAsync();
 else if (args.Contains("--prediction"))
 await RunPredictionAsync(Guid.Empty); 
 }
 private static async Task RunTrainingAndPredictionAsync()
 {
 var (projectId, iterationId) = await RunTrainingAsync();
 Console.WriteLine("Running prediction now");
 await RunPredictionAsync(projectId);
 }
 private static async Task<(Guid, Guid)> RunTrainingAsync()
 {
 var trainer = new CustomVisionTrainingClient(new TrainCred(trainingKey)) { Endpoint = trainingEndpoint };
 Console.WriteLine("Creating new project");
 var domains = trainer.GetDomains();
 var classificationDomain = domains.FirstOrDefault(d => d.Type == "Classification");
 var project = trainer.CreateProject("CatsVsDogsProject", null, classificationDomain?.Id);
 var projectId = project.Id;
 var catTag = trainer.CreateTag(projectId, "Cat");
 var dogTag = trainer.CreateTag(projectId, "Dog");
 Console.WriteLine("Uploading Cat images");
 UploadImages(trainer, projectId, catTag.Id, Path.Combine(imagesFolder, "Cat"));
 Console.WriteLine("Uploading Dog images");
 UploadImages(trainer, projectId, dogTag.Id, Path.Combine(imagesFolder, "Dog"));
 Console.WriteLine("Training started");
 var iteration = trainer.TrainProject(projectId);
 while (iteration.Status == "Training")
 {
 Thread.Sleep(2000);
 iteration = trainer.GetIteration(projectId, iteration.Id);
 }
 Console.WriteLine("Publishing iteration");
 trainer.PublishIteration(projectId, iteration.Id, publishName, predictionResourceId);
 Console.WriteLine("Training complete and published.");
 return (projectId, iteration.Id);
 }
 private static void UploadImages(CustomVisionTrainingClient trainer, Guid projectId, Guid tagId, string folderPath)
 {
 var imageFiles = Directory.GetFiles(folderPath);
 foreach (var file in imageFiles)
 {
 using var stream = File.OpenRead(file);
 var result = trainer.CreateImagesFromData(projectId, stream, new[] { tagId });
 if (!result.IsBatchSuccessful)
 {
 Console.WriteLine($"Failed to upload {file}");
 foreach (var detail in result.Images)
 {
 Console.WriteLine($" - {detail.Status}: {detail.SourceUrl}");
 }
 }
 }
 }
 private static async Task RunPredictionAsync(Guid projectId)
 {
 if (projectId == Guid.Empty)
 {
 Console.WriteLine("Error: projectId is empty. You must pass a valid ID.");
 return;
 }
 var predictor = new CustomVisionPredictionClient(new PredCred(predictionKey))
 {
 Endpoint = predictionEndpoint
 };
 Console.WriteLine($"Using project ID: {projectId}");
 using var testImage = File.OpenRead(testImageFile);
 Console.WriteLine("Predicting");
 var result = await predictor.ClassifyImageAsync(
 projectId,
 publishName,
 testImage
 );
 Console.WriteLine("Predictions:");
 foreach (var p in result.Predictions.OrderByDescending(p => p.Probability))
 {
 Console.WriteLine($" {p.TagName}: {p.Probability:P2}");
 }
 if (result.Predictions.All(p => p.Probability < 0.6))
 {
 Console.WriteLine("Warning: Low confidence. Model may not be well-trained or test image is too different.");
 }
 }
 }
}

Output :

The model ran successfully and generated more accurate predictions for the dog class as shown below.

enter image description here