public async Task <RecommendationsResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest) { #region Create seed lists if null if (recommendationRequest.SeedArtists == null) { recommendationRequest.SeedArtists = new List <string>(); } if (recommendationRequest.SeedGenres == null) { recommendationRequest.SeedGenres = new List <string>(); } if (recommendationRequest.SeedTracks == null) { recommendationRequest.SeedTracks = new List <string>(); } #endregion Create seed lists if null await FillSeedTracks(recommendationRequest); string query = FormatRecommendationQuery(recommendationRequest); return(await _requestHandler.GetTrackRecommendations(query)); }
private async Task FillSeedTracks(RecommendationRequest recommendationRequest) { List <TracksSearchResponse> tracksToAdd = new List <TracksSearchResponse>(); if (recommendationRequest.SeedPlaylists != null && recommendationRequest.SeedPlaylists.Any()) //If the user has selected categories, choose tracks according to those { foreach (var playlist in recommendationRequest.SeedPlaylists) { tracksToAdd.Add(await _requestHandler.GetPlaylistTracksAsync(playlist)); } } else // else take user top tracks { tracksToAdd.Add(await _requestHandler.GetUserTopTracksAsync()); } int tracksFromEach = (5 - GetSeedCount(recommendationRequest)) / tracksToAdd.Count(); if (tracksFromEach < 1) { tracksFromEach = 1; } foreach (var tracksSearch in tracksToAdd) { foreach (var track in tracksSearch.Tracks.Take(tracksFromEach)) { if (GetSeedCount(recommendationRequest) < 5) { recommendationRequest.SeedTracks.Add(track.Id); } } } }
public async Task <IActionResult> CategoryPlaylists(RecommendationRequest request) { if (_spotifyService == null) { _spotifyService = await GetSpotifyServiceAsync(); } List <Playlist> playlists = new List <Playlist>(); if (request.SeedCategories == null) { return(PartialView(playlists)); } foreach (var category in request.SeedCategories) { var pr = await _spotifyService.GetCategoryPlaylists(category); playlists.AddRange(pr.PlaylistsData.Playlists); } if (playlists.Any()) { return(PartialView(playlists)); } else { return(BadRequest("Not found.")); } }
public static (bool, string) IsValid(RecommendationRequest req) { if (req.Score > 0 && req.Score <= 10) { return(true, null); } return(false, "Score must be between 0 and 10"); }
public async Task Post(RecommendationRequest req) { string url = $"{_baseUrl}/Recommendation/"; using (HttpClient httpClient = new HttpClient()) { StringContent content = new StringContent(JsonConvert.SerializeObject(req), Encoding.UTF8, "application/json"); await httpClient.PostAsync(url, content); } }
private SeedData ProcessRequest(RecommendationRequest recommendationRequest) { var seedData = new SeedData(); foreach (var skill in recommendationRequest.ProjectSkills) { var propertyInfo = seedData.GetType().GetProperty(skill.Tag.ToLower()); propertyInfo.SetValue(seedData, Convert.ChangeType(skill.Weight, propertyInfo.PropertyType), null); } return(seedData); }
private int GetSeedCount(RecommendationRequest recommendationRequest) { int result = 0; result += recommendationRequest.SeedArtists != null?recommendationRequest.SeedArtists.Count() : 0; result += recommendationRequest.SeedGenres != null?recommendationRequest.SeedGenres.Count() : 0; result += recommendationRequest.SeedTracks != null?recommendationRequest.SeedTracks.Count() : 0; return(result); }
public virtual async System.Threading.Tasks.Task <IEnumerable <RecommendationResult> > GetRecommendationContent(HttpContextBase httpContext, ContentRecommendationViewModel requestModel) { var recommendationRequest = new RecommendationRequest { siteId = requestModel.SiteId, context = new Context { contentId = requestModel.ContentId, languageId = requestModel.LanguageId }, numberOfRecommendations = requestModel.NumberOfRecommendations == 0 ? 3 : requestModel.NumberOfRecommendations }; return(await _personalizationRecommendationService.Get(httpContext, recommendationRequest)); }
public Task <RecommendationResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest) { var predictionData = PredictValue(recommendationRequest); var candidates = predictionData.userData .Where(p => p.SelectedClusterId.Equals(predictionData.prediction.SelectedClusterId)) .OrderBy(x => x.Distance[x.SelectedClusterId]) .Select(Candidate.FromPrediction) .ToList(); return(Task.FromResult(new RecommendationResponse { Matches = candidates })); }
public async Task <bool> RecommendMovie(RecommendationRequest recommmendationRequest) { var response = GetMovieDetailResponse(recommmendationRequest.MovieId); if (response.Data != null) { string htmlMessage = HtmlHelper.ConvertToHtml(response.Data); bool isSent = await _emailService.Send(htmlMessage, _appConfiguration.SmtpInfo.subject, new List <string> { recommmendationRequest.Email }); return(isSent); } return(false); }
public async Task <ActionResult> Post([FromBody] RecommendationRequest req) { var isValid = RecommendationValidator.IsValid(req); if (isValid.Item1) { await _bingeWatchService.UpdateContentWatchingStatus(req.UserId, req.ContentId, Enums.ContentWatchingStatus.Finished); await _bingeWatchService.UpdateContentRecomendation(req.ContentId, req.UserId, req.Score); return(Ok()); } return(BadRequest(isValid.Item2)); }
public Task <RecommendationResponse> GetRecommendationsAsync(RecommendationRequest recommendationRequest) { var candidates = new List <Candidate> { new Candidate { UserId = "mgonzalez", Name = "Marlon", LastName = "González", Score = _random.NextDouble() }, new Candidate { UserId = "yvaldes", Name = "Yanara", LastName = "Valdes", Score = _random.NextDouble() }, new Candidate { UserId = "dalvarez", Name = "Delia", LastName = "Álvarez", Score = _random.NextDouble() }, new Candidate { UserId = "wclaro", Name = "Willian", LastName = "Claro", Score = _random.NextDouble() }, new Candidate { UserId = "ktamayo", Name = "Karel", LastName = "Tamayo", Score = _random.NextDouble() } } .OrderByDescending(x => x.Score); return(Task.FromResult(new RecommendationResponse { Matches = candidates })); }
/// <summary> /// Constructor /// </summary> /// <param name="client">(Required) Spotify Sdk Client</param> /// <param name="trackType">(Required) Track Type</param> /// <param name="value">(Required) Only for TrackType.Search - Track Search Term, TrackType.Album - Spotify Album Id and TrackType.Artist - Spotify Artist Id</param> /// <param name="multipleTrackIds">(Required) Only for TrackType.Multiple - Multiple Spotify Track Ids</param> /// <param name="searchIsExternal">(Optional) Only for TrackType.Search, If true the response will include any relevant audio content that is hosted externally</param> /// <param name="recommendation">(Optional) Only for TrackType.Recommended - Recommendation Request</param> public ListTrackViewModel( ISpotifySdkClient client, TrackType trackType, string value = null, List <string> multipleTrackIds = null, bool?searchIsExternal = null, RecommendationRequest recommendation = null) : base(client, new TracksRequest() { TrackType = trackType, Value = value, MultipleTrackIds = multipleTrackIds, SearchIsExternal = searchIsExternal, Recommendation = recommendation }) { }
public async Task <IActionResult> RecommendMovie([FromBody] RecommendationRequest recommendRquest) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState.Values)); } bool isSent = await _movieService.RecommendMovie(recommendRquest); return(Ok(isSent)); } catch (System.Exception ex) { _logger.LogError(ex, ex.Message); return(StatusCode((int)HttpStatusCode.InternalServerError)); } }
public async Task <ActionResult> Post(RecommendationRequest req) { string url = $"{_baseUrl}/Recommendation/"; using (HttpClient httpClient = new HttpClient()) { StringContent content = new StringContent(JsonConvert.SerializeObject(req), Encoding.UTF8, "application/json"); var res = await httpClient.PostAsync(url, content); if (!res.IsSuccessStatusCode) { var response = await res.Content.ReadAsStringAsync(); return(new BadRequestObjectResult(response)); } } return(new OkResult()); }
/// <summary> /// Get Recommendations /// </summary> /// <param name="client">Spotify Sdk Client</param> /// <param name="mapper">Mapper</param> /// <param name="country">Country</param> /// <param name="recommendationRequest">Recommendation Request</param> /// <returns>Navigation Response of Track Response</returns> public static async Task <NavigationResponse <TrackResponse> > GetRecommendationsAsync( this ISpotifyClient client, IMapper mapper, string country, RecommendationRequest recommendationRequest) { var recommended = await client.LookupRecommendationsAsync( seedArtists : recommendationRequest?.SeedArtistIds, seedGenres : Helpers.GetListFromString(recommendationRequest?.SeedGenre) ?? recommendationRequest?.SeedGenres, seedTracks : recommendationRequest?.SeedTrackIds, limit : recommendationRequest?.TargetTotal, market : country, minTuneableTrack : mapper.Map(recommendationRequest?.MinimumTuneableTrack), maxTuneableTrack : mapper.Map(recommendationRequest?.MaximumTuneableTrack), targetTuneableTrack : mapper.Map(recommendationRequest?.TargetTuneableTrack)); return(mapper.MapFromRecommendationResponse(recommended)); }
public async Task <IActionResult> Recommendations(RecommendationRequest request) { if (_spotifyService == null) { _spotifyService = await GetSpotifyServiceAsync(); } var recommendations = await _spotifyService.GetRecommendationsAsync(request); if (recommendations != null) { var recommendedTracks = recommendations.Tracks; return(PartialView(recommendedTracks)); } else { return(BadRequest("Not found.")); } }
/// <summary> /// Performs recommendation for specified users. /// </summary> /// <param name="model">Model instance.</param> /// <param name="users">Users to get recommendation.</param> /// <param name="recordsCount">Number of items to recommend for each user.</param> /// <param name="filterItems">Items to filter.</param> /// <param name="filterItemsMode">Mode of filter,</param> /// <param name="filterAlreadyInteractedItems">Filter out already interacted items from prediction.</param> /// <param name="userItems">Updated users items.</param> /// <param name="recalculateUsers">Recalculate users recommendations using <see cref="userItems"/></param> public RecommendationResponse Recommend(MLModelConfig model, List <Guid> users, int recordsCount = 10, List <Guid> filterItems = null, RecommendationFilterItemsMode filterItemsMode = RecommendationFilterItemsMode.White, bool filterAlreadyInteractedItems = true, List <DatasetValue> userItems = null, bool recalculateUsers = false) { RecommendationRequest request = new RecommendationRequest { ModelId = model.ModelInstanceUId, PredictionParams = new RecommendationInput { UserIds = users.Select(e => e.ToString()).ToList(), PredictionRecordsCount = recordsCount, FilterItems = filterItems?.Select(e => e.ToString()).ToList() ?? new List <string>(), FilterItemsMode = filterItemsMode.ToString().ToLowerInvariant(), FilterAlreadyInteractedItems = filterAlreadyInteractedItems, UserItems = userItems, RecalculateUsers = recalculateUsers } }; return(Post <RecommendationResponse>(model.PredictionEndpoint, request, RecommendationTimeoutSec)); }
public string GetRecommendations(ApiRecommendationRequest request) { _recommendationService = ServiceLocator.Current.GetInstance <IRecommendationService>(); var rRequest = new RecommendationRequest { siteId = request.siteId, context = new Context { contentId = request.contentId, languageId = request.languageId }, numberOfRecommendations = request.numberOfRecommendations == 0 ? 3 : request.numberOfRecommendations }; var context = Request.Properties["MS_HttpContext"] as HttpContextWrapper; var task = Task.Run(async() => await _recommendationService.Get(context, rRequest)); var recommendationResults = task.Result; var htmlResult = new StringBuilder(); if (recommendationResults != null) { htmlResult.Append("<h2>Recommendations</h2>"); htmlResult.Append("<ul>"); var urlResolver = ServiceLocator.Current.GetInstance <IUrlResolver>(); foreach (var result in recommendationResults) { var friendlyUrl = urlResolver.GetUrl(result.Content.ContentLink); htmlResult.Append($"<li><a onmouseup=\"Misc && Misc.setCookie('EPiServer_CMS_RecommendationId', '{result.RecommendationId}', 60);\" href=\"{friendlyUrl}\">{result.Content.Name}</a></li>"); } htmlResult.Append("</ul>"); } return(htmlResult.ToString()); }
private (ClusteringPrediction[] userData, ClusteringPrediction prediction) PredictValue(RecommendationRequest recommendationRequest) { string modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "trainedModel.zip"); var inputPath = Path.Combine(Environment.CurrentDirectory, "Data", "user-languages.csv"); try { var data = MLContext.Data.LoadFromTextFile <SeedData>( path: inputPath, hasHeader: true, separatorChar: ','); // Load data preparation pipeline and trained model out dataPrepPipelineSchema); ITransformer trainedModel = MLContext.Model.Load(modelPath, out var modelSchema); var transformedDataView = trainedModel.Transform(data); var predictionEngine = MLContext.Model.CreatePredictionEngine <SeedData, ClusteringPrediction>(trainedModel); var prediction = predictionEngine.Predict(ProcessRequest(recommendationRequest)); ClusteringPrediction[] userData = MLContext.Data .CreateEnumerable <ClusteringPrediction>(transformedDataView, false) .ToArray(); //Plot/paint the clusters in a chart and open it with the by-default image-tool in Windows //var plotLocation = Path.Combine(Directory.GetParent(modelPath).FullName, "userskillclusters.svg"); //SaveSegmentationPlotChart(userData, plotLocation); return(userData, prediction); } catch (Exception ex) { throw ex; } }
private string FormatRecommendationQuery(RecommendationRequest recommendationRequest) { StringBuilder stringBuilder = new StringBuilder("?"); var c = System.Globalization.CultureInfo.InvariantCulture; //Add all parameters for the reccomendation request #region Build query if (recommendationRequest.SeedArtists.Any()) { stringBuilder.Append("seed_artists="); foreach (var artist in recommendationRequest.SeedArtists) { stringBuilder.Append(artist); if (artist != recommendationRequest.SeedArtists.Last()) { stringBuilder.Append(","); } } } if (recommendationRequest.SeedGenres.Any()) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("seed_genres="); foreach (var genre in recommendationRequest.SeedGenres) { stringBuilder.Append(genre); if (genre != recommendationRequest.SeedGenres.Last()) { stringBuilder.Append(","); } } } if (recommendationRequest.SeedTracks.Any()) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("seed_tracks="); foreach (var track in recommendationRequest.SeedTracks) { stringBuilder.Append(track); if (track != recommendationRequest.SeedTracks.Last()) { stringBuilder.Append(","); } } } if (recommendationRequest.MinDanceAbility > 0) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("min_danceability="); stringBuilder.Append((recommendationRequest.MinDanceAbility / 100).ToString("0.00", c)); } if (recommendationRequest.MaxDanceAbility > 0) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("max_danceability="); stringBuilder.Append((recommendationRequest.MaxDanceAbility / 100).ToString("0.00", c)); } if (recommendationRequest.TargetDanceAbility > 0) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("target_danceability="); stringBuilder.Append((recommendationRequest.TargetDanceAbility / 100).ToString("0.00", c)); } if (recommendationRequest.TargetTempo > 60) { if (stringBuilder.Length > 1) { stringBuilder.Append("&"); } stringBuilder.Append("target_tempo="); stringBuilder.Append((recommendationRequest.TargetTempo).ToString("0.00", c)); } #endregion Build query return(stringBuilder.ToString()); }
/// <inheritdoc /> public Task <RecommendedContentItem[]> GetRecommendationsAsync(RecommendationRequest request) { return(PostAsync <RecommendedContentItem[]>($"{RecommendationEndpointRoutePrefix}/items", JsonConvert.SerializeObject(request))); }