public void CanMultiplySparseVectorByScalarUsingOperators()
{
var vector = SparseVector.OfEnumerable(Data);
vector = vector * 2.0f;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * 2.0f, vector[i]);
}
vector = vector * 1.0f;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * 2.0f, vector[i]);
}
vector = SparseVector.OfEnumerable(Data);
vector = 2.0f * vector;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * 2.0f, vector[i]);
}
vector = 1.0f * vector;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * 2.0f, vector[i]);
}
}
public void CanMultiplySparseVectorByScalarUsingOperators()
{
var vector = SparseVector.OfEnumerable(Data);
vector = vector * new Complex(2.0, 1);
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
}
vector = vector * 1.0;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
}
vector = SparseVector.OfEnumerable(Data);
vector = new Complex(2.0, 1) * vector;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
}
vector = 1.0 * vector;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] * new Complex(2.0, 1), vector[i]);
}
}
public double GlobalTest(double[] x0, double[,] a, double[] measurability, double[] tolerance)
{
var aMatrix = SparseMatrix.OfArray(a);
var aTransposedMatrix = SparseMatrix.OfMatrix(aMatrix.Transpose());
var x0Vector = SparseVector.OfEnumerable(x0);
// Введение погрешностей по неизмеряемым потокам
var xStd = SparseVector.OfEnumerable(tolerance) / 1.96;
for (var i = 0; i < xStd.Count; i++)
{
if (Math.Abs(measurability[i]) < 0.0000001)
{
xStd[i] = Math.Pow(10, 2) * x0Vector.Maximum();
}
}
var sigma = SparseMatrix.OfDiagonalVector(xStd.PointwisePower(2));
var r = aMatrix * x0Vector;
var v = aMatrix * sigma * aTransposedMatrix;
var result = r * v.PseudoInverse() * r.ToColumnMatrix();
var chi = ChiSquared.InvCDF(aMatrix.RowCount, 1 - 0.05);
return(result[0] / chi);
}
public void CanConvertArrayToSparseVector()
{
var array = new[] { 0.0f, 1.0f, 2.0f, 3.0f, 4.0f };
var vector = SparseVector.OfEnumerable(array);
Assert.IsInstanceOf(typeof(SparseVector), vector);
CollectionAssert.AreEqual(vector, array);
}
public void CanConvertArrayToSparseVector()
{
var array = new[] { new Complex(1, 1), new Complex(2, 1), new Complex(3, 1), new Complex(4, 1) };
var vector = SparseVector.OfEnumerable(array);
Assert.IsInstanceOf(typeof(SparseVector), vector);
CollectionAssert.AreEqual(array, array);
}
public void CanConvertSparseVectorToArray()
{
var vector = SparseVector.OfEnumerable(Data);
var array = vector.ToArray();
Assert.IsInstanceOf(typeof(float[]), array);
CollectionAssert.AreEqual(vector, array);
}
/// <summary>
/// Convert one user's preference relations into position matrix
/// See: Brun, A., Hamad, A., Buffet, O., & Boyer, A. (2010).
/// Towards preference relations in recommender systems. Workshop in ECML-PKDD.
/// </summary>
/// <param name="userPreferences"></param>
/// <returns></returns>
public static Vector <double> PreferencesToPositions(SparseMatrix userPreferences)
{
// Count for each preference type
// Actually the original paper count the strict preferred and less preferred by exact match
// but here we just compare with the EquallyPreferred, because the preferences can be
// scalar with Bradley-Terry model. However, it won't affect the result when it is discrete preference relations.
SparseVector preferredCountByItem = SparseVector.OfEnumerable(userPreferences.FoldByRow((count, pref) =>
count + (pref == Config.Preferences.Preferred ? 1 : 0), 0.0));
SparseVector lessPreferredCountByItem = SparseVector.OfEnumerable(userPreferences.FoldByRow((count, pref) =>
count + (pref == Config.Preferences.LessPreferred ? 1 : 0), 0.0));
// Note that we assume the diagonal are left empty
// otherwise the equally count needs to be offset by 1 for each, i.e. item itself does not count
Debug.Assert(userPreferences.Trace() == 0);
SparseVector equallyPreferredCountByItem = SparseVector.OfEnumerable(userPreferences.FoldByRow((count, pref) =>
count + (pref == Config.Preferences.EquallyPreferred ? 1 : 0), 0.0));
// Note that if the position is value zero then it won't appear in positionByItem
// because the use of SparseVector.OfVector() will ignore all zero values
Vector <double> positionByItem =
(preferredCountByItem - lessPreferredCountByItem)
.PointwiseDivide(lessPreferredCountByItem + preferredCountByItem + equallyPreferredCountByItem) + Config.Preferences.PositionShift;
Vector <double> indicatorOfSeenItems = userPreferences.RowSums(); // If zero, then this item has never been seen
for (int i = 0; i < indicatorOfSeenItems.Count; i++)
{
if (indicatorOfSeenItems[i] == 0)
{
positionByItem[i] = SparseVector.Zero;
}
}
// Note that the positions do not add up to 0
// because we shifted all values
Debug.Assert(
Math.Abs(positionByItem.Sum() - ((SparseVector)positionByItem).NonZerosCount * Config.Preferences.PositionShift)
< 0.001);
//+Config.Preferences.PositionShift;
// TODO: May improve later. Some items have position 0 and we dont want to mix
// up the position 0 and the 0 in sparsematrix.
// So we use a constant to hold the space for position value 0
// it should be reverted back when use
//Vector<double> indicatorVector = userPreferences.RowSums();
//for (int i = 0; i < indicatorVector.Count; i++)
//{
//if (indicatorVector[i] != 0 && positionByItem[i] != 0)
//{
// Debug.Assert(true, "By using the PositionShift constant, we should not be in here.");
// positionByItem[i] = Config.ZeroInSparseMatrix;
// }
//}
return(positionByItem);
}
public void CanCreateSparseVectorFromAnotherSparseVector()
{
var vector = SparseVector.OfEnumerable(Data);
var other = SparseVector.OfVector(vector);
Assert.AreNotSame(vector, other);
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(vector[i], other[i]);
}
}
public void CanCreateSparseVectorFromArray()
{
var data = new float[Data.Length];
Array.Copy(Data, data, Data.Length);
var vector = SparseVector.OfEnumerable(data);
for (var i = 0; i < data.Length; i++)
{
Assert.AreEqual(data[i], vector[i]);
}
}
public void CanDivideSparseVectorByScalarUsingOperators()
{
var vector = SparseVector.OfEnumerable(Data);
vector = vector / 2.0f;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] / 2.0f, vector[i]);
}
vector = vector / 1.0f;
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(Data[i] / 2.0f, vector[i]);
}
}
public void CanDivideSparseVectorByScalarUsingOperators()
{
var vector = SparseVector.OfEnumerable(Data);
vector = vector / new Complex(2.0, 1);
for (var i = 0; i < Data.Length; i++)
{
AssertHelpers.AlmostEqualRelative(Data[i] / new Complex(2.0, 1), vector[i], 14);
}
vector = vector / 1.0;
for (var i = 0; i < Data.Length; i++)
{
AssertHelpers.AlmostEqualRelative(Data[i] / new Complex(2.0, 1), vector[i], 14);
}
}
public void CanDivideSparseVectorByComplexUsingOperators()
{
var vector = SparseVector.OfEnumerable(Data);
vector = vector / new Complex32(2.0f, 1);
for (var i = 0; i < Data.Length; i++)
{
AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
}
vector = vector / 1.0f;
for (var i = 0; i < Data.Length; i++)
{
AssertHelpers.AlmostEqual(Data[i] / new Complex32(2.0f, 1), vector[i], 7);
}
}
public void CanPointwiseMultiplySparseVector()
{
var zeroArray = new[] { 0.0f, 1.0f, 0.0f, 1.0f, 0.0f };
var vector1 = SparseVector.OfEnumerable(Data);
var vector2 = SparseVector.OfEnumerable(zeroArray);
var result = new SparseVector(vector1.Count);
vector1.PointwiseMultiply(vector2, result);
for (var i = 0; i < vector1.Count; i++)
{
Assert.AreEqual(Data[i] * zeroArray[i], result[i]);
}
var resultStorage = (SparseVectorStorage <float>)result.Storage;
Assert.AreEqual(2, resultStorage.ValueCount);
}
public void UpdateTFIDFVectorRepresenation()
{
foreach (List <string> d in _documents)
{
List <double> vector = new List <double>();
foreach (string term in _termIdx.Keys)
{
double _termFrequency = TermFrequency(d, term);
double _inverseDocumentFrequency = InverseDocumentFrequency((double)_documents.Count, (double)_termCount[term]);
//Console.WriteLine("Num of docs in corpora: " + _documents.Count);
//Console.WriteLine(term + " : " + _termCount[term]);
//Console.WriteLine(term + " IDF : " + _inverseDocumentFrequency);
vector.Add(_termFrequency * _inverseDocumentFrequency);
}
_vectorRepresentation.Add(SparseVector.OfEnumerable(vector));
}
}
public void CanOuterMultiplySparseVectors()
{
var vector1 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
var vector2 = SparseVector.OfEnumerable(new[] { 2.0, 2.0, 0.0, 0.0 });
var result = vector1.OuterProduct(vector2);
Assert.AreEqual(4.0, result[0, 0]);
Assert.AreEqual(4.0, result[0, 1]);
Assert.AreEqual(4.0, result[1, 0]);
Assert.AreEqual(4.0, result[1, 1]);
for (var i = 0; i < vector1.Count; i++)
{
for (var j = 0; j < vector2.Count; j++)
{
if (i > 1 || j > 1)
{
Assert.AreEqual(0.0, result[i, j]);
}
}
}
}
/// <summary>
/// Creates a vector from an array.
/// </summary>
/// <param name="data">The array to create this vector from.</param>
/// <returns>The new vector. </returns>
protected override Vector <double> CreateVector(double[] data)
{
return(SparseVector.OfEnumerable(data));
}
public double[] Solve(double[] x0, double[,] a, double[] b, double[] measurability, double[] tolerance,
double[] lower, double[] upper)
{
// Проверка аргументов на null
_ = x0 ?? throw new ArgumentNullException(nameof(x0));
_ = a ?? throw new ArgumentNullException(nameof(a));
_ = b ?? throw new ArgumentNullException(nameof(b));
_ = measurability ?? throw new ArgumentNullException(nameof(measurability));
_ = tolerance ?? throw new ArgumentNullException(nameof(tolerance));
_ = lower ?? throw new ArgumentNullException(nameof(lower));
_ = upper ?? throw new ArgumentNullException(nameof(upper));
//Проверка аргументов на размерности
if (x0.Length == 0)
{
throw new ArgumentException(nameof(x0));
}
if (a.GetLength(1) != x0.Length)
{
throw new ArgumentException("Array length by dimension 1 is not equal to X0 length.", nameof(a));
}
if (b.Length != a.GetLength(0))
{
throw new ArgumentException("Array length is not equal to A length by 0 dimension.", nameof(b));
}
if (measurability.Length != x0.Length)
{
throw new ArgumentException("Array length is not equal to X0 length.", nameof(measurability));
}
if (tolerance.Length != x0.Length)
{
throw new ArgumentException("Array length is not equal to X0 length.", nameof(tolerance));
}
if (lower.Length != x0.Length)
{
throw new ArgumentException("Array length is not equal to X0 length.", nameof(lower));
}
if (upper.Length != x0.Length)
{
throw new ArgumentException("Array length is not equal to X0 length.", nameof(upper));
}
var stopWatch = new Stopwatch();
stopWatch.Start();
var i = SparseMatrix.OfDiagonalArray(measurability);
var w = SparseMatrix.OfDiagonalVector(1 / SparseVector.OfEnumerable(tolerance).PointwisePower(2));
var h = i * w;
var d = -(h * SparseVector.OfEnumerable(x0));
var func = new QuadraticObjectiveFunction(h.ToArray(), d.ToArray());
var constraints = new List <LinearConstraint>();
Time = stopWatch.Elapsed;
//Нижние и верхние границы
for (var j = 0; j < x0.Length; j++)
{
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = lower[j]
});
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = upper[j]
});
}
//Ограничения для решения задачи баланса
for (var j = 0; j < b.Length; j++)
{
var notNullElements = Array.FindAll(a.GetRow(j), x => Math.Abs(x) > 0.0000001);
var notNullElementsIndexes = new List <int>();
for (var k = 0; k < x0.Length; k++)
{
if (Math.Abs(a[j, k]) > 0.0000001)
{
notNullElementsIndexes.Add(k);
}
}
constraints.Add(new LinearConstraint(notNullElements.Length)
{
VariablesAtIndices = notNullElementsIndexes.ToArray(),
CombinedAs = notNullElements,
ShouldBe = ConstraintType.EqualTo,
Value = b[j]
});
}
var solver = new GoldfarbIdnani(func, constraints);
if (!solver.Minimize())
{
throw new ApplicationException("Failed to solve balance task.");
}
stopWatch.Stop();
TimeAll = stopWatch.Elapsed;
DisbalanceOriginal = a.Dot(x0).Subtract(b).Euclidean();
Disbalance = a.Dot(solver.Solution).Subtract(b).Euclidean();
return(solver.Solution);
}
/// <summary>
/// Creates a vector from an array.
/// </summary>
/// <param name="data">The array to create this vector from.</param>
/// <returns>The new vector. </returns>
protected override Vector <float> CreateVector(float[] data)
{
return(SparseVector.OfEnumerable(data));
}
// We need to directly compute the position matrix because the PR would be too big to fit into memory
public static SparseMatrix PredictPrefRelations(PrefRelations PR_train, Dictionary <int, List <int> > PR_unknown,
int maxEpoch, double learnRate, double regularizationOfUser, double regularizationOfItem, int factorCount, List <double> quantizer)
{
// Latent features
List <Vector <double> > P;
List <Vector <double> > Q;
//Matrix<double> P;
//Matrix<double> Q;
//SparseMatrix positionMatrix = new SparseMatrix(PR_train.UserCount, PR_train.ItemCount);
Vector <double>[] positionMatrixCache = new Vector <double> [PR_train.UserCount];
LearnLatentFeatures(PR_train, maxEpoch, learnRate, regularizationOfUser, regularizationOfItem, factorCount, out P, out Q);
//PrefRelations PR_predicted = new PrefRelations(PR_train.ItemCount);
Object lockMe = new Object();
Parallel.ForEach(PR_unknown, user =>
{
Utils.PrintEpoch("Epoch", user.Key, PR_unknown.Count);
int indexOfUser = user.Key;
List <int> unknownItemsOfUser = user.Value;
//SparseMatrix predictedPreferencesOfUser = new SparseMatrix(PR_train.ItemCount, PR_train.ItemCount);
List <Tuple <int, int, double> > predictedPreferencesOfUserCache = new List <Tuple <int, int, double> >();
// Predict each unknown preference
foreach (int indexOfItem_i in unknownItemsOfUser)
{
foreach (int indexOfItem_j in unknownItemsOfUser)
{
if (indexOfItem_i == indexOfItem_j)
{
continue;
}
double estimate_uij = P[indexOfUser].DotProduct(Q[indexOfItem_i] - Q[indexOfItem_j]); // Eq. 2
double normalized_estimate_uij = Core.SpecialFunctions.InverseLogit(estimate_uij); // pi_uij in paper
predictedPreferencesOfUserCache.Add(new Tuple <int, int, double>(indexOfItem_i, indexOfItem_j, normalized_estimate_uij));
//predictedPreferencesOfUser[indexOfItem_i, indexOfItem_j] = normalized_estimate_uij;
}
}
// Note: it shows better performance to not quantize here
/*
* DataMatrix predictedPreferencesOfUser =
* new DataMatrix(SparseMatrix.OfIndexed(PR_train.ItemCount, PR_train.ItemCount, predictedPreferencesOfUserCache));
* predictedPreferencesOfUser.Quantization(0, 1.0, quantizer);
* Vector<double> positionsOfUser = PrefRelations.PreferencesToPositions(predictedPreferencesOfUser.Matrix);
*/
double[] positionByItem = new double[PR_train.ItemCount];
foreach (var triplet in predictedPreferencesOfUserCache)
{
int indexOfItem_i = triplet.Item1;
int indexOfItem_j = triplet.Item2;
double preference = triplet.Item3;
if (preference > 0.5)
{
positionByItem[indexOfItem_i]++;
positionByItem[indexOfItem_j]--;
}
else if (preference < 0.5)
{
positionByItem[indexOfItem_i]--;
positionByItem[indexOfItem_j]++;
}
}
int normalizationTerm = unknownItemsOfUser.Count * 2 - 2;
for (int i = 0; i < positionByItem.Length; i++)
{
if (positionByItem[i] != 0)
{
positionByItem[i] /= normalizationTerm;
}
}
Vector <double> positionsOfUser = SparseVector.OfEnumerable(positionByItem);
lock (lockMe)
{
positionMatrixCache[indexOfUser] = positionsOfUser;
//positionMatrix.SetRow(indexOfUser, positionsOfUser);
//PR_predicted[indexOfUser] = predictedPreferencesOfUser;
}
});
return(SparseMatrix.OfRowVectors(positionMatrixCache));
}
/// <summary>
/// Creates a vector from an array.
/// </summary>
/// <param name="data">The array to create this vector from.</param>
/// <returns>The new vector. </returns>
protected virtual Vector <float> CreateVector(float[] data)
{
return(SparseVector.OfEnumerable(data));
}
/// <summary>
/// Creates a vector from an array.
/// </summary>
/// <param name="data">The array to create this vector from.</param>
/// <returns>The new vector. </returns>
protected override Vector <Complex32> CreateVector(Complex32[] data)
{
return(SparseVector.OfEnumerable(data));
}
