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)); }