Example #1
0
        public static void CreateImageFromUrls([QueueTrigger("create-image-from-urls")] CreateImageFromUrlsRequest imageCreateRequest, TraceWriter log)
        {
            log.Info($"C# Queue trigger function processed: {imageCreateRequest}");

            // https://docs.microsoft.com/ja-jp/azure/cognitive-services/custom-vision-service/csharp-tutorial
            var CV_ProjectId   = Environment.GetEnvironmentVariable("CV_ProjectId");
            var CV_TrainingKey = Environment.GetEnvironmentVariable("CV_TrainingKey");
            //var CV_PredictionKey = Environment.GetEnvironmentVariable("CV_PredictionKey");

            var trainingApi = new TrainingApi()
            {
                ApiKey = CV_TrainingKey
            };
            var projectId = Guid.Parse(CV_ProjectId);
            //var project = new ProjectInfo(trainingApi.GetProject(Guid.Parse(CV_ProjectId)));

            var requestTags      = imageCreateRequest.Tags.ToList();
            var existTags        = trainingApi.GetTags(projectId);
            var nonExistTagNames = requestTags.Except(existTags.Select(x => x.Name));
            var tagIds           = existTags.Where(x => requestTags.Contains(x.Name)).Select(x => x.Id).ToList();

            nonExistTagNames.ToList().ForEach(tagName =>
            {
                // XXX 同時に同じタグ名を指定された複数のキューを処理すると、重複してタグ作成してしまう。
                // 現状、重複エラー後のリトライで処理
                var tag = trainingApi.CreateTag(projectId, tagName);
                tagIds.Add(tag.Id);
            });

            var images = new List <ImageUrlCreateEntry>()
            {
                new ImageUrlCreateEntry()
                {
                    Url = imageCreateRequest.Url
                }
            };

            trainingApi.CreateImagesFromUrls(Guid.Parse(CV_ProjectId), new ImageUrlCreateBatch(images, tagIds));
        }
Example #2
0
        public static HttpResponseMessage Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(TrainClassifier))]
                                              HttpRequestMessage req, TraceWriter log)
        {
            using (var analytic = new AnalyticService(new RequestTelemetry
            {
                Name = nameof(TrainClassifier)
            }))
            {
                try
                {
                    var allTags   = new List <string>();
                    var json      = req.Content.ReadAsStringAsync().Result;
                    var j         = JObject.Parse(json);
                    var gameId    = (string)j["gameId"];
                    var imageUrls = j["imageUrls"].ToObject <List <string> >();
                    var tags      = (JArray)j["tags"];

                    var game = CosmosDataService.Instance.GetItemAsync <Game>(gameId).Result;

                    var          api     = new TrainingApi(new TrainingApiCredentials(ConfigManager.Instance.CustomVisionTrainingKey));
                    ProjectModel project = null;

                    //Get the existing project for this game if there is one
                    if (!string.IsNullOrEmpty(game.CustomVisionProjectId))
                    {
                        try
                        {
                            project = api.GetProject(Guid.Parse(game.CustomVisionProjectId));
                        }
                        catch (Exception) { }
                    }

                    //Otherwise create a new project and associate it with the game
                    if (project == null)
                    {
                        project = api.CreateProject(game.Name, game.Id);
                        game.CustomVisionProjectId = project.Id.ToString();
                        CosmosDataService.Instance.UpdateItemAsync <Game>(game).Wait();
                    }

                    //Generate tag models for training
                    var tagModels = new List <ImageTagModel>();
                    foreach (string tag in tags)
                    {
                        var model = api.CreateTag(project.Id, tag.Trim());
                        tagModels.Add(model);
                    }

                    //Batch the image urls that were sent up from Azure Storage (blob)
                    var batch   = new ImageUrlCreateBatch(tagModels.Select(m => m.Id).ToList(), imageUrls);
                    var summary = api.CreateImagesFromUrls(project.Id, batch);

                    if (!summary.IsBatchSuccessful)
                    {
                        return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Image batch was unsuccessful"));
                    }

                    //Traing the classifier and generate a new iteration, that we'll set as the default
                    var iteration = api.TrainProject(project.Id);

                    while (iteration.Status == "Training")
                    {
                        Thread.Sleep(1000);
                        iteration = api.GetIteration(project.Id, iteration.Id);
                    }

                    iteration.IsDefault = true;
                    api.UpdateIteration(project.Id, iteration.Id, iteration);

                    return(req.CreateResponse(HttpStatusCode.OK, true));
                }
                catch (Exception e)
                {
                    analytic.TrackException(e);

                    return(req.CreateErrorResponse(HttpStatusCode.BadRequest, e));
                }
            }
        }
Example #3
0
 /// <summary>
 /// 上传图片
 /// </summary>
 /// <param name="projectId"></param>
 /// <param name="createBatch"></param>
 /// <returns></returns>
 public Task UploadOnlineImage(Guid projectId, ImageUrlCreateBatch createBatch)
 {
     return(Task.Run(() => {
         trainingApi.CreateImagesFromUrls(projectId, createBatch);
     }));
 }
Example #4
0
        async public static Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = nameof(TrainClassifier))]
                                                           HttpRequestMessage req, TraceWriter log)
        {
            using (var analytic = new AnalyticService(new RequestTelemetry
            {
                Name = nameof(TrainClassifier)
            }))
            {
                try
                {
                    var allTags   = new List <string>();
                    var json      = req.Content.ReadAsStringAsync().Result;
                    var j         = JObject.Parse(json);
                    var gameId    = (string)j["gameId"];
                    var imageUrls = j["imageUrls"].ToObject <List <string> >();
                    var tags      = (JArray)j["tags"];

                    var         game = CosmosDataService.Instance.GetItemAsync <Game>(gameId).Result;
                    TrainingApi api  = new TrainingApi {
                        ApiKey = ConfigManager.Instance.CustomVisionTrainingKey
                    };
                    Project project = null;

                    //Get the existing project for this game if there is one
                    if (!string.IsNullOrEmpty(game.CustomVisionProjectId))
                    {
                        try     { project = api.GetProject(Guid.Parse(game.CustomVisionProjectId)); }
                        catch (Exception) { }
                    }

                    //Otherwise create a new project and associate it with the game
                    if (project == null)
                    {
                        project = api.CreateProject($"{game.Name}_{DateTime.Now.ToString()}_{Guid.NewGuid().ToString()}", game.Id);
                        game.CustomVisionProjectId = project.Id.ToString();
                        CosmosDataService.Instance.UpdateItemAsync <Game>(game).Wait();
                    }

                    var tagItems = tags.Select(t => api.CreateTag(project.Id, t.ToString().Trim()));
                    var entries  = imageUrls.Select(u => new ImageUrlCreateEntry(u)).ToList();

                    //Batch the image urls that were sent up from Azure Storage (blob)
                    var batch   = new ImageUrlCreateBatch(entries, tagItems.Select(t => t.Id).ToList());
                    var summary = api.CreateImagesFromUrls(project.Id, batch);

                    //if(!summary.IsBatchSuccessful)
                    //	return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Image batch was unsuccessful");

                    //Traing the classifier and generate a new iteration, that we'll set as the default
                    var iteration = api.TrainProject(project.Id);

                    while (iteration.Status == "Training")
                    {
                        Thread.Sleep(1000);
                        iteration = api.GetIteration(project.Id, iteration.Id);
                    }

                    iteration.IsDefault = true;
                    api.UpdateIteration(project.Id, iteration.Id, iteration);

                    var data = new Event("Training classifier");
                    data.Add("project", project.Name);
                    data.Add("iteration", iteration.Id);
                    await EventHubService.Instance.SendEvent(data);

                    return(req.CreateResponse(HttpStatusCode.OK, true));
                }
                catch (Exception e)
                {
                    analytic.TrackException(e);

                    var baseException      = e.GetBaseException();
                    var operationException = baseException as HttpOperationException;
                    var reason             = baseException.Message;

                    if (operationException != null)
                    {
                        var jobj = JObject.Parse(operationException.Response.Content);
                        var code = jobj.GetValue("Code");

                        if (code != null && !string.IsNullOrWhiteSpace(code.ToString()))
                        {
                            reason = code.ToString();
                        }
                    }

                    return(req.CreateErrorResponse(HttpStatusCode.BadRequest, reason));
                }
            }
        }
Example #5
0
        public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequestMessage req, TraceWriter log)
        {
            try
            {
                var allTags     = new List <string>();
                var json        = req.Content.ReadAsStringAsync().Result;
                var jobj        = JObject.Parse(json);
                var tags        = (JArray)jobj["tags"];
                var term        = jobj["term"].ToString();
                var projectId   = jobj["projectId"].ToString();
                var trainingKey = jobj["trainingKey"].ToString();
                var offset      = 0;

                if (jobj["offset"] != null)
                {
                    offset = (int)jobj["offset"];
                }

                var imageUrls = await SearchForImages(term, offset);

                var api     = new TrainingApi(new TrainingApiCredentials(trainingKey));
                var project = api.GetProject(Guid.Parse(projectId));

                var tagModels    = new List <ImageTagModel>();
                var existingTags = api.GetTags(project.Id);
                foreach (string tag in tags)
                {
                    ImageTagModel model = existingTags.Tags.SingleOrDefault(t => t.Name == tag);

                    if (model == null)
                    {
                        model = api.CreateTag(project.Id, tag.Trim());
                    }

                    tagModels.Add(model);
                }

                var batch   = new ImageUrlCreateBatch(tagModels.Select(m => m.Id).ToList(), imageUrls);
                var summary = api.CreateImagesFromUrls(project.Id, batch);

                //if(!summary.IsBatchSuccessful)
                //	return req.CreateErrorResponse(HttpStatusCode.BadRequest, "Image batch was unsuccessful");

                //Traing the classifier and generate a new iteration, that we'll set as the default
                var iteration = api.TrainProject(project.Id);

                while (iteration.Status == "Training")
                {
                    Thread.Sleep(1000);
                    iteration = api.GetIteration(project.Id, iteration.Id);
                }

                iteration.IsDefault = true;
                api.UpdateIteration(project.Id, iteration.Id, iteration);

                return(req.CreateResponse(HttpStatusCode.OK, iteration.Id));
            }
            catch (Exception e)
            {
                var exception = e.GetBaseException();
                return(req.CreateErrorResponse(HttpStatusCode.BadRequest, exception.Message));
            }

            async Task <List <string> > SearchForImages(string term, int offset)
            {
                var client = new HttpClient();

                client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", "c2adf0e5c057447ea9e0f50cc5202251");
                var uri = $"https://api.cognitive.microsoft.com/bing/v7.0/images/search?count=50&q={term}&offset={offset}";

                var json = await client.GetStringAsync(uri);

                var jobj = JObject.Parse(json);
                var arr  = (JArray)jobj["value"];

                var list = new List <string>();

                foreach (var result in arr)
                {
                    list.Add(result["contentUrl"].ToString());
                }

                return(list);
            }
        }