public IPredictionResult Predict(PredictorType predictorType, double[][] training, double[][] test, int numberOfDays, int numberOfIterations, double likelihoodTolerance) { var model = (HiddenMarkovModelWeightedMixtureDistribution)HiddenMarkovModelFactory.GetModel <HiddenMarkovModelWeightedMixtureDistribution, Mixture <IMultivariateDistribution> >(new ModelCreationParameters <Mixture <IMultivariateDistribution> > { Pi = _pi, TransitionProbabilityMatrix = _transitionProbabilityMatrix, Emissions = _emission }); //new HiddenMarkovModelState<IMultivariateDistribution>(_pi, _transitionProbabilityMatrix, _emission); model.Normalized = Normalized; var request = new PredictionRequest(); request.TrainingSet = training; request.TestSet = test; request.NumberOfDays = numberOfDays; request.Tolerance = PREDICTION_LIKELIHOOD_TOLERANCE; request.TrainingLikelihoodTolerance = likelihoodTolerance; request.NumberOfTrainingIterations = numberOfIterations; var predictor = HiddenMarkovModelPredictorFactory.GetPredictor(predictorType); return(predictor.Predict(model, request)); }
private static PredictionRequest BuildRequest(ChangedFiles changedFiles) { var request = new PredictionRequest(); foreach (var loopFile in changedFiles.Files) { request.Items.Add(new PredictionRequestFile { Author = loopFile.Author, Path = loopFile.Path, OldPath = loopFile.OldPath, NumberOfModifiedLines = loopFile.NumberOfModifiedLines, CCMMd = loopFile.CCMMd, CCMAvg = loopFile.CCMAvg, CCMMax = loopFile.CCMMax }); } return(request); }
/// <summary> /// Given a trackID, gets its audio features then passes that /// to the Machine Learning Web Service /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <JsonResult> GetPrediction(string id) { Task <JObject> audioFeatures = SpotifyAPIs.GetSpotifyAudioFeaturesAsync(id); Task <int> trackYear = SpotifyAPIs.GetTrackReleaseYear(id); await Task.WhenAll(audioFeatures, trackYear); string response; if (audioFeatures.Result != null && trackYear.Result != 0) { var scoreRequest = PredictionRequest.CreateRequest(audioFeatures.Result, trackYear.Result); response = await CallMlService(scoreRequest); } else { response = "Try again: Spotify Web APIs returned an error"; } return(Json(response, JsonRequestBehavior.AllowGet)); }
public async Task <string> PredictAsync(PredictionRequest request) { if (_model == null) { _model = await PredictionModel.ReadAsync <BankStatementLineItem, PredictedLabel>( PredictionModelWrapper.GetModel()); } var item = new BankStatementLineItem { Description = request.Description, Amount = request.Amount, //AccountNumber = request.AccountNumber, //AccountName = request.AccountName, Bank = request.Bank //TransactionUtcDate = request.TransactionUtcDate, //Notes = request.Notes, //Tags = request.Tags }; await SemaphoreSlim.WaitAsync(); PredictedLabel predicted = null; try { predicted = _model.Predict(item); } catch (Exception ex) { Log.Warning(ex, "error {err}", request); throw; } finally { //When the task is ready, release the semaphore. It is vital to ALWAYS release the semaphore when we are ready, or else we will end up with a Semaphore that is forever locked. SemaphoreSlim.Release(); } return(predicted.SubCategory); }
public void Evaluate_HMMMultivariateAndFTSESeriesLength20_ErrorEstimatorCalculated() { var util = new TestDataUtils(); var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18)); var test = util.GetSvcData(util.FTSEFilePath, new DateTime(2011, 12, 18), new DateTime(2012, 01, 18)); var model = (HiddenMarkovModelMultivariateGaussianDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>() { NumberOfStates = _NumberOfStates }); model.Normalized = true; model.Train(series, _NumberOfIterations, _LikelihoodTolerance); var pred = new ViterbiBasedPredictor(); var request = new PredictionRequest { TrainingSet = series, NumberOfDays = 20, TestSet = test }; pred.NumberOfIterations = _NumberOfIterations; pred.LikelihoodTolerance = _LikelihoodTolerance; var predictions = pred.Predict(model, request); var errorRequest = new EvaluationRequest { EstimatorType = ErrorEstimatorType.Value, PredictionParameters = request, PredictionToEvaluate = predictions }; var errorEstimation = pred.Evaluate(errorRequest); for (int i = 0; i < series[0].Length; i++) { Assert.IsTrue(errorEstimation.CumulativeForecastError[i] > 0); Assert.IsTrue(errorEstimation.MeanAbsoluteDeviation[i] > 0); Assert.IsTrue(errorEstimation.MeanAbsolutePercentError[i] > 0); Assert.IsTrue(errorEstimation.MeanError[i] > 0); Assert.IsTrue(errorEstimation.MeanSquaredError[i] > 0); Assert.IsTrue(errorEstimation.RootMeanSquaredError[i] > 0); } }
static async Task <PredictionResponse> GetPredictionAsync() { // Get client using (var luisClient = CreateClient()) { // Change the query text to test the various options presented in the unit text var predictionRequest = new PredictionRequest { Query = "turn on the light", }; // get prediction return(await luisClient.Prediction.GetSlotPredictionAsync( Guid.Parse(appId), slotName : "production", predictionRequest, verbose : false, showAllIntents : false, log : true)); } }
public async Task <IActionResult> Search(PredictionRequest request) { Guard.AgainstNull(request); using (LogContext.PushProperty("request", request.ToJson())) using (LogContext.PushProperty("requestId", request.Id)) { try { var result = await _predictor.PredictAsync(request); return(Ok(result)); } catch (Exception e) { Console.WriteLine(e); Log.Warning(e, "PredictionController error {request}", request.ToJson()); return(NoContent()); } } }
public void Predict_HMMMultivariateAndFTSESeriesLength1_PredictedOneDay() { var util = new TestDataUtils(); var series = util.GetSvcData(util.FTSEFilePath, new DateTime(2010, 12, 18), new DateTime(2011, 12, 18)); var model = (HiddenMarkovModelMultivariateGaussianDistribution)HiddenMarkovModelFactory.GetModel(new ModelCreationParameters <IMultivariateDistribution>() { NumberOfStates = _NumberOfStates }); model.Normalized = true; model.Train(series, _NumberOfIterations, _LikelihoodTolerance); var request = new PredictionRequest(); request.TrainingSet = series; request.NumberOfDays = 1; var pred = new ViterbiBasedPredictor(); var res = pred.Predict(model, request); Assert.AreEqual(1, res.Predicted.Length); }
public PredictionResult PredictNumberByGrpc([FromBody] PredictionRequest model) { try { var stopWatch = Stopwatch.StartNew(); var imageData = CreateImageDataFromModel(model.ImageData); //Init predict request var request = new PredictRequest() { ModelSpec = new ModelSpec() { Name = "mnist_v1", SignatureName = "serving_default" } }; request.Inputs.Add("flatten_input", TensorBuilder.CreateTensorFromImage(imageData, 255.0f)); //Create grpc request var channel = new Channel(_configuration.GetSection("TfServer")["GrpcServerUrl"], ChannelCredentials.Insecure); var client = new PredictionService.PredictionServiceClient(channel); var predictResponse = client.Predict(request); //Process response var maxValue = predictResponse.Outputs["dense_1"].FloatVal.Max(); var predictedValue = predictResponse.Outputs["dense_1"].FloatVal.IndexOf(maxValue); return(new PredictionResult() { Success = true, Results = predictResponse.Outputs["dense_1"].FloatVal.Select(x => x).ToList(), PredictedValue = predictedValue.ToString(), DebugText = $"Total time: {stopWatch.ElapsedMilliseconds} ms" }); } catch (Exception ex) { return(ErrorResult(ex)); } }
private async Task <PredictionResponse> getLUISPredictionAsync(string query) { using (var client = new LUISRuntimeClient(credentials, new DelegatingHandler[] { }) { Endpoint = _luisPredictionEndpoint }) { var appId = Guid.Parse(_luisAppId); var slotName = "production"; var options = new PredictionRequestOptions() { DatetimeReference = DateTime.Parse("2020-01-01"), PreferExternalEntities = true }; var predictionRequest = new PredictionRequest(query, options); var result = await client.Prediction.GetSlotPredictionAsync(appId, slotName, predictionRequest, true, true, true); return(result); } }
private async void UpdatePredictionAsync() { bool isValid = await ValidateDataAsync(); if (!isValid) { return; } string url = App.Current.Resources["UrlAPI"].ToString(); if (!_apiService.CheckConnection()) { await App.Current.MainPage.DisplayAlert(Languages.Error, Languages.ConnectionError, Languages.Accept); return; } UserResponse user = JsonConvert.DeserializeObject <UserResponse>(Settings.User); TokenResponse token = JsonConvert.DeserializeObject <TokenResponse>(Settings.Token); PredictionRequest request = new PredictionRequest { GoalsLocal = GoalsLocal.Value, GoalsVisitor = GoalsVisitor.Value, MatchId = Match.Id, UserId = new Guid(user.Id), CultureInfo = Languages.Culture }; //manda el post al método predicción Response response = await _apiService.MakePredictionAsync(url, "/api", "/Predictions", request, "bearer", token.Token); if (!response.IsSuccess) { await App.Current.MainPage.DisplayAlert(Languages.Error, response.Message, Languages.Accept); } }
public async Task <List <string> > GetSymbols(dynamic config) { var highestPredictionConfig = config as HighestPredictionConfig; var symbolDifferences = new List <(string, double)>(); foreach (var symbol in highestPredictionConfig.pool.symbols) { var req = new PredictionRequest { Symbol = symbol, TrendLength = highestPredictionConfig.trend_length }; try { var res = _predictorService.Predict(req); var quote = await _datasourceService.GetQuote(symbol); Console.WriteLine($"{symbol}: {res.ValDenorm} vs {quote.latestPrice}"); symbolDifferences.Add((symbol, (res.ValDenorm - quote.latestPrice) / quote.latestPrice)); } catch (Exception e) { Console.WriteLine($"Error getting symbol data: {e}"); } } symbolDifferences.Sort((r1, r2) => r1.Item2.CompareTo(r2.Item2)); // Best performing at start return(symbolDifferences .Where( diff => diff.Item2 >= highestPredictionConfig.filters.percent_change_floor && diff.Item2 <= highestPredictionConfig.filters.percent_change_ceiling ) .Select((r) => r.Item1) .Reverse() .ToList()); }
public static IEnumerable <PredictionRequest> ToPredictionRequests(this BankStatementDownload download) { if (download == null) { return(null); } if (download.Error != null) { return(null); } var list = new List <PredictionRequest>(); foreach (var account in download.FetchAllResponse.Accounts) { foreach (var item in account.StatementData.Details) { var pr = new PredictionRequest { Id = Guid.NewGuid(), Description = item.Text, AccountType = AccountTypeConverter.Convert(account.AccountType), Amount = Convert.ToDouble(item.Amount), Bank = account.Institution, TransactionUtcDate = item.DateObj.Date.UtcDateTime }; list.Add(pr); } } var missing = list.Where(x => string.IsNullOrEmpty(x.Description)); Debug.Assert(!missing.Any()); return(list); }
public async Task <PredictionResponse> QueryAsync(PredictionRequest predictionRequest, CancellationToken cancellationToken) { while (true) { try { this.TraceQueryTarget(); if (this.LuisConfiguration.DirectVersionPublish) { return(await this.RuntimeClient.Prediction.GetVersionPredictionAsync( Guid.Parse(this.LuisConfiguration.AppId), this.LuisConfiguration.VersionId, predictionRequest, verbose : true, log : false, cancellationToken : cancellationToken) .ConfigureAwait(false)); } return(await this.RuntimeClient.Prediction.GetSlotPredictionAsync( Guid.Parse(this.LuisConfiguration.AppId), this.LuisConfiguration.SlotName, predictionRequest, verbose : true, log : false, cancellationToken : cancellationToken) .ConfigureAwait(false)); } catch (ErrorException ex) when(IsTransientStatusCode(ex.Response.StatusCode)) { Logger.LogTrace($"Received HTTP {(int)ex.Response.StatusCode} result from Cognitive Services. Retrying."); await Task.Delay(ThrottleQueryDelay, cancellationToken).ConfigureAwait(false); } } }
private async static void GetPrediction(LUISRuntimeClient cliente, string mensaje) { var kbLUIS = "30018600-f54e-46ce-a650-954172c06484"; var request = new PredictionRequest { Query = mensaje }; var result = await cliente.Prediction.GetSlotPredictionAsync(Guid.Parse(kbLUIS), slotName : "Staging", request); var prediction = result.Prediction; switch (prediction.TopIntent) { case "EnviaCorreo": Console.WriteLine("La intención es enviar correo"); var entities = prediction.Entities; var correo = entities["Correo"]; Console.WriteLine($"Enviando correo a {((JArray)correo)[0]}"); break; default: Console.WriteLine("No se cuál es la intención del usuario"); break; } }
public async Task <IActionResult> PostPrediction([FromBody] PredictionRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } CultureInfo cultureInfo = new CultureInfo(request.CultureInfo); Resource.Culture = cultureInfo; MatchEntity matchEntity = await _context.Matches.FindAsync(request.MatchId); if (matchEntity == null) { return(BadRequest(Resource.MatchDoesntExists)); } if (matchEntity.IsClosed) { return(BadRequest(Resource.MatchAlreadyClosed)); } UserEntity userEntity = await _userHelper.GetUserAsync(request.UserId); if (userEntity == null) { return(BadRequest(Resource.UserDoesntExists)); } if (matchEntity.Date <= DateTime.UtcNow) { return(BadRequest(Resource.MatchAlreadyStarts)); } PredictionEntity predictionEntity = await _context.Predictions .FirstOrDefaultAsync(p => p.User.Id == request.UserId.ToString() && p.Match.Id == request.MatchId); if (predictionEntity == null) { predictionEntity = new PredictionEntity { GoalsLocal = request.GoalsLocal, GoalsVisitor = request.GoalsVisitor, Match = matchEntity, User = userEntity }; _context.Predictions.Add(predictionEntity); } else { predictionEntity.GoalsLocal = request.GoalsLocal; predictionEntity.GoalsVisitor = request.GoalsVisitor; _context.Predictions.Update(predictionEntity); } await _context.SaveChangesAsync(); return(NoContent()); }
public static async Task Main() { // <VariablesYouChange> var key = "REPLACE-WITH-YOUR-AUTHORING-KEY"; var authoringResourceName = "REPLACE-WITH-YOUR-AUTHORING-RESOURCE-NAME"; var predictionResourceName = "REPLACE-WITH-YOUR-PREDICTION-RESOURCE-NAME"; // </VariablesYouChange> // <VariablesYouDontNeedToChangeChange> var authoringEndpoint = String.Format("https://{0}.cognitiveservices.azure.com/", authoringResourceName); var predictionEndpoint = String.Format("https://{0}.cognitiveservices.azure.com/", predictionResourceName); var appName = "Contoso Pizza Company"; var versionId = "0.1"; var intentName = "OrderPizzaIntent"; // </VariablesYouDontNeedToChangeChange> // <AuthoringCreateClient> var credentials = new Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.ApiKeyServiceClientCredentials(key); var client = new LUISAuthoringClient(credentials) { Endpoint = authoringEndpoint }; // </AuthoringCreateClient> // Create app var appId = await CreateApplication(client, appName, versionId); // <AddIntent> await client.Model.AddIntentAsync(appId, versionId, new ModelCreateObject() { Name = intentName }); // </AddIntent> // Add Entities await AddEntities(client, appId, versionId); // Add Labeled example utterance await AddLabeledExample(client, appId, versionId, intentName); // <TrainAppVersion> await client.Train.TrainVersionAsync(appId, versionId); while (true) { var status = await client.Train.GetStatusAsync(appId, versionId); if (status.All(m => m.Details.Status == "Success")) { // Assumes that we never fail, and that eventually we'll always succeed. break; } } // </TrainAppVersion> // <PublishVersion> await client.Apps.PublishAsync(appId, new ApplicationPublishObject { VersionId = versionId, IsStaging = false }); // </PublishVersion> // <PredictionCreateClient> var runtimeClient = new LUISRuntimeClient(credentials) { Endpoint = predictionEndpoint }; // </PredictionCreateClient> // <QueryPredictionEndpoint> // Production == slot name var request = new PredictionRequest { Query = "I want two small pepperoni pizzas with more salsa" }; var prediction = await runtimeClient.Prediction.GetSlotPredictionAsync(appId, "Production", request); Console.Write(JsonConvert.SerializeObject(prediction, Formatting.Indented)); // </QueryPredictionEndpoint> }
public void Prediction_Slot() { UseClientFor(async client => { var utterance = "today this is a test with post"; var slotName = "production"; var requestOptions = new PredictionRequestOptions { DatetimeReference = DateTime.Parse("2019-01-01"), OverridePredictions = true }; var externalResolution = JObject.FromObject(new { text = "post", external = true }); var externalEntities = new[] { new ExternalEntity { EntityName = "simple", StartIndex = 26, EntityLength = 4, Resolution = externalResolution } }; var dynamicLists = new[] { new DynamicList { ListEntityName = "list", RequestLists = new[] { new RequestList { Name = "test", CanonicalForm = "testing", Synonyms = new[] { "this" } } } } }; var predictionRequest = new PredictionRequest { Query = utterance, Options = requestOptions, ExternalEntities = externalEntities, DynamicLists = dynamicLists }; var result = await client.Prediction.GetSlotPredictionAsync( Guid.Parse(appId), slotName, predictionRequest, verbose: true, showAllIntents: true); var prediction = result.Prediction; Assert.Equal(utterance, result.Query); Assert.Equal(utterance, prediction.NormalizedQuery); Assert.Equal("intent", prediction.TopIntent); Assert.Equal(2, prediction.Intents.Count); Assert.Equal(4, prediction.Entities.Count); Assert.Contains("datetimeV2", prediction.Entities.Keys); Assert.Contains("simple", prediction.Entities.Keys); Assert.Contains("list", prediction.Entities.Keys); Assert.Contains("$instance", prediction.Entities.Keys); // Test external resolution var actualResolution = (prediction.Entities["simple"] as JArray).Single(); Assert.True(JToken.DeepEquals(externalResolution, actualResolution)); var topIntent = prediction.Intents[prediction.TopIntent]; Assert.True(topIntent.Score > 0.5); Assert.Equal("positive", prediction.Sentiment.Label); Assert.True(prediction.Sentiment.Score > 0.5); // dispatch var child = topIntent.ChildApp; Assert.Equal(utterance, child.NormalizedQuery); Assert.Equal("None", child.TopIntent); Assert.Equal(1, child.Intents.Count); Assert.Equal(2, child.Entities.Count); Assert.Contains("datetimeV2", child.Entities.Keys); Assert.Contains("$instance", child.Entities.Keys); var dispatchTopIntent = child.Intents[child.TopIntent]; Assert.True(dispatchTopIntent.Score > 0.5); Assert.Equal("positive", child.Sentiment.Label); Assert.True(child.Sentiment.Score > 0.5); }); }
public double GetResult([FromBody] PredictionRequest predictionRequest) { return(winPredictorService.GetResult(predictionRequest)); }
protected override async Task OnMessageActivityAsync(ITurnContext <IMessageActivity> context, CancellationToken cancellationToken) { var message = context.Activity; // To quickly test the bot after deploy to ensure the version we want is available. if (message.Text.ToLower().Equals("bot version")) { var version = typeof(SupportBot).Assembly.GetName().Version; var replyText = $"Art Gallery Support Assistant v{version?.Major}.{version?.Minor}.{version?.Build}.{version?.Revision}"; await context.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken); return; } // ******************************* Cognitive Services - Text Analysis API ******************************* // using var textAnalyticsClient = new TextAnalyticsClient(new TextAnalysisServiceClientCredentials(SubscriptionKeys.TextAnalysisServiceKey)) { Endpoint = "https://eastus.api.cognitive.microsoft.com/" }; var langResult = await textAnalyticsClient.DetectLanguageAsync(false, new LanguageBatchInput(new List <LanguageInput> { new LanguageInput(id: "1", text: message.Text) }), cancellationToken : cancellationToken); await context.TraceActivityAsync("OnMessageActivity Trace", langResult, "LanguageResult", cancellationToken : cancellationToken); var languageCode = string.Empty; foreach (var document in langResult.Documents) { // Pick the language with the highest score var bestLanguage = document.DetectedLanguages?.OrderByDescending(l => l.Score).FirstOrDefault(); if (string.IsNullOrEmpty(languageCode) && bestLanguage != null) { languageCode = bestLanguage.Iso6391Name.ToLower(); await context.TraceActivityAsync("OnMessageActivity Trace", languageCode, "string", cancellationToken : cancellationToken); } } // If we couldn't detect language if (string.IsNullOrEmpty(languageCode)) { var replyText = "We could not determine what language you're using. Please try again."; await context.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken); return; } // ******************************* Cognitive Services - Text Translation API ******************************* // var query = string.Empty; // If the detected language was not English, translate it before sending to LUIS if (languageCode != "en") { try { using var translationClient = new TextTranslationServiceClient(SubscriptionKeys.TextTranslationServiceKey); var result = await translationClient.TranslateAsync(message.Text, "en"); var translatedQuery = result?.Translations?.FirstOrDefault()?.Text; if (!string.IsNullOrEmpty(translatedQuery)) { query = translatedQuery; } } catch (Exception ex) { var replyText = $"RespondWithTranslatedReply Exception: {ex.Message}"; await context.SendActivityAsync(MessageFactory.Text(replyText, replyText), cancellationToken); } } else { query = message.Text; } // ******************************* Cognitive Services - LUIS (Natural Language Understanding) API ******************************* // using var luisClient = new LUISRuntimeClient(new ApiKeyServiceClientCredentials(SubscriptionKeys.LuisPredictionKey)); luisClient.Endpoint = SubscriptionKeys.LuisEndpoint; // Prepare a prediction request var predictionRequest = new PredictionRequest { Query = query }; // Request a prediction, returns a PredictionResponse var predictionResponse = await luisClient.Prediction.GetSlotPredictionAsync( Guid.Parse(SubscriptionKeys.LuisAppId), "production", predictionRequest, verbose : true, showAllIntents : true, log : true, cancellationToken : cancellationToken); // You will get a full list of intents. For the purposes of this demo, we'll just use the highest scoring intent. var topScoringIntent = predictionResponse.Prediction.TopIntent; // Respond to the user depending on the detected intent of their query var respondedToQuery = await RespondWithEnglishAsync(context, topScoringIntent, languageCode, cancellationToken); // ******************************* Cognitive Services - Sentiment Analysis ******************************* // // Only evaluate sentiment if we've given a meaningful reply (and not connection or service error messages). if (respondedToQuery) { // Use Text Analytics Sentiment analysis var sentimentResult = await textAnalyticsClient.SentimentAsync( multiLanguageBatchInput : new MultiLanguageBatchInput(new List <MultiLanguageInput> { new MultiLanguageInput(id: "1", text: query, language: languageCode) }), cancellationToken : cancellationToken); if (sentimentResult?.Documents?.Count > 0) { await context.TraceActivityAsync("SentimentAsync Trace", sentimentResult.Documents[0], "SentimentBatchResultItem", cancellationToken : cancellationToken); SentimentBatchResultItem sentimentItem = sentimentResult.Documents[0]; // Use the sentiment score to determine if we need to react, the range is 0 (angriest) to 1 (happiest) await EvaluateAndRespondToSentimentAsync(context, sentimentItem, languageCode, cancellationToken); } } }
/// <summary> /// Gets the predictions for an application version. /// </summary> /// <param name='appId'> /// The application ID. /// </param> /// <param name='versionId'> /// The application version ID. /// </param> /// <param name='predictionRequest'> /// The prediction request parameters. /// </param> /// <param name='verbose'> /// Indicates whether to get extra metadata for the entities predictions or /// not. /// </param> /// <param name='showAllIntents'> /// Indicates whether to return all the intents in the response or just the top /// intent. /// </param> /// <param name='log'> /// Indicates whether to log the endpoint query or not. /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <exception cref="ErrorException"> /// Thrown when the operation returned an invalid status code /// </exception> /// <exception cref="SerializationException"> /// Thrown when unable to deserialize the response /// </exception> /// <exception cref="ValidationException"> /// Thrown when a required parameter is null /// </exception> /// <exception cref="System.ArgumentNullException"> /// Thrown when a required parameter is null /// </exception> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <HttpOperationResponse <PredictionResponse> > GetVersionPredictionWithHttpMessagesAsync(System.Guid appId, string versionId, PredictionRequest predictionRequest, bool?verbose = default(bool?), bool?showAllIntents = default(bool?), bool?log = default(bool?), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (Client.Endpoint == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.Endpoint"); } if (versionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "versionId"); } if (predictionRequest == null) { throw new ValidationException(ValidationRules.CannotBeNull, "predictionRequest"); } if (predictionRequest != null) { predictionRequest.Validate(); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("appId", appId); tracingParameters.Add("versionId", versionId); tracingParameters.Add("verbose", verbose); tracingParameters.Add("showAllIntents", showAllIntents); tracingParameters.Add("log", log); tracingParameters.Add("predictionRequest", predictionRequest); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "GetVersionPrediction", tracingParameters); } // Construct URL var _baseUrl = Client.BaseUri; var _url = _baseUrl + (_baseUrl.EndsWith("/") ? "" : "/") + "apps/{appId}/versions/{versionId}/predict"; _url = _url.Replace("{Endpoint}", Client.Endpoint); _url = _url.Replace("{appId}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(appId, Client.SerializationSettings).Trim('"'))); _url = _url.Replace("{versionId}", System.Uri.EscapeDataString(versionId)); List <string> _queryParameters = new List <string>(); if (verbose != null) { _queryParameters.Add(string.Format("verbose={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(verbose, Client.SerializationSettings).Trim('"')))); } if (showAllIntents != null) { _queryParameters.Add(string.Format("show-all-intents={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(showAllIntents, Client.SerializationSettings).Trim('"')))); } if (log != null) { _queryParameters.Add(string.Format("log={0}", System.Uri.EscapeDataString(Rest.Serialization.SafeJsonConvert.SerializeObject(log, Client.SerializationSettings).Trim('"')))); } if (_queryParameters.Count > 0) { _url += "?" + string.Join("&", _queryParameters); } // Create HTTP transport objects var _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("POST"); _httpRequest.RequestUri = new System.Uri(_url); // Set Headers if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (predictionRequest != null) { _requestContent = Rest.Serialization.SafeJsonConvert.SerializeObject(predictionRequest, Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8); _httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200) { var ex = new ErrorException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); Error _errorBody = Rest.Serialization.SafeJsonConvert.DeserializeObject <Error>(_responseContent, Client.DeserializationSettings); if (_errorBody != null) { ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new HttpOperationResponse <PredictionResponse>(); _result.Request = _httpRequest; _result.Response = _httpResponse; // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = Rest.Serialization.SafeJsonConvert.DeserializeObject <PredictionResponse>(_responseContent, Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
public async Task <PredictionResponse> Predict(string query) { PredictionRequest predictionRequest = new PredictionRequest(query); return(await _recognizer.Prediction.GetSlotPredictionAsync(appId, "Production", predictionRequest, true, true)); }
public async Task <IHttpActionResult> GetPredictions(PredictionRequest predictionRequest) { return(this.Json(await this.client.Predict(await this.requestPrepareService.Prepare(predictionRequest)))); }
public async Task <SpeechPredictionResponse> RecognizeSpeechAsync(string speechFile, PredictionRequest predictionRequest, CancellationToken cancellationToken) { if (this.LuisConfiguration.SpeechKey == null) { throw new InvalidOperationException("Must provide speech key to perform speech intent recognition."); } var request = (HttpWebRequest)WebRequest.Create(this.LuisConfiguration.SpeechEndpoint); request.Method = "POST"; request.ContentType = "audio/wav; codec=audio/pcm; samplerate=16000"; request.ServicePoint.Expect100Continue = true; request.SendChunked = true; request.Accept = "application/json"; request.Headers.Add("Ocp-Apim-Subscription-Key", this.LuisConfiguration.SpeechKey); JObject responseJson; using (var fileStream = File.OpenRead(speechFile)) using (var requestStream = await request.GetRequestStreamAsync().ConfigureAwait(false)) { await fileStream.CopyToAsync(requestStream).ConfigureAwait(false); using (var response = await request.GetResponseAsync().ConfigureAwait(false)) using (var streamReader = new StreamReader(response.GetResponseStream())) { var responseText = await streamReader.ReadToEndAsync().ConfigureAwait(false); responseJson = JObject.Parse(responseText); } } if (responseJson.Value <string>("RecognitionStatus") != "Success") { throw new InvalidOperationException($"Received error from LUIS speech service: {responseJson}"); } var speechMatch = responseJson["NBest"].OrderByDescending(t => t.Value <double?>("Confidence") ?? 0.0).First(); var text = speechMatch.Value <string>("Display"); var textScore = speechMatch.Value <double?>("Confidence"); var speechPredictionRequest = new PredictionRequest { Query = text, DynamicLists = predictionRequest?.DynamicLists, ExternalEntities = predictionRequest?.ExternalEntities, Options = predictionRequest?.Options, }; var predictionResponse = await this.QueryAsync(speechPredictionRequest, cancellationToken).ConfigureAwait(false); return(new SpeechPredictionResponse(predictionResponse, textScore)); }
public PredictionResult PredictNumber([FromBody] PredictionRequest model) { try { //Load Bitmap from input base64 Bitmap convertedImage = null; using (var str = new MemoryStream(Convert.FromBase64String(model.ImageData))) { str.Position = 0; using (var bmp = Image.FromStream(str)) { //Resize image and convert to rgb24 convertedImage = ImageUtils.ResizeImage(bmp, 28, 28, 280, 280); } } //Create channel var channel = new Channel(_configuration.GetSection("TfServer")["ServerUrl"], ChannelCredentials.Insecure); var client = new PredictionService.PredictionServiceClient(channel); //Init predict request var request = new PredictRequest() { ModelSpec = new ModelSpec() { Name = "mnist", SignatureName = ModelMethodClasses.PredictImages } }; //Convert image to 28x28 8bit per pixel image data array var imageData = ImageUtils.ConvertImageStreamToDimArrays(convertedImage); var textDebug = TextUtils.RenderImageData(imageData); //add image tensor request.Inputs.Add("images", TensorBuilder.CreateTensorFromImage(imageData, 255.0f)); //add keep_prob tensor request.Inputs.Add("keep_prob", TensorBuilder.CreateTensor(1.0f)); var predictResponse = client.Predict(request); var maxValue = predictResponse.Outputs["scores"].FloatVal.Max(); var predictedValue = predictResponse.Outputs["scores"].FloatVal.IndexOf(maxValue); return(new PredictionResult() { Success = true, Results = predictResponse.Outputs["scores"].FloatVal.Select(x => x).ToList(), PredictedNumber = predictedValue, DebugText = textDebug }); } catch (Exception ex) { return(new PredictionResult() { Success = false, ErrorMessage = ex.ToString() }); } }
// It's always a good idea to access services in an async fashion public static async Task Main() { var authoringEndpoint = String.Format("https://{0}.cognitiveservices.azure.com/", AUTHORING_RESOURCE_NAME); var predictionEndpoint = String.Format("https://{0}.cognitiveservices.azure.com/", PREDICTION_RESOURCE_NAME); var appName = "Contoso Pizza Company"; var versionId = "0.1"; var intentName = "OrderPizza"; // Authenticate the client Console.WriteLine("Authenticating the client..."); var credentials = new Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.ApiKeyServiceClientCredentials(AUTHORING_KEY); var client = new LUISAuthoringClient(credentials) { Endpoint = authoringEndpoint }; // Create a LUIS app var newApp = new ApplicationCreateObject { Culture = "en-us", Name = appName, InitialVersionId = versionId }; Console.WriteLine("Creating a LUIS app..."); var appId = await client.Apps.AddAsync(newApp); // Create intent for the app Console.WriteLine("Creating intent for the app..."); await client.Model.AddIntentAsync(appId, versionId, new ModelCreateObject() { Name = intentName }); // Create entities for the app Console.WriteLine("Creating entities for the app..."); // Add Prebuilt entity await client.Model.AddPrebuiltAsync(appId, versionId, new[] { "number" }); // Define ml entity with children and grandchildren var mlEntityDefinition = new EntityModelCreateObject { Name = "Pizza order", Children = new[] { new ChildEntityModelCreateObject { Name = "Pizza", Children = new[] { new ChildEntityModelCreateObject { Name = "Quantity" }, new ChildEntityModelCreateObject { Name = "Type" }, new ChildEntityModelCreateObject { Name = "Size" } } }, new ChildEntityModelCreateObject { Name = "Toppings", Children = new[] { new ChildEntityModelCreateObject { Name = "Type" }, new ChildEntityModelCreateObject { Name = "Quantity" } } } } }; // Add ML entity var mlEntityId = await client.Model.AddEntityAsync(appId, versionId, mlEntityDefinition);; // Add phraselist feature var phraselistId = await client.Features.AddPhraseListAsync(appId, versionId, new PhraselistCreateObject { EnabledForAllModels = false, IsExchangeable = true, Name = "QuantityPhraselist", Phrases = "few,more,extra" }); // Get entity and subentities var model = await client.Model.GetEntityAsync(appId, versionId, mlEntityId); var toppingQuantityId = GetModelGrandchild(model, "Toppings", "Quantity"); var pizzaQuantityId = GetModelGrandchild(model, "Pizza", "Quantity"); // add model as feature to subentity model await client.Features.AddEntityFeatureAsync(appId, versionId, pizzaQuantityId, new ModelFeatureInformation { ModelName = "number", IsRequired = true }); await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { ModelName = "number" }); // add phrase list as feature to subentity model await client.Features.AddEntityFeatureAsync(appId, versionId, toppingQuantityId, new ModelFeatureInformation { FeatureName = "QuantityPhraselist" }); // Add example utterance to intent Console.WriteLine("Adding example utterance to intent..."); // Define labeled example var labeledExampleUtteranceWithMLEntity = new ExampleLabelObject { Text = "I want two small seafood pizzas with extra cheese.", IntentName = intentName, EntityLabels = new[] { new EntityLabelObject { StartCharIndex = 7, EndCharIndex = 48, EntityName = "Pizza order", Children = new[] { new EntityLabelObject { StartCharIndex = 7, EndCharIndex = 30, EntityName = "Pizza", Children = new[] { new EntityLabelObject { StartCharIndex = 7, EndCharIndex = 9, EntityName = "Quantity" }, new EntityLabelObject { StartCharIndex = 11, EndCharIndex = 15, EntityName = "Size" }, new EntityLabelObject { StartCharIndex = 17, EndCharIndex = 23, EntityName = "Type" } } }, new EntityLabelObject { StartCharIndex = 37, EndCharIndex = 48, EntityName = "Toppings", Children = new[] { new EntityLabelObject { StartCharIndex = 37, EndCharIndex = 41, EntityName = "Quantity" }, new EntityLabelObject { StartCharIndex = 43, EndCharIndex = 48, EntityName = "Type" } } } } }, } }; // Add an example for the entity. // Enable nested children to allow using multiple models with the same name. // The quantity subentity and the phraselist could have the same exact name if this is set to True await client.Examples.AddAsync(appId, versionId, labeledExampleUtteranceWithMLEntity, enableNestedChildren : true); // Train the app Console.WriteLine("Training the app..."); await client.Train.TrainVersionAsync(appId, versionId); while (true) { var status = await client.Train.GetStatusAsync(appId, versionId); if (status.All(m => m.Details.Status == "Success")) { // Assumes that we never fail, and that eventually we'll always succeed. break; } } // Publish app to production slot Console.WriteLine("Publishing the app to production slot..."); await client.Apps.PublishAsync(appId, new ApplicationPublishObject { VersionId = versionId, IsStaging = false }); // Authenticate the prediction runtime client Console.WriteLine("Authenticating the prediction client..."); credentials = new Microsoft.Azure.CognitiveServices.Language.LUIS.Authoring.ApiKeyServiceClientCredentials(PREDICTION_KEY); var runtimeClient = new LUISRuntimeClient(credentials) { Endpoint = predictionEndpoint }; // Get prediction from runtime // Production == slot name Console.WriteLine("Getting prediction..."); var request = new PredictionRequest { Query = "I want two small pepperoni pizzas with more salsa" }; var prediction = await runtimeClient.Prediction.GetSlotPredictionAsync(appId, "Production", request); Console.Write(JsonConvert.SerializeObject(prediction, Formatting.Indented)); }
public async Task <Response> MakePredictionAsync(string urlBase, string servicePrefix, string controller, PredictionRequest predictionRequest, string tokenType, string accessToken) { try { string request = JsonConvert.SerializeObject(predictionRequest); StringContent content = new StringContent(request, Encoding.UTF8, "application/json"); HttpClient client = new HttpClient { BaseAddress = new Uri(urlBase) }; client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(tokenType, accessToken); string url = $"{servicePrefix}{controller}"; HttpResponseMessage response = await client.PostAsync(url, content); string result = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { return(new Response { IsSuccess = false, Message = result }); } return(new Response { IsSuccess = true }); } catch (Exception ex) { return(new Response { IsSuccess = false, Message = ex.Message }); } }
public PredictionResponse(PredictionRequest prq, string ClassName, float Proba) : base(prq.FilePath, prq.Image) { this.ClassName = ClassName; this.Proba = Proba; }
/// <summary> /// Gets the predictions for an application slot. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='appId'> /// The application ID. /// </param> /// <param name='slotName'> /// The application slot name. /// </param> /// <param name='predictionRequest'> /// The prediction request parameters. /// </param> /// <param name='verbose'> /// Indicates whether to get extra metadata for the entities predictions or /// not. /// </param> /// <param name='showAllIntents'> /// Indicates whether to return all the intents in the response or just the top /// intent. /// </param> /// <param name='log'> /// Indicates whether to log the endpoint query or not. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <PredictionResponse> GetSlotPredictionAsync(this IPredictionOperations operations, System.Guid appId, string slotName, PredictionRequest predictionRequest, bool?verbose = default(bool?), bool?showAllIntents = default(bool?), bool?log = default(bool?), CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.GetSlotPredictionWithHttpMessagesAsync(appId, slotName, predictionRequest, verbose, showAllIntents, log, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public async Task <IActionResult> PostPrediction([FromBody] PredictionRequest request) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } MatchEntity matchEntity = await _context.Matches.FindAsync(request.MatchId); if (matchEntity == null) { return(BadRequest("Este partido no existe.")); } if (matchEntity.IsClosed) { return(BadRequest("Este partido está cerrado.")); } User userEntity = await _userHelper.GetUserAsync(request.UserId); if (userEntity == null) { return(BadRequest("Este usuario no existe.")); } if (matchEntity.Date <= DateTime.UtcNow) { return(BadRequest("Este partido ya empezó.")); } PredictionEntity predictionEntity = await _context.Predictions .FirstOrDefaultAsync(p => p.Player.User.Id == request.UserId.ToString() && p.Match.Id == request.MatchId); if (predictionEntity == null) { //var playerResponse = JsonConvert.DeserializeObject<PlayerResponse>(Settings.Player); var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == request.UserId.ToString()); var player = await _context.Players.FirstOrDefaultAsync(u => u.User.Id == user.Id); predictionEntity = new PredictionEntity { GoalsLocal = request.GoalsLocal, GoalsVisitor = request.GoalsVisitor, Match = matchEntity, Player = player }; _context.Predictions.Add(predictionEntity); } else { predictionEntity.GoalsLocal = request.GoalsLocal; predictionEntity.GoalsVisitor = request.GoalsVisitor; _context.Predictions.Update(predictionEntity); } await _context.SaveChangesAsync(); return(NoContent()); }