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)); }