public async Task <object> UploadImageToAzure(CustomVisionBatchImage customVisionBatchImage, Guid projectId)
{
CustomVisionTrainingClient trainingApi = AuthenticateTraining(customVisionBatchImage.Endpoint, customVisionBatchImage.TrainingKey);
var currentProject = await trainingApi.GetProjectAsync(projectId);
// Create the ImageUrlBatch to send to CustomVision
List <ImageUrlCreateEntry> singleUrlEntry = new List <ImageUrlCreateEntry>();
foreach (CustomVisionImage customVisionImage in customVisionBatchImage.BatchImage)
{
singleUrlEntry.Add(new ImageUrlCreateEntry(customVisionImage.ImageUri));
}
ImageUrlCreateBatch batchEntry = new ImageUrlCreateBatch(singleUrlEntry);
var isUploaded = trainingApi.CreateImagesFromUrlsAsync(projectId, batchEntry);
List <string> createdImageUris = new List <string>();
foreach (ImageCreateResult image in isUploaded.Result.Images)
{
createdImageUris.Add(image.Image.OriginalImageUri);
}
var response = new
{
project_id = projectId,
project_name = currentProject.Name,
image_count = isUploaded.Result.Images.Count,
image_create_result = createdImageUris
};
return(response);
}
public async Task <SpectraProjectWithMetadata> GetProject(CustomVisionProject project, string projectId)
{
CustomVisionTrainingClient trainingApi = AuthenticateTraining(project.Endpoint, project.TrainingKey);
var spectraProjectCollection = _database.GetCollection <SpectraProject>("spectra-projects");
var projectMetaData = spectraProjectCollection.Find(x => x.ProjectId == projectId).FirstOrDefault();
// Get all the Custom Vision projects
var customVisionProject = await trainingApi.GetProjectAsync(Guid.Parse(projectId));
var mergedObject = new SpectraProjectWithMetadata
{
Category = projectMetaData.Category,
DemoUrls = projectMetaData.DemoUrls,
HeroUrl = projectMetaData.HeroUrl,
Created = customVisionProject.Created,
Description = customVisionProject.Description,
DrModeEnabled = customVisionProject.DrModeEnabled,
Id = customVisionProject.Id,
LastModified = customVisionProject.LastModified,
Name = customVisionProject.Name,
Settings = customVisionProject.Settings,
Status = customVisionProject.Status,
ThumbnailUri = customVisionProject.ThumbnailUri
};
return(mergedObject);
}
static void Main(string[] args)
{
// Get Configuration Settings
IConfigurationBuilder builder = new ConfigurationBuilder().AddJsonFile("appsettings.json");
IConfigurationRoot configuration = builder.Build();
string training_endpoint = configuration["TrainingEndpoint"];
string training_key = configuration["TrainingKey"];
Guid project_id = Guid.Parse(configuration["ProjectID"]);
try
{
// Authenticate a client for the training API
training_client = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(training_key))
{
Endpoint = training_endpoint
};
// Get the Custom Vision project
custom_vision_project = training_client.GetProject(project_id);
// Upload and tag images
Upload_Images("more-training-images");
// Retrain the model
Train_Model();
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
private async Task UploadCachedScreenshots()
{
if (!_ImagesToUpload.Any())
{
return;
}
var trainingClient = new CustomVisionTrainingClient()
{
ApiKey = _CustomVisionKey,
Endpoint = _AzureEndpoint
};
var listToLoad = new List <ImageFileCreateEntry>();
while (_ImagesToUpload.Any())
{
var imgStream = _ImagesToUpload.Dequeue();
listToLoad.Add(new ImageFileCreateEntry(contents: imgStream.ToArray()));
}
var result = await trainingClient.CreateImagesFromFilesWithHttpMessagesAsync(_AzureProjectId, new ImageFileCreateBatch()
{
Images = listToLoad
});
_TotalPictures -= (byte)result.Body.Images.Where(r => r.Status != "OK").Count();
if (_TotalPictures >= DefaultTrainingCount)
{
_CurrentlyTraining = true;
}
Console.WriteLine(result.ToString());
}
public static IList <Project> GetProjects(CustomVisionTrainingClient cvClient)
{
//GetProjects for Training Key and Endpoint verification
var projects = cvClient.GetProjects();
return(projects);
}
public static IList <Iteration> GetIterations(CustomVisionTrainingClient cvClient, Guid cvProjectId)
{
//GetIterations
var iterations = cvClient.GetIterations(cvProjectId);
return(iterations);
}
// </snippet_train>
// <snippet_publish>
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
}
async Task PredictPhoto(MediaFile photo)
{
var endpoint = new PredictionEndpoint
{
ApiKey = await KeyService.GetPredictionKey()
};
var results = await endpoint.PredictImageAsync(Guid.Parse(await KeyService.GetProjectId()),
photo.GetStream());
AllPredictions = results.Predictions
.Where(p => p.Probability > Probability)
.ToList();
// Create the Api, passing in the training key
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = KeyService.TK,
Endpoint = KeyService.SouthCentralUsEndpoint
};
// Find the object detection domain
//var domains = trainingApi.GetDomains();
//var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");
//upload to service
trainingApi.CreateImagesFromData(Guid.Parse(await KeyService.GetProjectId()), photo.GetStream(), null);
}
async Task InitCustomVision()
{
//setup custom vision clients
if (!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionTrainingApiKey) &&
!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionPredictionApiKey))
{
_customVisionTraining = new CustomVisionTrainingClient {
Endpoint = SettingsHelper.Instance.CustomVisionTrainingApiKeyEndpoint, ApiKey = SettingsHelper.Instance.CustomVisionTrainingApiKey
};
_customVisionPrediction = new CustomVisionPredictionClient {
Endpoint = SettingsHelper.Instance.CustomVisionPredictionApiKeyEndpoint, ApiKey = SettingsHelper.Instance.CustomVisionPredictionApiKey
};
}
//get custom vision projects
CustomVisionProjects.Clear();
if (_customVisionTraining != null)
{
var projects = await _customVisionTraining.GetProjectsAsync();
CustomVisionProjects.AddRange(projects.OrderBy(i => i.Name).Select(i => new ProjectViewModel {
Project = i
}));
}
//enable UI
CustomVisionApi.IsEnabled = _customVisionTraining != null;
}
async Task InitCustomVision()
{
//setup custom vision clients
if (!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionTrainingApiKey) &&
!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionPredictionApiKey) &&
!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionPredictionResourceId))
{
_customVisionTraining = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(SettingsHelper.Instance.CustomVisionTrainingApiKey))
{
Endpoint = SettingsHelper.Instance.CustomVisionTrainingApiKeyEndpoint
};
_customVisionPrediction = new CustomVisionPredictionClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Prediction.ApiKeyServiceClientCredentials(SettingsHelper.Instance.CustomVisionPredictionApiKey))
{
Endpoint = SettingsHelper.Instance.CustomVisionPredictionApiKeyEndpoint
};
}
//get custom vision projects
CustomVisionProjects.Clear();
if (_customVisionTraining != null)
{
var projects = await _customVisionTraining.GetProjectsAsync();
CustomVisionProjects.AddRange(projects.OrderBy(i => i.Name).Select(i => new ProjectViewModel {
Project = i
}));
}
//enable UI
CustomVisionApi.IsEnabled = _customVisionTraining != null;
}
public void AddImage(string data)
{
TagResponse resp = JsonConvert.DeserializeObject <TagResponse>(data);
// Create the Api, passing in the training key
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = endpointUrl
};
var project = trainingApi.GetProject(PROJECT_ID);
byte[] imgBytes = Convert.FromBase64String(resp.ImgBase64);
foreach (string tagName in resp.TagNames)
{
var tag = trainingApi.CreateTag(PROJECT_ID, tagName);
resp.TagIds.Add(tag.Id);
}
// Images can be uploaded one at a time
using (var stream = new MemoryStream(imgBytes))
{
trainingApi.CreateImagesFromData(project.Id, stream, resp.TagIds);
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
if (!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionTrainingApiKey) &&
!string.IsNullOrEmpty(SettingsHelper.Instance.CustomVisionPredictionApiKey))
{
userProvidedTrainingApi = new CustomVisionTrainingClient {
Endpoint = SouthCentralUsEndpoint, ApiKey = SettingsHelper.Instance.CustomVisionTrainingApiKey
};
userProvidedPredictionApi = new CustomVisionPredictionClient {
Endpoint = SouthCentralUsEndpoint, ApiKey = SettingsHelper.Instance.CustomVisionPredictionApiKey
};
}
this.DataContext = this;
await this.LoadProjectsFromService();
if (!this.Projects.Any())
{
await new MessageDialog("It looks like you don't have any projects yet. Please create a project via the '+' button near the Target Project list in this page.", "No projects found").ShowAsync();
this.webCamButton.IsEnabled = false;
this.PicturesAppBarButton.IsEnabled = false;
}
base.OnNavigatedTo(e);
}
public async Task <Product> AddProduct(List <Stream> images, Product product)
{
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = _trainingKey,
Endpoint = _endpointUrl
};
Tag tag;
try
{
tag = await trainingApi.CreateTagAsync(_projectId, product.TagName);
}
catch (CustomVisionErrorException e)
{
throw new Exception(e.Body.Message, e);
}
foreach (var image in images)
{
image.Seek(0, SeekOrigin.Begin);
await trainingApi.CreateImagesFromDataAsync(_projectId, image, new List <Guid>() { tag.Id });
}
product.CustomVisionTagId = tag.Id;
return(product);
}
// </snippet_train>
// <snippet_publish>
private static void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
// The iteration is now trained. Publish it to the prediction end point.
trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
Console.WriteLine("Done!\n");
}
private int UploadFolder(CustomVisionTrainingClient trainingApi, int fileCount, string directory, Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models.Tag targetTag)
{
Console.WriteLine($"Batch uploading content from {directory}....");
var imageFiles = Directory.GetFiles(directory).Select(img => new ImageFileCreateEntry(Path.GetFileName(img), File.ReadAllBytes(img))).ToList();
try
{
while (imageFiles.Any())
{
var batchSize = Math.Min(imageFiles.Count, BATCH_SIZE);
var ifcb = new ImageFileCreateBatch(imageFiles.Take(batchSize).ToList(), new List <Guid>()
{
targetTag.Id
});
var res = trainingApi.CreateImagesFromFiles(Options.ProjectId, ifcb);
var errorCount = PrintBatchErrors(res);
imageFiles.RemoveRange(0, batchSize);
fileCount += batchSize;
Console.WriteLine($" {batchSize} files uploaded with {errorCount} errors ({fileCount} total)");
}
}
catch (CustomVisionErrorException ex) { Console.WriteLine($"Error: {ex.DetailedMessage()}"); }
fileCount += imageFiles.Count;
return(fileCount);
}
public void Run()
{
// Add your training & prediction key from the settings page of the portal
_trainingApi = CreateTrainingApi();
// Find the object detection domain
var domains = _trainingApi.GetDomains();
var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");
Console.WriteLine($"Loading project: Id = {CustomVisionProjectId.ToString()}");
//var project = _trainingApi.CreateProject("My New Project", null, objDetectionDomain.Id);
var project = _trainingApi.GetProject(CustomVisionProjectId);
if (project == null)
{
Console.WriteLine($"Project not found: Id = {CustomVisionProjectId.ToString()}");
}
else
{
Console.WriteLine($"Project - Name '{project.Name}' is loaded");
}
var tags = _trainingApi.GetTags(CustomVisionProjectId).ToList();
var organicTag = GetTag(project, tags, "organic", true);
var paperTag = GetTag(project, tags, "paper", true);
var mixedTag = GetTag(project, tags, "mixed", true);
var landfillTag = GetTag(project, tags, "landfill", true);
UploadImageWithTag(project, organicTag, "organic");
UploadImageWithTag(project, paperTag, "paper");
UploadImageWithTag(project, mixedTag, "mixed");
UploadImageWithTag(project, landfillTag, "landfill");
}
public CustomVisionServiceWrapper(string apiKey, string endpoint)
{
trainingApi = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(apiKey))
{
Endpoint = endpoint
};
}
private void MakePredictionRequest(string filepath)
{
CustomVisionTrainingClient trainingClient = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = SouthCentralUsEndpoint
};
// Create a prediction endpoint, passing in obtained prediction key
CustomVisionPredictionClient endpoint = new CustomVisionPredictionClient()
{
ApiKey = predictionKey,
Endpoint = SouthCentralUsEndpoint
};
var project = trainingClient.GetProjects().FirstOrDefault();
// Make a prediction against the new project
Console.WriteLine("Making a prediction:");
var result = endpoint.PredictImage(project.Id, new MemoryStream(File.ReadAllBytes(filepath)));
// Loop over each prediction and write out the results
foreach (var c in result.Predictions)
{
Console.WriteLine($"\t{c.TagName}: {c.Probability:P1}");
}
}
private async void PopulateTagSamplesAsync(Guid projectId, CustomVisionTrainingClient trainingEndPoint, ObservableCollection <TagSampleViewModel> collection)
{
//take samples images rotating through each tag
var maxSamples = 8;
var tags = (await trainingEndPoint.GetTagsAsync(projectId)).OrderBy(i => i.Name).ToArray();
//extend sample count to atleast match tag count
if (tags.Length > maxSamples)
{
maxSamples = (int)Math.Ceiling(tags.Length / 4d) * 4;
}
var sampleTasks = tags.Select(i => trainingEndPoint.GetTaggedImagesAsync(projectId, null, new List <Guid>()
{
i.Id
}, null, maxSamples)).ToArray(); //request sample images for each tag
await Task.WhenAll(sampleTasks); //wait for request to finish
//round-robin out sample images
var roundRobin = new RoundRobinIterator <Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.Models.Image>(sampleTasks.Select(i => i.Result));
collection.AddRange(roundRobin.Distinct(new TaggedImageComparer()).Take(maxSamples).Select(i => new TagSampleViewModel {
TagSampleImage = new BitmapImage(new Uri(i.OriginalImageUri))
}));
UpdateSuggestedPhotoList();
}
// </snippet_addtags>
// <snippet_upload>
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
}));
}
static void Main(string[] args)
{
tags = new List <string>();
// Console.WriteLine("Enter the tags of the image to be uploaded");
for (int i = 0; i < 2; i++)
{
tags.Add(Console.ReadLine());
}
// Add your training & prediction key from the settings page of the portal
// Create the Api, passing in the training key
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = SouthCentralUsEndpoint
};
uploadImages(trainingApi);
// Now there is a trained endpoint, it can be used to make a prediction
// Create a prediction endpoint, passing in obtained prediction key
// predictingImages(endpoint);
Console.ReadKey();
}
public CustomVisionServiceWrapper(string apiKey, string endpoint)
{
trainingApi = new CustomVisionTrainingClient
{
ApiKey = apiKey,
Endpoint = endpoint
};
}
// </snippet_loadimages>
// <snippet_delete>
private static void DeleteProject(CustomVisionTrainingClient trainingApi, Project project)
{
// Delete project. Note you cannot delete a project with a published iteration; you must unpublish the iteration first.
Console.WriteLine("Unpublishing iteration.");
trainingApi.UnpublishIteration(project.Id, iteration.Id);
Console.WriteLine("Deleting project.");
trainingApi.DeleteProject(project.Id);
}
public MachineLearningTags(CustomVisionTrainingClient trainingApi,
Guid projectId,
IEnumerable <SkiVideoEntity> videos)
{
this.m_trainingApi = trainingApi;
this.m_videos = videos;
this.m_projectId = projectId;
this.m_tags = m_trainingApi.GetTags(this.m_projectId);
}
private static CustomVisionTrainingClient AuthenticateTraining(string endpoint, string trainingKey)
{
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient(new Microsoft.Azure.CognitiveServices.Vision.CustomVision.Training.ApiKeyServiceClientCredentials(trainingKey))
{
Endpoint = endpoint
};
return(trainingApi);
}
// </snippet_train>
// <snippet_publish>
private void PublishIteration(CustomVisionTrainingClient trainingApi, Project project)
{
// The iteration is now trained. Publish it to the prediction end point.
var publishedModelName = "toolModel";
var predictionResourceId = "<target prediction resource ID>";
trainingApi.PublishIteration(project.Id, iteration.Id, publishedModelName, predictionResourceId);
Console.WriteLine("Done!\n");
}
public ImageClassifcation()
{
// Create the Api, passing in the training key
trainingApi = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = SouthCentralUsEndpoint
};
}
public TrainingHostedService(
ILogger <TrainingHostedService> logger,
IHostApplicationLifetime appLifetime,
TrainingOptions trainingOptions)
{
_logger = logger;
_appLifetime = appLifetime;
_trainingClient = CreateClient(trainingOptions);
}
public CustomVisionService(string trainingApiKey, string trainingEndpoint, Guid projectId)
{
trainingApi = new CustomVisionTrainingClient
{
ApiKey = trainingApiKey,
Endpoint = trainingEndpoint
};
this.projectId = projectId;
}
public async Task <IActionResult> Post(List <IFormFile> img)
{
var requestStream = Request.HttpContext.Items;
const string scue = "https://southcentralus.api.cognitive.microsoft.com";
string trainingKey = "4f473807b7434dd5a1bdb45cb9104b38";
CustomVisionTrainingClient trainingApi = new CustomVisionTrainingClient()
{
ApiKey = trainingKey,
Endpoint = scue
};
// Find the object detection domain
var domains = trainingApi.GetDomainsAsync();
//var objDetectionDomain = domains.FirstOrDefault(d => d.Type == "ObjectDetection");
var project = trainingApi.GetProject(Guid.Parse("b911d77a-ef25-47fd-86ed-87db4500ef7b"));
const string southcentralus = "https://southcentralus.api.cognitive.microsoft.com";
string predictionKey = "a58f3ca5856c491db0b73b87cb1118cf";
CustomVisionPredictionClient endpoint = new CustomVisionPredictionClient()
{
ApiKey = predictionKey,
Endpoint = southcentralus
};
var c = new List <PredictionModel>();
var result = endpoint.PredictImage(Guid.Parse("cbfa66a3-9815-47d6-a389-7438e468ac15"), img[0].OpenReadStream());
ImageUrl imgUrl = new ImageUrl();
imgUrl.Url = "https://http2.mlstatic.com/guitarra-tagima-pr-200-special-pr200-sunburst-D_NQ_NP_894387-MLB26271081482_112017-F.jpg";
var resultImageUrl = endpoint.PredictImageUrl(Guid.Parse("cbfa66a3-9815-47d6-a389-7438e468ac15"), imgUrl);
foreach (var item in result.Predictions.OrderBy(x => x.Probability))
{
var pm = new PredictionModel(Math.Round(item.Probability * 100), item.TagId, item.TagName, item.BoundingBox);
if (pm.Probability > 70)
{
pm.BoundingBox.Top = Convert.ToInt32(pm.BoundingBox.Top * 380);
pm.BoundingBox.Height = Convert.ToInt32(pm.BoundingBox.Height * 380);
pm.BoundingBox.Left = Convert.ToInt32(pm.BoundingBox.Left * 700);
pm.BoundingBox.Width = Convert.ToInt32(pm.BoundingBox.Width * 700);
c.Add(pm);
}
}
return(Ok(c));
}
