public void GetRecommendationsUsingUserId()
{
const string baseFolder = nameof(GetRecommendationsUsingUserId);
Directory.CreateDirectory(baseFolder);
var generator = new ModelTrainingFilesGenerator(8);
string usageFileFolderPath = Path.Combine(baseFolder, "usage");
Directory.CreateDirectory(usageFileFolderPath);
IList <string> warmItems = generator.CreateUsageFile(Path.Combine(usageFileFolderPath, "usage.csv"), 1000);
var trainingParameters = ModelTrainingParameters.Default;
trainingParameters.EnableBackfilling = false;
trainingParameters.EnableUserToItemRecommendations = true;
trainingParameters.AllowSeedItemsInRecommendations = true;
Dictionary <string, Document> userHistory = null;
IDocumentStore documentStore = Substitute.For <IDocumentStore>();
documentStore.AddDocumentsAsync(Arg.Any <string>(), Arg.Any <IEnumerable <Document> >(),
Arg.Any <CancellationToken>())
.Returns(info =>
{
userHistory = info.Arg <IEnumerable <Document> >().ToDictionary(doc => doc.Id);
return(Task.FromResult(userHistory.Count));
});
documentStore.GetDocument(Arg.Any <string>(), Arg.Any <string>())
.Returns(info => userHistory?[info.ArgAt <string>(1)]);
var trainer = new ModelTrainer(documentStore: documentStore);
ModelTrainResult result = trainer.TrainModel(trainingParameters, usageFileFolderPath, null, null, CancellationToken.None);
Assert.IsNotNull(result);
Assert.IsTrue(result.IsCompletedSuccessfuly);
var recommender = new Recommender(result.Model, documentStore);
var items = new List <UsageEvent>
{
new UsageEvent
{
ItemId = warmItems.First(),
EventType = UsageEventType.Click,
Timestamp = DateTime.UtcNow
}
};
string userId = generator.Users.FirstOrDefault();
IList <Recommendation> recommendations = recommender.GetRecommendations(items, userId, 3);
// expect the document store to be called once with the provided user id
documentStore.Received(1).GetDocument(Arg.Any <string>(), userId);
Assert.IsNotNull(recommendations);
Assert.IsTrue(recommendations.Any());
Assert.IsTrue(recommendations.All(r => r != null));
Assert.IsTrue(recommendations.All(r => r.Score > 0 && !string.IsNullOrWhiteSpace(r.RecommendedItemId)));
}
public async Task Init()
{
var hotel = await _hotelService.GetById <HotelDTO>(_hotelId);
Hotel = hotel;
var ratingData = await _ratingService.Get <List <RatingDTO> >(new RatingSearchRequest { HotelId = hotel.Id });
Recommender recommender = new Recommender(hotel.Id, hotel.CityId);
var recHotels = await recommender.GetSimilarHotels();
foreach (var recHotel in recHotels)
{
RecommendedHotels.Add(recHotel);
}
foreach (var item in ratingData)
{
var rating =
new RatingModel
{
UserName = (await _userService.GetById <UserDTO>(item.UserId)).UserName,
Rating = item.HotelRating,
RatingDate = item.RatingDate
};
Reviews.Add(rating);
}
}
public ActionResult Index(int?page)
{
if (User.Identity.IsAuthenticated)
{
var person = PersonRepository.GetPersonByEmail(User.Identity.Name, true);
var movies = new List <MovieViewModel>();
var BLLmovies = new List <BLL.Movie>();
#region Getting recommended movies here
BLLmovies = Recommender.Recommend(person).ToList();
//BLLmovies = MovieProvider.RecommendMovies();
foreach (var BLLmovie in BLLmovies)
{
if (BLLmovie.Title == "" || BLLmovie.PosterPath == null || BLLmovie.PosterPath == "")
{
continue;
}
var movie = new MovieViewModel();
movie.CastSimpleFromMovie(BLLmovie);
movies.Add(movie);
}
#endregion
int pageSize = 9;
int pageNumber = (page ?? 1);
return(View("HomeLoggedIn", movies.ToPagedList(pageNumber, pageSize)));
}
else
{
return(View());
}
}
public override double GetEvaluation(IDictionary <User, ICollection <Preference> > testUserPrefs,
Recommender recommender)
{
RunningAverage average = new FullRunningAverage();
foreach (KeyValuePair <User, ICollection <Preference> > entry in testUserPrefs)
{
foreach (Preference realPref in entry.Value)
{
User testUser = entry.Key;
try
{
double estimatedPreference =
recommender.EstimatePreference(testUser.ID, realPref.Item.ID);
if (!double.IsNaN(estimatedPreference))
{
double diff = realPref.Value - estimatedPreference;
average.AddDatum(diff * diff);
}
}
catch (NoSuchElementException nsee)
{
// It's possible that an item exists in the test data but not training data in which case
// NSEE will be thrown. Just ignore it and move on.
log.Info("Element exists in test data but not training data: " + testUser.ID, nsee);
}
}
}
return(Math.Sqrt(average.Average));
}
///
public override void LoadModel(string filename)
{
using (StreamReader reader = Recommender.GetReader(filename, this.GetType()))
{
var bias = double.Parse(reader.ReadLine(), CultureInfo.InvariantCulture);
var user_factors = (Matrix <double>)IMatrixUtils.ReadMatrix(reader, new Matrix <double>(0, 0));
var item_factors = (Matrix <double>)IMatrixUtils.ReadMatrix(reader, new Matrix <double>(0, 0));
if (user_factors.NumberOfColumns != item_factors.NumberOfColumns)
{
throw new Exception(
string.Format("Number of user and item factors must match: {0} != {1}",
user_factors.NumberOfColumns, item_factors.NumberOfColumns));
}
this.MaxUserID = user_factors.NumberOfRows - 1;
this.MaxItemID = item_factors.NumberOfRows - 1;
// assign new model
this.global_bias = bias;
if (this.NumFactors != user_factors.NumberOfColumns)
{
Console.Error.WriteLine("Set num_factors to {0}", user_factors.NumberOfColumns);
this.NumFactors = (uint)user_factors.NumberOfColumns;
}
this.user_factors = user_factors;
this.item_factors = item_factors;
}
}
public void Initialize()
{
DbContextHelpers contextHelpers = new DbContextHelpers();
db = contextHelpers.getDbContext();
recommender = new Recommender(db.Object);
}
public ServisModel AddServis(ServisInsertRequest request)
{
var entity = _mapper.Map <Database.Servisi>(request);
Recommender recommender = new Recommender(_context, _mapper);
var dodjeljeniServiser = recommender.GetServisera(request.UredjajId);
if (dodjeljeniServiser == null)
{
dodjeljeniServiser = _context.KorisniciUloge.Include(k => k.Korisnik).Where(ko => ko.Uloga.Naziv == "serviser").Select(k => k.Korisnik).FirstOrDefault();
}
entity.ServiserId = dodjeljeniServiser.KorisnikId;
var status1 = _context.StatusServisa.Where(x => x.Naziv == "Servis napravljen").FirstOrDefault();
var status2 = _context.StatusServisa.Where(x => x.Naziv == "Servis dodjeljen serviseru").FirstOrDefault();
entity.StatusServisaId = status2.StatusServisaId;
_context.Servisi.Add(entity);
_context.SaveChanges();
StanjeServisa ss1 = new StanjeServisa();
ss1.Azurirano = DateTime.Now;
ss1.Napomena = "Servir kreiran";
ss1.ServisId = entity.ServisId;
ss1.StatusServisaId = status1.StatusServisaId;
_context.StanjeServisa.Add(ss1);
_context.SaveChanges();
StanjeServisa ss2 = new StanjeServisa();
ss2.Azurirano = DateTime.Now;
ss2.Napomena = "Servis uspjesno dodjeljen serviseru";
ss2.ServisId = entity.ServisId;
ss2.StatusServisaId = status2.StatusServisaId;
_context.StanjeServisa.Add(ss2);
_context.SaveChanges();
return(_mapper.Map <ServisModel>(entity));
}
/// <summary>
/// Get recommendations from a model
/// </summary>
/// <param name="modelId">The id of the model to recommend with</param>
/// <param name="usageEvents">Usage events to get recommendations for</param>
/// <param name="userId">An optional id of the user to provide recommendations for. Any stored usage events associated with this user will be considered when getting recommendations</param>
/// <param name="recommendationCount">Number of recommendations to get</param>
/// <param name="cancellationToken">A cancellation token used to abort the operation</param>
public async Task <IList <Recommendation> > ScoreAsync(Guid modelId, IEnumerable <IUsageEvent> usageEvents, string userId, int recommendationCount, CancellationToken cancellationToken)
{
// return empty result if no recommendations requested
if (recommendationCount <= 0)
{
Trace.TraceVerbose($"Requested '{recommendationCount}' recommendation for model '{modelId}' - returning empty recommendations.");
return(new Recommendation[0]);
}
Trace.TraceInformation($"Getting or creating a recommender for model '{modelId}'");
Recommender recommender = await GetOrCreateRecommenderAsync(modelId, cancellationToken);
try
{
Trace.TraceInformation($"Getting recommendations for model '{modelId}'");
return(recommender.GetRecommendations(usageEvents, userId, recommendationCount));
}
catch (Exception ex)
{
var exception = new Exception(
$"Exception while trying to get recommendations for model with id {modelId}", ex);
Trace.TraceError(exception.ToString());
throw exception;
}
}
/// <summary>
/// Gets or creates a <see cref="Recommender"/> for the input model
/// </summary>
private async Task <Recommender> GetOrCreateRecommenderAsync(Guid modelId, CancellationToken cancellationToken)
{
var key = modelId.ToString();
var recommender = _recommendersCache.Get(key) as Recommender;
if (recommender == null)
{
using (var stream = new MemoryStream())
{
Trace.TraceInformation($"Downloading the serialized trained model '{modelId}' from blob storage");
await DownloadTrainedModelAsync(modelId, stream, cancellationToken);
// rewind the stream
stream.Seek(0, SeekOrigin.Begin);
Trace.TraceInformation($"Deserializing the trained model '{modelId}'");
ITrainedModel trainedModel = DeserializeTrainedModel(stream, modelId);
// get the model's user history store
IDocumentStore modelDocumentStore = _documentStoreProvider.GetDocumentStore(modelId);
// create a recommender from the trained model
recommender = new Recommender(trainedModel, modelDocumentStore, new Tracer(nameof(Recommender)));
}
bool result = _recommendersCache.Add(key, recommender,
new CacheItemPolicy {
AbsoluteExpiration = DateTimeOffset.UtcNow.AddDays(1)
});
Trace.TraceVerbose($"Addition of model {modelId} recommender to the cache resulted with '{result}'");
}
return(recommender);
}
public void GetRecommendedMovies_testuser_StarWarsRecommended()
{
new User("testuser");
MySqlCommands.RateMovie(12, "thumbsup"); // star wars movie
MySqlCommands.RateMovie(212, "thumbsup"); // star wars movie
MySqlCommands.RateMovie(73, "thumbsup"); // star wars movie
MySqlCommands.RateMovie(10, "thumbsup"); // fight club
MySqlCommands.RateMovie(13, "thumbsup"); // forrest gump
MySqlCommands.RateMovie(22, "thumbsup"); // se7en
Recommender.Update("genre", "directors", "actors");
Recommender.AlgorithmMovieWeight(MySqlCommands.FindMovieFromId(new List <int> {
20
}).ToList());
// given user data with these 6 movies for the movieid 20, Star Wars(1997)
// genre: action(0,5), adventure(0,5), fantasy(0,5), sci-fi(0,5)
// director: george lucas(0)
// actors: Mark(0,5), Harrison(0,5), Carrie(0,5), Peter C(0), Alec(0,1667), Anthony(0,3333), Kenny(0,1667), Peter M(0,3333), David(0,1667), Phil(0)
// total director = 0
// total actors = 0,5 + 0,5 + 0,5 + 0 + 0,1667 + 0,3333 + 0,1667 + 0,3333 + 0,1667 + 0 = 2,6667
// total genre = 0,5 + 0,5/4 + 0,5/4 + 0,5/4 = 0,875
// total weight = 0 + 2,6667 + 0,875 = 3,5417
KeyValuePair <MovieMenuItem, double> movie = Recommender.MovieRatingsWeight.First();
Assert.AreEqual(Math.Round(3.5417, 2), (Math.Round(movie.Value, 2))); // rounds down due to data is more preceise
}
public static void evaluate(Recommender recommender, DataModel model, int samples, RunningAverage tracker, string tag)
{
printHeader();
IEnumerator <long> enumerator = recommender.getDataModel().getUserIDs();
while (enumerator.MoveNext())
{
long current = enumerator.Current;
List <RecommendedItem> items = recommender.recommend(current, model.getNumItems());
PreferenceArray prefs = model.getPreferencesFromUser(current);
prefs.sortByValueReversed();
FastIDSet modelSet = new FastIDSet();
long num2 = setBits(modelSet, items, samples);
FastIDSet set2 = new FastIDSet();
num2 = Math.Max(num2, setBits(set2, prefs, samples));
int max = Math.Min(mask(modelSet, set2, num2), samples);
if (max >= 2)
{
long[] itemsL = getCommonItems(modelSet, items, max);
long[] itemsR = getCommonItems(modelSet, prefs, max);
double datum = scoreCommonSubset(tag, current, samples, max, itemsL, itemsR);
tracker.addDatum(datum);
}
}
}
public async Task <CompletionResult> GetCompletionList(WorkspaceRequest request, Budget budget)
{
budget ??= new TimeBudget(TimeSpan.FromSeconds(defaultBudgetInSeconds));
var package = await _packageFinder.Find <ICreateWorkspace>(request.Workspace.WorkspaceType);
var workspace = await request.Workspace.InlineBuffersAsync();
var sourceFiles = workspace.GetSourceFiles();
var(_, documents) = await package.GetCompilationForLanguageServices(
sourceFiles,
GetSourceCodeKind(request),
GetUsings(request.Workspace),
budget);
var file = workspace.GetFileFromBufferId(request.ActiveBufferId);
var(_, _, absolutePosition) = workspace.GetTextLocation(request.ActiveBufferId);
var selectedDocument = documents.First(doc => doc.IsMatch(file));
var service = CompletionService.GetService(selectedDocument);
var completionList = await service.GetCompletionsAsync(selectedDocument, absolutePosition);
var semanticModel = await selectedDocument.GetSemanticModelAsync();
var diagnostics = DiagnosticsExtractor.ExtractSerializableDiagnosticsFromSemanticModel(request.ActiveBufferId, budget, semanticModel, workspace);
var symbols = await Recommender.GetRecommendedSymbolsAtPositionAsync(
semanticModel,
absolutePosition,
selectedDocument.Project.Solution.Workspace);
var symbolToSymbolKey = new Dictionary <(string, int), ISymbol>();
foreach (var symbol in symbols)
{
var key = (symbol.Name, (int)symbol.Kind);
if (!symbolToSymbolKey.ContainsKey(key))
{
symbolToSymbolKey[key] = symbol;
}
}
if (completionList == null)
{
return(new CompletionResult(requestId: request.RequestId, diagnostics: diagnostics));
}
var completionItems = completionList.Items
.Where(i => i != null)
.Select(item => item.ToModel(symbolToSymbolKey, selectedDocument));
return(new CompletionResult(completionItems
.Deduplicate()
.ToArray(),
requestId: request.RequestId,
diagnostics: diagnostics));
}
// TODO add compute_fit again
static void Usage(int exit_code)
{
Console.WriteLine(@"
MyMediaLite KDD Cup 2011 Track 2 tool
usage: KDDTrack2.exe METHOD [ARGUMENTS] [OPTIONS]
use '-' for either TRAINING_FILE or TEST_FILE to read the data from STDIN
methods (plus arguments and their defaults):");
Console.Write(" - ");
Console.WriteLine(string.Join("\n - ", Recommender.List("MyMediaLite.ItemRecommendation")));
Console.WriteLine(@"method ARGUMENTS have the form name=value
general OPTIONS have the form name=value
- random_seed=N set random seed to N
- data_dir=DIR load all files from DIR
- save_model=FILE save computed model to FILE
- load_model=FILE load model from FILE
- prediction_file=FILE write the predictions to FILE ('-' for STDOUT)
- sample_data=BOOL assume the sample data set instead of the real one
- predict_score=BOOL predict scores (double precision) instead of 0/1 decisions
- predict_rated=BOOL instead of predicting what received a good rating, try to predict what received a rating at all
(implies predict_score)
options for finding the right number of iterations (MF methods)
- find_iter=N give out statistics every N iterations
- max_iter=N perform at most N iterations
- epsilon=NUM abort iterations if error is more than best result plus NUM
- err_cutoff=NUM abort if error is above NUM");
Environment.Exit(exit_code);
}
///
public override void LoadModel(string file)
{
using (StreamReader reader = Recommender.GetReader(file, this.GetType()))
{
int numberOfComponents = int.Parse(reader.ReadLine());
var weights = new List <double>();
var recommenders = new List <IRecommender>();
for (int i = 0; i < numberOfComponents; i++)
{
string[] data = reader.ReadLine().Split(' ');
Type t = Type.GetType(data[0]);
recommenders.Add((IRecommender)Activator.CreateInstance(t));
recommenders[i].LoadModel("model-" + i + ".txt");
// make sure the recommenders get their data FIXME
weights.Add(double.Parse(data[1], CultureInfo.InvariantCulture));
}
this.weights = weights;
this.recommenders = recommenders;
}
}
/// <summary>
/// 取得光标位置的可用智能感知项目
/// </summary>
/// <param name="bodytext">代码</param>
/// <param name="logic">对应项目</param>
/// <param name="index">光标所在位置</param>
/// <returns>可能智能感知项目</returns>
public IEnumerable <ISymbol> GetRecommendedSymbolsAtPositionAsync(string bodytext, IDocumentProvider logic, int index)
{
if (logic is IPartCodeProvider)
{
var doc = Documents[logic.GetDocumentGuid()];
bodytext = (logic as IPartCodeProvider).ReplaceNewCode(doc.GetTextAsync().Result.ToString(), bodytext);
//var doc = Documents[method.BusinessObject.Oid];
//var newText = method.ReplaceNewCode(doc.GetTextAsync().Result.ToString(), bodytext);
//UpdateText(newText, method.BusinessObject);
//var semanticModel = SemanticModels[method.BusinessObject.Oid];
//return Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, pos, Workspace).Result;
}
UpdateText(bodytext, logic);
if (logic is IPartCodeProvider)
{
var define = (logic as IPartCodeProvider).DefaultLocation;
index = bodytext.IndexOf(define) + define.Length + index + 1;
}
var semanticModel = SemanticModels[logic.GetDocumentGuid()];
return(Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, index, Workspace).Result);
}
public async Task WhenRecommenderIsNullResultExeption()
{
var rec = new Recommender(strngr);
var controller = new ProductController(streinger: strngr, recommendator: null);
Assert.CatchAsync <NullReferenceException>(() => controller.Product("exists_objects"));
}
public IReadOnlyList <ISymbol> GetRecommendedSymbols(DocumentId documentId, int position)
{
var document = CurrentSolution.GetDocument(documentId);
var semanticModel = document.GetSemanticModelAsync().Result;
return(Recommender.GetRecommendedSymbolsAtPosition(semanticModel, position, this).ToArray());
}
public async Task <IActionResult> AutoComplete([FromBody] Request request)
{
_workspace.EnsureBufferUpdated(request);
var completions = Enumerable.Empty <AutoCompleteResponse>();
var document = _workspace.GetDocument(request.FileName);
if (document != null)
{
var sourceText = await document.GetTextAsync();
var position = sourceText.Lines.GetPosition(new LinePosition(request.Line - 1, request.Column - 1));
var model = await document.GetSemanticModelAsync();
var symbols = Recommender.GetRecommendedSymbolsAtPosition(model, position, _workspace);
completions = symbols.Select(MakeAutoCompleteResponse);
}
else
{
return(new HttpNotFoundResult());
}
return(new ObjectResult(completions));
}
// GET: Recommendations
public async Task <ActionResult> Index()
{
var userClaims = User.Identity as System.Security.Claims.ClaimsIdentity;
ViewBag.Name = userClaims?.FindFirst("name")?.Value;
IEnumerable <PreferenceEntity> preferenceEntities = TableActions.GetPreferencesResult("PreferenceTable", userClaims?.FindFirst(System.IdentityModel.Claims.ClaimTypes.Name)?.Value);
IEnumerable <PantryEntity> pantryEntities = TableActions.GetPantryResult("PantryTable", userClaims?.FindFirst(System.IdentityModel.Claims.ClaimTypes.Name)?.Value);
var preference = preferenceEntities.FirstOrDefault();
IEnumerable <string> dietaryRestrictions = null;
string diet = null;
if (preference != null)
{
dietaryRestrictions = preference.healthPreference.Split(',');
diet = preference.dietPreference;
}
string[] foods = { "pork", "bread", "peppers", "sugar", "corn" };
string[] pantryList = pantryEntities.Select(x => x.RowKey).ToArray();
IngredientList userPreferences = new IngredientList(foods);
IngredientList pantry = new IngredientList(pantryList);
List <Tuple <Recipe, double> > recs = await Recommender.GetRecommendations(userPreferences, pantry, dietaryRestrictions, diet);
return(View(recs));
}
public static IEnumerable <ICompletionData> Resolve(string code, int position, string[] references = null, IEnumerable <Tuple <string, string> > includes = null)
{
var completions = new List <ICompletionData>();
var pos = position - 1;
var workspace = new AdhocWorkspace();
var document = InitWorkspace(workspace, code, null, AgregateRefs(references), includes);
var model = document.GetSemanticModelAsync().Result;
var symbols = Recommender.GetRecommendedSymbolsAtPositionAsync(model, position, workspace).Result.ToArray();
var data = symbols.Select(s => s.ToCompletionData()).ToArray();
foreach (var group in data.GroupBy(x => x.DisplayText))
{
var item = group.First();
if (group.Count() > 1)
{
foreach (var overload in group)
{
item.AddOverload(overload);
//item.HasOverloads = true;
}
}
completions.Add(item);
}
return(completions);
}
private async Task <IEnumerable <CompletionItem> > GetCompletionList(
string code,
int cursorPosition)
{
var(document, offset) = GetDocumentWithOffsetFromCode(code);
var absolutePosition = cursorPosition + offset;
var service = CompletionService.GetService(document);
var completionList = await service.GetCompletionsAsync(document, absolutePosition);
if (completionList is null)
{
return(Enumerable.Empty <CompletionItem>());
}
var semanticModel = await document.GetSemanticModelAsync();
var symbols = await Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, absolutePosition, document.Project.Solution.Workspace);
var symbolToSymbolKey = new Dictionary <(string, int), ISymbol>();
foreach (var symbol in symbols)
{
var key = (symbol.Name, (int)symbol.Kind);
if (!symbolToSymbolKey.ContainsKey(key))
{
symbolToSymbolKey[key] = symbol;
}
}
var items = completionList.Items.Select(item => item.ToModel(symbolToSymbolKey, document)).ToArray();
return(items);
}
// GET: api/FoodRecommend
public async Task <object> Get(string UserID, string TagId = "")
{
string response = await Recommender.InvokeRequestResponseService(UserID);
var obj = JsonConvert.DeserializeObject <object>(response);
JObject rss = JObject.Parse(response);
List <int> arr = new List <int>();
for (int i = 1; i < 20; i++)
{
string tempstring = (string)rss["Results"]["output1"][0]["Item " + i.ToString()];
if (!string.IsNullOrEmpty(tempstring))
{
arr.Add(int.Parse(tempstring));
}
}
ApplicationDbContext ApplicationDbContext = new ApplicationDbContext();
var arr3 = ApplicationDbContext.FoodModels.Include("Restaurant")
.Where(c => arr.Contains(c.FoodID) && c.TagID.Contains(TagId))
.Select(x => new { x.Restaurant.Name, x.Restaurant.GPSLocation, x }).ToList();
//var arr2 = ApplicationDbContext.FoodModels.Where(c => arr3.Contains(c.RestaurantID)).ToList();
return(Json(arr2));
}
public override double GetEvaluation(IDictionary<User, ICollection<Preference>> testUserPrefs,
Recommender recommender)
{
RunningAverage average = new FullRunningAverage();
foreach (KeyValuePair<User, ICollection<Preference>> entry in testUserPrefs)
{
foreach (Preference realPref in entry.Value)
{
User testUser = entry.Key;
try
{
double estimatedPreference =
recommender.EstimatePreference(testUser.ID, realPref.Item.ID);
if (!double.IsNaN(estimatedPreference))
{
double diff = realPref.Value - estimatedPreference;
average.AddDatum(diff * diff);
}
}
catch (NoSuchElementException nsee)
{
// It's possible that an item exists in the test data but not training data in which case
// NSEE will be thrown. Just ignore it and move on.
log.Info("Element exists in test data but not training data: " + testUser.ID, nsee);
}
}
}
return Math.Sqrt(average.Average);
}
private async Task <IEnumerable <CompletionItem> > GetCompletionList(string code, int cursorPosition, ScriptState scriptState)
{
var metadataReferences = ImmutableArray <MetadataReference> .Empty;
var forcedState = false;
if (scriptState == null)
{
scriptState = await CSharpScript.RunAsync(string.Empty, ScriptOptions);
forcedState = true;
}
var compilation = scriptState.Script.GetCompilation();
metadataReferences = metadataReferences.AddRange(compilation.References);
var originalCode = forcedState ? string.Empty : scriptState.Script.Code ?? string.Empty;
var buffer = new StringBuilder(originalCode);
if (!string.IsNullOrWhiteSpace(originalCode) && !originalCode.EndsWith(Environment.NewLine))
{
buffer.AppendLine();
}
buffer.AppendLine(code);
var fullScriptCode = buffer.ToString();
var offset = fullScriptCode.LastIndexOf(code, StringComparison.InvariantCulture);
var absolutePosition = Math.Max(offset, 0) + cursorPosition;
if (_fixture == null || _metadataReferences != metadataReferences)
{
_fixture = new WorkspaceFixture(compilation.Options, metadataReferences);
_metadataReferences = metadataReferences;
}
var document = _fixture.ForkDocument(fullScriptCode);
var service = CompletionService.GetService(document);
var completionList = await service.GetCompletionsAsync(document, absolutePosition);
var semanticModel = await document.GetSemanticModelAsync();
var symbols = await Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, absolutePosition, document.Project.Solution.Workspace);
var symbolToSymbolKey = new Dictionary <(string, int), ISymbol>();
foreach (var symbol in symbols)
{
var key = (symbol.Name, (int)symbol.Kind);
if (!symbolToSymbolKey.ContainsKey(key))
{
symbolToSymbolKey[key] = symbol;
}
}
var items = completionList.Items.Select(item => item.ToModel(symbolToSymbolKey, document).ToDomainObject()).ToArray();
return(items);
}
public void WhenParamIsNullResultNull()
{
var recommender = new Recommender(strngr);
var recommendations = recommender.RecommendationsTo(null);
Assert.IsNull(recommendations);
}
///
public override void LoadModel(string filename)
{
using (StreamReader reader = Recommender.GetReader(filename, this.GetType()))
{
this.global_average = double.Parse(reader.ReadLine(), CultureInfo.InvariantCulture);
this.entity_averages = VectorUtils.ReadVector(reader);
}
}
///
public override void SaveModel(string filename)
{
using (StreamWriter writer = Recommender.GetWriter(filename, this.GetType()))
{
writer.WriteLine(global_average.ToString(CultureInfo.InvariantCulture));
VectorUtils.WriteVector(writer, entity_averages);
}
}
///
public override void SaveModel(string file)
{
using (StreamWriter writer = Recommender.GetWriter(file, this.GetType()))
{
IMatrixUtils.WriteMatrix(writer, user_factors);
IMatrixUtils.WriteMatrix(writer, item_factors);
}
}
public void WhenParamIsNullResultNull()
{
var recommender = new Recommender(strngr);
var comments = recommender.CommentsTo(null);
Assert.IsNull(comments);
}
///
public override void SaveModel(string filename)
{
using (StreamWriter writer = Recommender.GetWriter(filename, this.GetType()))
{
writer.WriteLine(global_bias.ToString(CultureInfo.InvariantCulture));
IMatrixUtils.WriteMatrix(writer, user_factors);
IMatrixUtils.WriteMatrix(writer, item_factors);
}
}
///
public override void SaveModel(string file)
{
using (StreamWriter writer = Recommender.GetWriter(file, this.GetType()))
{
writer.WriteLine(global_average.ToString(CultureInfo.InvariantCulture));
IMatrixUtils.WriteSparseMatrix(writer, diff_matrix);
IMatrixUtils.WriteSparseMatrix(writer, freq_matrix);
}
}
public abstract double GetEvaluation(IDictionary<User, ICollection<Preference>> testUserPrefs, Recommender recommender);
static void Main(string[] args)
{
ExplorationSpace space = Common.ExternalIO.LoadSpace(
ExternalIO.WorldDataPath(),
ExternalIO.GraphDataPath());
recommender = new Recommender(space);
if (space != null)
{
Console.WriteLine("Starting server...");
Task serverTask = StartServer();
Console.WriteLine("Press ENTER to stop server . . .");
Console.ReadLine();
shutdown = true;
serverTask.Wait();
}
Console.WriteLine("Press any key to continue . . .");
Console.ReadKey();
}
public void AddRecommender(Recommender r)
{
r.NumberOfTags = NumberOfTags;
rcs.Add (r);
}
public static void runKFoldCrossValidation(object parameters)
{
try {
Program.semaphore.WaitOne();
// Setting environment for experiments
ThreadParams p = (ThreadParams)parameters;
string dbFile = p.dbFile;
int nFolds = p.nFolds;
int nIterations = p.nIterations;
// Check if the DB file exists
if (!File.Exists(dbFile))
throw new FileNotFoundException(dbFile);
// Do experiments for each methodology
foreach (Methodology methodology in Program.methodologies) {
// Get ego user's ID and his like count
long egoUser = long.Parse(Path.GetFileNameWithoutExtension(dbFile));
int cntLikes = 0;
// Check if this experiment has ever been performed earlier
int m = (int)methodology;
if (Program.existingResults.ContainsKey(egoUser) && Program.existingResults[egoUser].Contains(m)) {
lock (Program.locker) {
Console.WriteLine("Ego network(" + egoUser + "): done on experiment #" + m);
}
continue;
}
// Final result to put the experimental result per fold together
var finalResult = new Dictionary<EvaluationMetric, double>();
foreach (EvaluationMetric metric in Enum.GetValues(typeof(EvaluationMetric)))
finalResult.Add(metric, 0d);
// Need to avoid the following error: "Collection was modified; enumeration operation may not execute"
List<EvaluationMetric> metrics = new List<EvaluationMetric>(finalResult.Keys);
// K-Fold Cross Validation
for (int fold = 0; fold < nFolds; fold++) {
// Load graph information from database and then configurate the graph
DataLoader loader = new DataLoader(dbFile, nFolds);
if (fold == 0) {
if (loader.checkEgoNetworkValidation() == false)
return;
cntLikes = loader.cntLikesOfEgoUser;
}
loader.graphConfiguration(methodology, fold);
// Nodes and edges of graph
Dictionary<int, Node> nodes = loader.allNodes;
Dictionary<int, List<ForwardLink>> edges = loader.allLinks;
// Exeption: for the case that mention count is included when the friendship is none
if (methodology == Methodology.INCL_MENTIONCOUNT
|| methodology == Methodology.EXCL_FRIENDSHIP
|| methodology == Methodology.INCL_FOLLOWSHIP_ON_THIRDPARTY_AND_MENTIONCOUNT) {
foreach (List<ForwardLink> forwardLinks in edges.Values) {
List<int> indFriendshipLinks = new List<int>();
for (int i = 0; i < forwardLinks.Count; i++) {
if (forwardLinks[i].type == EdgeType.FRIENDSHIP)
indFriendshipLinks.Add(i);
}
foreach (int i in indFriendshipLinks) {
ForwardLink forwardLink = forwardLinks[i];
if (forwardLink.type == EdgeType.FRIENDSHIP) {
forwardLink.type = EdgeType.UNDEFINED;
forwardLinks[i] = forwardLink;
}
}
}
}
// Make a graph structure to run Random Walk with Restart algorithm
Graph graph = new Graph(nodes, edges);
graph.buildGraph();
// Get recommendation list
Recommender recommender = new Recommender(graph);
var recommendation = recommender.Recommendation(0, 0.15f, nIterations);
//// temp
//lock (Program.locker) {
// StreamWriter logger = new StreamWriter(Program.dirData + "rank.dat", true);
// logger.WriteLine(methodology);
// for (int i = 0; i < recommendation.Count; i++)
// logger.WriteLine(recommendation[i].Key + ":\t" + recommendation[i].Value);
// logger.Close();
//}
// Get evaluation result
int nHits = 0;
double sumPrecision = 0;
for (int i = 0; i < recommendation.Count; i++) {
if (loader.testSet.Contains(recommendation[i].Key)) {
nHits += 1;
sumPrecision += (double)nHits / (i + 1);
}
}
// Add current result to final one
foreach (EvaluationMetric metric in metrics) {
switch (metric) {
case EvaluationMetric.HIT:
finalResult[metric] += nHits; break;
case EvaluationMetric.AVGPRECISION:
finalResult[metric] += (nHits == 0) ? 0 : sumPrecision / nHits; break;
}
}
}
lock (Program.locker) {
// Write the result of this ego network to file
StreamWriter logger = new StreamWriter(Program.dirData + "result.dat", true);
logger.Write(egoUser + "\t" + (int)methodology + "\t" + nFolds + "\t" + nIterations);
foreach (EvaluationMetric metric in metrics) {
switch (metric) {
case EvaluationMetric.HIT:
logger.Write("\t" + (int)finalResult[metric] + "\t" + cntLikes); break;
case EvaluationMetric.AVGPRECISION:
logger.Write("\t" + (finalResult[metric] / nFolds)); break;
}
}
logger.WriteLine();
logger.Close();
}
}
} catch (FileNotFoundException e) {
Console.WriteLine(e);
} finally {
Program.semaphore.Release();
}
}
