public static void CalculateTFIDF(SuggestorCollection collection, double numberOfCollections)
{
foreach (SuggestorCollectionLine line in collection.CollectionLines.Values)
{
line.Weight= ((1.0 + Math.Log(line.Quantity)) * Math.Log(numberOfCollections / line.Quantity));
}
}
public override Dictionary<string, double> SuggestNItems(Dictionary<string, SuggestorCollection> collections, SuggestorCollection compareCollection, int n)
{
if (compareCollection.CollectionLines.Count == 0) return null;
Dictionary<string, double> itemAggregation = new Dictionary<string, double>();
// Find top similar collections
Dictionary<SuggestorCollection, double> topCollections = SuggestNCollections(collections.Values.ToList(), compareCollection, n);
foreach (SuggestorCollection collection in topCollections.Keys)
{
foreach (string itemNo in collection.CollectionLines.Keys)
{
if (compareCollection.CollectionLines.ContainsKey(itemNo)) continue; // Ignore items that are already in basket
if (!(itemAggregation.ContainsKey(itemNo))) itemAggregation.Add(itemNo, 1);
itemAggregation[itemNo]++;
//itemAggregation[itemNo] += topInvoices[invoice] * 1.0;
}
}
List<KeyValuePair<string, double>> itemAggregationList = itemAggregation.ToList();
// Sort dictionary by value
itemAggregationList.Sort((firstPair, nextPair) => { return firstPair.Value.CompareTo(nextPair.Value); });
itemAggregationList.Reverse();
itemAggregation = itemAggregationList.ToDictionary(pair => pair.Key, pair => pair.Value);
return itemAggregation;
}
/*
public static double GetLimitedSize(SuggestorCollection collection, Dictionary<string, SuggestorCollectionLine> mutualCollectionLines)
{
double squaredSum = 0;
foreach (string invoiceLineNo in mutualCollectionLines.Keys)
{
squaredSum += Math.Pow(collection.CollectionLines[invoiceLineNo].Weight, 2);
}
return Math.Sqrt(squaredSum);
}
*/
/*
public static double GetLimitedSize(SuggestorUser user, Dictionary<string, SuggestorCollectionLine> mutualCollectionLines)
{
double squaredSum = 0;
foreach (string invoiceLineNo in mutualCollectionLines.Keys)
{
squaredSum += Math.Pow(user.CollectionLines[invoiceLineNo].Weight, 2);
}
return Math.Sqrt(squaredSum);
}
*/
public static double GetSize(SuggestorCollection collection)
{
double squaredSum = 0;
foreach (SuggestorCollectionLine line in collection.CollectionLines.Values)
{
squaredSum += Math.Pow(line.Weight, 2);
}
return Math.Sqrt(squaredSum);
}
public static double CosineScore(SuggestorCollection collection, SuggestorCollection otherCollection)
{
// TF-IDF
Dictionary<string, SuggestorCollectionLine> mutualAttributes = new Dictionary<string, SuggestorCollectionLine>();
mutualAttributes = collection.CollectionLines.Keys.Intersect(otherCollection.CollectionLines.Keys).ToDictionary(t => t, t => collection.CollectionLines[t]);
double cosScore = 0;
double termProductSum = 0;
foreach (string lineNo in mutualAttributes.Keys)
{
termProductSum += collection.CollectionLines[lineNo].Weight * otherCollection.CollectionLines[lineNo].Weight;
}
double vectorNormalizingMultiplication = (GetSize(collection) * GetSize(otherCollection));
if (vectorNormalizingMultiplication == 0)
return 0;
cosScore = termProductSum / vectorNormalizingMultiplication;
return cosScore;
}
public override Dictionary<SuggestorCollection, double> SuggestNCollections(List<SuggestorCollection> collections, SuggestorCollection compareCollection, int n)
{
// TODO: Disgusting code
Dictionary<SuggestorCollection, double> topCollections = new Dictionary<SuggestorCollection, double>();
List<SuggestorCollection> compareCollections = collections;
compareCollections.Remove(compareCollection);
// Calculate all weights
// TODO: Cache this. Per instance?
foreach (SuggestorCollection invoice in compareCollections)
{
topCollections.Add(invoice, SuggestorCollectionFunctions.CosineScore(invoice, compareCollection));
}
List<KeyValuePair<SuggestorCollection, double>> topValues = topCollections.ToList();
topValues.Sort((firstPair, nextPair) => { return firstPair.Value.CompareTo(nextPair.Value); });
topValues.Reverse();
Dictionary<SuggestorCollection, double> returnInvoices = new Dictionary<SuggestorCollection, double>();
for (int i = 0; i < n; i++)
{
if (topValues[i].Value != 0)
returnInvoices.Add(topValues[i].Key, topValues[i].Value);
}
return returnInvoices;
}
public void Foo(SuggestorCollection collection)
{
}
public Dictionary<string, double> SuggestItems(SuggestorCollection compareCollection, int n)
{
return recommenderEngine.SuggestNItems(collections, compareCollection, n);
}
public Dictionary<SuggestorCollection, double> SuggestCollections(List<SuggestorCollection> collectionsToCompareTo, SuggestorCollection compareCollection, int n)
{
return recommenderEngine.SuggestNCollections(collectionsToCompareTo, compareCollection, n);
}
public static void PrintInvoice(SuggestorCollection collection)
{
Console.WriteLine("--------------------------");
Console.WriteLine("Collection: " + collection.CollectionId);
foreach (SuggestorCollectionLine line in collection.CollectionLines.Values)
{
Console.WriteLine(" " + line.Description + " " + line.Quantity);
}
Console.WriteLine();
Console.WriteLine();
}
public abstract Dictionary<string, double> SuggestNItems(Dictionary<string, SuggestorCollection> collections, SuggestorCollection compareCollection, int n);
public abstract Dictionary<SuggestorCollection, double> SuggestNCollections(List<SuggestorCollection> collections, SuggestorCollection compareCollection, int n);
