/// <summary>
/// Adds the provided images to the current project iteration
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='projectId'>
/// The project id.
/// </param>
/// <param name='imageData'>
/// </param>
/// <param name='tagIds'>
/// The tags ids to associate with the image batch.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <CreateImageSummaryModel> CreateImagesFromDataAsync(this ITrainingApi operations, System.Guid projectId, IEnumerable <Stream> imageData, IList <Guid> tagIds = default(IList <Guid>), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateImagesFromDataWithHttpMessagesAsync(projectId, imageData, tagIds, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Read and upload images to <paramref name="project"/> based on <paramref name="options"/>
/// </summary>
public static async Task <CreateImageSummaryModel> ReadAndUploadImagesAsync(this ITrainingApi trainingApi,
Project project, TrainingOptions options, ICollection <string> allowedTagNames)
{
var images = ImagesLoaderGenerator.GenerateImagesLoader(options, allowedTagNames).LoadImages();
return(await ImagesUploaderGenerator.GenerateImagesUploader(options, trainingApi).UploadImagesAsync(images, project.Id));
}
/// <summary>
/// Create tags for <paramref name="projectId"/> with <paramref name="tagNames"/>
/// </summary>
public static async Task CreateTagsAsync(this ITrainingApi trainingApi, Guid projectId, IEnumerable <string> tagNames)
{
foreach (var tag in tagNames)
{
await trainingApi.CreateTagAsync(projectId, tag);
}
}
private static ProjectModel CreateProject(ITrainingApi trainingApi)
{
Console.Write("Project Name: ");
var projectName = Console.ReadLine();
return(trainingApi.CreateProject(projectName));
}
/// <summary>
/// Check if iteration exists or not.
/// </summary>
public static bool CheckIfIterationExists(this ITrainingApi trainingApi, Guid projectId, Guid iterationId)
{
try
{
trainingApi.GetIterationWithHttpMessagesAsync(projectId, iterationId).Wait();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Check if the project exists or not.
/// </summary>
public static bool CheckIfProjectExists(this ITrainingApi trainingApi, Guid projectId)
{
try
{
trainingApi.GetProjectAsync(projectId).Wait();
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Create a project using <paramref name="project"/>
/// </summary>
public static async Task <ProjectInfo> CreateProjectAsync(this ITrainingApi trainingApi, ProjectInfo project)
{
var domains = trainingApi.GetDomains();
var targetDomain = domains.FirstOrDefault(x => string.Equals(x.Name, project.Domain, StringComparison.OrdinalIgnoreCase));
if (targetDomain == null)
{
var supportedDomains = domains.Select(x => x.Name).Aggregate((x, y) => $"{x},{y}");
throw new InvalidOperationException($"Unsupported domain: {project.Domain}. Must be one of {supportedDomains}");
}
var projectModel = await trainingApi.CreateProjectAsync(project.Name, project.Description, targetDomain.Id);
project.Id = projectModel.Id;
project.ThumbnailUri = projectModel.ThumbnailUri;
return(project);
}
public override bool ValidateWithTrainingApi(ITrainingApi trainingApi, out string errorMessage)
{
if (!base.ValidateWithTrainingApi(trainingApi, out errorMessage))
{
return(false);
}
if (AllowedTagNames != null && AllowedTagNames.Count != 0)
{
var existingTagNames = new HashSet <string>(trainingApi.GetTagsAsync(ProjectId, IterationId).Result.Tags.Select(x => x.Name));
var invalidTagNames = AllowedTagNames.Where(x => !existingTagNames.Contains(x)).ToList();
if (invalidTagNames.Count != 0)
{
errorMessage = $"{ErrorMsgPrefix}Some tag names are invalid: {invalidTagNames.Aggregate((x, y) => x + "," + y)}";
}
}
return(errorMessage == null);
}
private static void CreateTags(ITrainingApi trainingApi, ProjectModel project)
{
Console.Write("Number of tags: ");
int numberOfTags;
while (!int.TryParse(Console.ReadLine(), out numberOfTags))
{
Console.Write("Invalid number. Number of tags: ");
}
Console.WriteLine();
for (var i = 1; i <= numberOfTags; i++)
{
Console.Write("Name for tag #" + i + ": ");
var tagName = Console.ReadLine();
var trainingTag = trainingApi.CreateTag(project.Id, tagName);
Console.Write("Images folder: ");
var imagesPath = Console.ReadLine();
// Upload the images we need for training
Console.WriteLine("\nLoading images...");
var images = GetLoadedImagesFromDisk(imagesPath);
// Upload in a single batch
var summary = trainingApi.CreateImagesFromData(project.Id, images, new List <Guid> {
trainingTag.Id
});
if (summary.IsBatchSuccessful)
{
Console.WriteLine("Done!\n");
}
else
{
Console.WriteLine("Error while uploading images, please check your images path.\n");
}
}
}
private static void TrainProject(ITrainingApi trainingApi, ProjectModel project)
{
// Before training images, first create tags
CreateTags(trainingApi, project);
// Now there are images with tags start training the project
Console.WriteLine("Training model...");
var 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")
{
Thread.Sleep(1000);
// Re-query the iteration to get it's updated status
iteration = trainingApi.GetIteration(project.Id, iteration.Id);
}
// The iteration is now trained. Make it the default project endpoint
iteration.IsDefault = true;
trainingApi.UpdateIteration(project.Id, iteration.Id, iteration);
Console.WriteLine("Model trained!\n");
}
public virtual bool ValidateWithTrainingApi(ITrainingApi trainingApi, out string errorMessage)
{
errorMessage = null;
try
{
trainingApi.GetProjects();
}
catch (HttpOperationException ex)
{
if (ex.Message.Contains("NotFound"))
{
errorMessage = $"{ErrorMsgPrefix}{ex.Message} It is likely the base url {BaseUri} is wrong.";
}
else if (ex.Message.Contains("Unauthorized"))
{
errorMessage = $"{ErrorMsgPrefix}{ex.Message}. It is likely the training key is wrong.";
}
else
{
errorMessage = ex.Message;
}
return(false);
}
if (ProjectId != Guid.Empty && !trainingApi.CheckIfProjectExists(ProjectId))
{
errorMessage = $"{ErrorMsgPrefix}Project with id {ProjectId} does not exist.";
}
else if (IterationId != null && !trainingApi.CheckIfIterationExists(ProjectId, IterationId.Value))
{
errorMessage = $"{ErrorMsgPrefix}Iteration with id {IterationId} does not exist within project with id {ProjectId}.";
}
return(errorMessage == null);
}
/// <summary>
/// Generate an instance of <see cref="IImagesUploader"/> based on <paramref name="options"/>.
/// </summary>
/// <returns>Requested instance of the desired implementation of <see cref="IImagesUploader"/></returns>
public static IImagesUploader GenerateImagesUploader(TrainingOptions options, ITrainingApi trainApi)
{
switch (options.ImageSource)
{
case "url":
return(new UrlImagesUploader(trainApi, options.UploadBatchSize));
case "local":
return(new LocalImagesUploader(trainApi, options.UploadBatchSize));
default:
throw new InvalidOperationException($"Not supported source of images: {options.ImageSource}");
}
}
/// <summary>
/// Adds the provided images to the current project iteration
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='projectId'>
/// The project id.
/// </param>
/// <param name='imageData'>
/// </param>
/// <param name='tagIds'>
/// The tags ids to associate with the image batch.
/// </param>
public static CreateImageSummaryModel CreateImagesFromData(this ITrainingApi operations, System.Guid projectId, IEnumerable <Stream> imageData, IList <Guid> tagIds = default(IList <Guid>))
{
return(operations.CreateImagesFromDataAsync(projectId, imageData, tagIds).GetAwaiter().GetResult());
}
protected ImagesUploaderInBatches(ITrainingApi trainingApi, int batchSize)
{
BatchSize = batchSize;
TrainingApi = trainingApi;
}
public ImagesLoaderFromProject(ITrainingApi trainingApi, Guid projectId, Guid?iterationId, IEnumerable <string> allowedTagNames) : base(allowedTagNames)
{
TrainingApi = trainingApi;
ProjectId = projectId;
IterationId = iterationId;
}
public LocalImagesUploader(ITrainingApi trainingApi, int batchSize) : base(trainingApi, batchSize)
{
}
/// <summary>
/// Adds the provided images to the current project iteration
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='projectId'>
/// The project id.
/// </param>
/// <param name='imageData'>
/// </param>
/// <param name='tagIds'>
/// The tags ids to associate with the image batch.
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
public static HttpOperationResponse <CreateImageSummaryModel> CreateImagesFromDataWithHttpMessages(this ITrainingApi operations, System.Guid projectId, IEnumerable <Stream> imageData, IList <Guid> tagIds = default(IList <Guid>), Dictionary <string, List <string> > customHeaders = null)
{
return(operations.CreateImagesFromDataWithHttpMessagesAsync(projectId, imageData, tagIds, customHeaders, CancellationToken.None).ConfigureAwait(false).GetAwaiter().GetResult());
}
public UrlImagesUploader(ITrainingApi trainingApi, int batchSize, int retryTimes = 3) : base(trainingApi, batchSize)
{
RetryTimes = retryTimes;
}
