public Dictionary <int, List <int> > GetSeenItemsByUser()
{
Dictionary <int, List <int> > seenItemsByUser = new Dictionary <int, List <int> >();
Object lockMe = new Object();
Parallel.ForEach(preferenceRelations, pair =>
{
int userIndex = pair.Key;
SparseMatrix userPreferences = pair.Value;
List <int> seenItems = new List <int>();
foreach (Tuple <int, Vector <double> > tuple in userPreferences.EnumerateRowsIndexed())
{
int itemIndex = tuple.Item1;
SparseVector itemPreferences = SparseVector.OfVector(tuple.Item2);
if (itemPreferences.NonZerosCount > 1) // 1 because the item must has compared with itself
{
seenItems.Add(itemIndex);
}
}
lock (lockMe)
{
seenItemsByUser[userIndex] = seenItems;
}
});
return(seenItemsByUser);
}
} //Получение J для оценки правильности обучения
private List <SparseMatrix> getDerivatives(SparseMatrix Y, SparseMatrix X, List <List <SparseVector> > activations)
{
List <Vector <double> > delta = new List <Vector <double> >();
List <SparseMatrix> D = new List <SparseMatrix>();
for (int i = 0; i < _layers.Count; i++)
{
D.Add(SparseMatrix.Create(_layers[i].Weights.RowCount, _layers[i].Weights.ColumnCount, 0));
}
for (int k = 0; k < m; k++)
{
delta = new List <Vector <double> >();
for (int i = 0; i < _layers.Count; i++)
{
delta.Add(new SparseVector(_layers[i].Activations.Count));
}
for (int i = delta.Count - 1; i >= 0; i--)
{
if (i == delta.Count - 1)
{
for (int j = 0; j < activations[k][i].Count; j++)
{
delta[delta.Count - 1][j] = (activations[k][i][j] - Y.Row(k)[j]);
}
}
else
{
delta[i] = _layers[i + 1].Weights.Transpose().Multiply((delta[i + 1]));
delta[i] = SparseVector.OfVector(multiplayOnSigmoidGradient(delta[i], activations[k][i]));
D[i + 1] = D[i + 1] + (SparseMatrix)(delta[i + 1].OuterProduct(activations[k][i]));
}
if (i == 0)
{
Vector <double> tempVector = SparseVector.Create(X.Row(k).Count, 1);
if (tempVector.Count != D[i].ColumnCount)
{
SparseVector tmp = SparseVector.Create(D[i].ColumnCount, 1);
for (int j = 1; j < tmp.Count; j++)
{
tmp[j] = X.Row(k)[j - 1];
}
tempVector = tmp;
}
Matrix <double> tempMatrix = delta[i].OuterProduct(tempVector);
D[i] = D[i] + (SparseMatrix)(tempMatrix);
}
}
}
List <SparseMatrix> derivatives = new List <SparseMatrix>();
for (int i = 0; i < D.Count; i++)
{
derivatives.Add(D[i] * (1f / m));
}
return(derivatives);
} //Получение частных производных
public void CanCreateSparseVectorFromUserDefinedVector()
{
var vector = new UserDefinedVector(Data);
var other = SparseVector.OfVector(vector);
for (var i = 0; i < Data.Length; i++)
{
Assert.AreEqual(vector[i], other[i]);
}
}
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]);
}
}
/// <summary>
/// List indexing is 2000x faster than Matrix.Row() or enumeration.
/// </summary>
public static void SpeedOfGetRow()
{
SparseMatrix myMatrix = new SparseMatrix(1000, 1000);
SparseVector myVector = SparseVector.OfVector(Vector.Build.Random(1000));
myVector.CoerceZero(1.8);
for (int i = 0; i < 1000; i++)
{
myMatrix.SetRow(i, myVector);
}
List <Vector <double> > myList = new List <Vector <double> >(myMatrix.EnumerateRows());
Utils.StartTimer();
for (int repeat = 0; repeat < 10; repeat++)
{
for (int i = 0; i < 1000; i++)
{
double foo = myMatrix.Row(i)[0];
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int repeat = 0; repeat < 10; repeat++)
{
foreach (var row in myMatrix.EnumerateRowsIndexed())
{
double foo = row.Item2[0];
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int repeat = 0; repeat < 10; repeat++)
{
for (int i = 0; i < 1000; i++)
{
double foo = myList[i][0];
}
}
Utils.StopTimer();
}
private List <float> forward(SparseVector input)
{
Layer[] tempLayers = new Layer[_layers.Count];
_layers.CopyTo(tempLayers);
for (int i = 0; i < tempLayers.Length; i++)
{
if (i == 0)
{
if (input.Count != tempLayers[i].Weights.ColumnCount)
{
SparseVector tmp = SparseVector.Create(tempLayers[i].Weights.ColumnCount, 1);
for (int j = 1; j < tmp.Count; j++)
{
tmp[j] = input[j - 1];
}
input = tmp;
}
tempLayers[i].Activations = SparseVector.OfVector((tempLayers[i].Weights * input));
}
else
{
if (tempLayers[i].Weights.ColumnCount != tempLayers[i - 1].Activations.Count)
{
SparseVector tmp = SparseVector.Create(tempLayers[i].Weights.ColumnCount, 1);
for (int j = 1; j < tmp.Count; j++)
{
tmp[j] = tempLayers[i - 1].Activations[j - 1];
}
tempLayers[i - 1].Activations = tmp;
}
else
{
tempLayers[i - 1].Activations[0] = 1;
}
tempLayers[i].Activations = SparseVector.OfVector((tempLayers[i].Weights * tempLayers[i - 1].Activations));
}
tempLayers[i].Activations = parallelSigmoid(tempLayers[i].Activations);
}
return(_layers.Last().Activations.ToList());
}
public void ForwardPropagation()
{
for (int i = 0; i < _layers.Count; i++)
{
if (i == 0)
{
if (Inputs.Count != _layers[i].Weights.ColumnCount)
{
SparseVector tmp = SparseVector.Create(_layers[i].Weights.ColumnCount, 1);
for (int j = 1; j < tmp.Count; j++)
{
tmp[j] = Inputs[j - 1];
}
Inputs = tmp;
}
_layers[i].Activations = SparseVector.OfVector((_layers[i].Weights * Inputs));
}
else
{
if (_layers[i].Weights.ColumnCount != _layers[i - 1].Activations.Count)
{
SparseVector tmp = SparseVector.Create(_layers[i].Weights.ColumnCount, 1);
for (int j = 1; j < tmp.Count; j++)
{
tmp[j] = _layers[i - 1].Activations[j - 1];
}
_layers[i - 1].Activations = tmp;
}
else
{
_layers[i - 1].Activations[0] = 1;
}
_layers[i].Activations = SparseVector.OfVector((_layers[i].Weights * _layers[i - 1].Activations));
}
sigmoid(ref _layers[i].Activations);
}
} //Прохождение вперёд
public void Sparsify()
{
coefficients_ = SparseVector.OfVector(coefficients_);
}
public RatingVector(Vector <double> ratingVector)
{
this.ratingVector = ratingVector.Storage.IsDense ? SparseVector.OfVector(ratingVector) : (SparseVector)ratingVector;
}
public void BalanceGurobi()
{
GRBEnv env = new GRBEnv();
GRBModel model = new GRBModel(env);
DateTime CalculationTimeStart;
DateTime CalculationTimeFinish;
double[] results = new double[measuredValues.ToArray().Length];
if (inputData.balanceSettings.balanceSettingsConstraints == BalanceSettings.BalanceSettingsConstraints.TECHNOLOGIC)
{
//Create variables
GRBVar[] varsTechnologic = new GRBVar[measuredValues.ToArray().Length];
for (int i = 0; i < varsTechnologic.Length; i++)
{
varsTechnologic[i] = model.AddVar(technologicRangeLowerBound[i], technologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
//Set objective
GRBQuadExpr objTechnologic = new GRBQuadExpr();
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(H[i, i] / 2.0, varsTechnologic[i], varsTechnologic[i]);
}
for (int i = 0; i < varsTechnologic.Length; i++)
{
objTechnologic.AddTerm(dVector[i], varsTechnologic[i]);
}
model.SetObjective(objTechnologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < incidenceMatrix.RowCount; i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < incidenceMatrix.ColumnCount; j++)
{
expr.AddTerm(incidenceMatrix[i, j], varsTechnologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
CalculationTimeStart = DateTime.Now;
model.Optimize();
CalculationTimeFinish = DateTime.Now;
results = new double[varsTechnologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsTechnologic[i].Get(GRB.DoubleAttr.X);
}
}
else
{
//Create variables
GRBVar[] varsMetrologic = new GRBVar[measuredValues.ToArray().Length];
for (int i = 0; i < varsMetrologic.Length; i++)
{
if (measureIndicator[i, i] == 0)
{
varsMetrologic[i] = model.AddVar(technologicRangeLowerBound[i], technologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
else
{
varsMetrologic[i] = model.AddVar(metrologicRangeLowerBound[i], metrologicRangeUpperBound[i], 0.0, GRB.CONTINUOUS, "x" + i);
}
}
//Set objective
GRBQuadExpr objMetroologic = new GRBQuadExpr();
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetroologic.AddTerm(H[i, i] / 2.0, varsMetrologic[i], varsMetrologic[i]);
}
for (int i = 0; i < varsMetrologic.Length; i++)
{
objMetroologic.AddTerm(dVector[i], varsMetrologic[i]);
}
model.SetObjective(objMetroologic);
//Add constraints
GRBLinExpr expr;
for (int i = 0; i < incidenceMatrix.RowCount; i++)
{
expr = new GRBLinExpr();
for (int j = 0; j < incidenceMatrix.ColumnCount; j++)
{
expr.AddTerm(incidenceMatrix[i, j], varsMetrologic[j]);
}
model.AddConstr(expr, GRB.EQUAL, 0.0, "c" + i);
}
// Optimize model
CalculationTimeStart = DateTime.Now;
model.Optimize();
CalculationTimeFinish = DateTime.Now;
results = new double[varsMetrologic.Length];
for (int i = 0; i < results.Length; i++)
{
results[i] = varsMetrologic[i].Get(GRB.DoubleAttr.X);
}
}
model.Dispose();
env.Dispose();
double disbalanceOriginal = incidenceMatrix.Multiply(measuredValues).Subtract(reconciledValues).ToArray().Euclidean();
double disbalance = incidenceMatrix.Multiply(SparseVector.OfVector(new DenseVector(results))).Subtract(reconciledValues).ToArray().Euclidean();
balanceOutput = new BalanceOutput();
balanceOutputVariables = new List <OutputVariables>();
for (int i = 0; i < results.Length; i++)
{
InputVariables outputVariable = inputData.BalanceInputVariables[i];
balanceOutputVariables.Add(new OutputVariables()
{
id = outputVariable.id,
name = outputVariable.name,
value = results[i],
source = outputVariable.sourceId,
target = outputVariable.destinationId,
upperBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeUpperBound[i] : metrologicRangeUpperBound[i],
lowerBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeLowerBound[i] : metrologicRangeLowerBound[i]
});
}
balanceOutput.CalculationTime = (CalculationTimeFinish - CalculationTimeStart).TotalSeconds;
balanceOutput.balanceOutputVariables = balanceOutputVariables;
balanceOutput.DisbalanceOriginal = disbalanceOriginal;
balanceOutput.Disbalance = disbalance;
balanceOutput.GlobaltestValue = 0.0;
balanceOutput.Status = "Success";
}
public void BalanceAccord()
{
var func = new QuadraticObjectiveFunction(H.ToArray(), dVector.ToArray());
var constraints = new List <LinearConstraint>();
//добавление ограничений узлов
for (var j = 0; j < measuredValues.ToArray().Length; j++)
{
if (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[j, j] == 0.0)
{
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].technologicLowerBound
});
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].technologicUpperBound
});
}
else
{
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.GreaterThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].metrologicLowerBound
});
constraints.Add(new LinearConstraint(1)
{
VariablesAtIndices = new[] { j },
ShouldBe = ConstraintType.LesserThanOrEqualTo,
Value = inputData.BalanceInputVariables[j].metrologicUpperBound
});
}
}
//Ограничения для решения задачи баланса
for (var j = 0; j < reconciledValues.ToArray().Length; j++)
{
var notNullElements = Array.FindAll(incidenceMatrix.ToArray().GetRow(j), x => Math.Abs(x) > 0.0000001);
var notNullElementsIndexes = new List <int>();
for (var k = 0; k < measuredValues.ToArray().Length; k++)
{
if (Math.Abs(incidenceMatrix[j, k]) > 0.0000001)
{
notNullElementsIndexes.Add(k);
}
}
constraints.Add(new LinearConstraint(notNullElements.Length)
{
VariablesAtIndices = notNullElementsIndexes.ToArray(),
CombinedAs = notNullElements,
ShouldBe = ConstraintType.EqualTo,
Value = reconciledValues[j]
});
}
var solver = new GoldfarbIdnani(func, constraints);
DateTime CalculationTimeStart = DateTime.Now;
if (!solver.Minimize())
{
throw new ApplicationException("Failed to solve balance task.");
}
DateTime CalculationTimeFinish = DateTime.Now;
double disbalanceOriginal = incidenceMatrix.Multiply(measuredValues).Subtract(reconciledValues).ToArray().Euclidean();
double disbalance = incidenceMatrix.Multiply(SparseVector.OfVector(new DenseVector(solver.Solution))).Subtract(reconciledValues).ToArray().Euclidean();
double[] solution = new double[countOfThreads];
sol = new double[countOfThreads];
for (int i = 0; i < solution.Length; i++)
{
solution[i] = solver.Solution[i];
sol[i] = solution[i];
}
balanceOutput = new BalanceOutput();
balanceOutputVariables = new List <OutputVariables>();
for (int i = 0; i < solution.Length; i++)
{
InputVariables outputVariable = inputData.BalanceInputVariables[i];
balanceOutputVariables.Add(new OutputVariables()
{
id = outputVariable.id,
name = outputVariable.name,
value = solution[i],
source = outputVariable.sourceId,
target = outputVariable.destinationId,
upperBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeUpperBound[i] : metrologicRangeUpperBound[i],
lowerBound = (inputData.balanceSettings.balanceSettingsConstraints == 0 || measureIndicator[i, i] == 0.0) ? technologicRangeLowerBound[i] : metrologicRangeLowerBound[i]
});
}
balanceOutput.CalculationTime = (CalculationTimeFinish - CalculationTimeStart).TotalSeconds;
balanceOutput.balanceOutputVariables = balanceOutputVariables;
balanceOutput.DisbalanceOriginal = disbalanceOriginal;
balanceOutput.Disbalance = disbalance;
balanceOutput.GlobaltestValue = GTR;
balanceOutput.Status = "Success";
}
/// <summary>
/// 2D nested list is 10x faster than SparseMatrix and List<SparseVector>
/// and 100x faster than Dictionary. However, 2D nested list is only for dense case.
/// Note that Nested Dictionary is faster than Tuple dictionary!
/// it is the second fastest only 4 times slower than 2D list.
/// </summary>
public static void SpeedOfAccessRandomElement()
{
SparseMatrix myMatrix = new SparseMatrix(1000, 1000);
SparseVector myVector = SparseVector.OfVector(Vector.Build.Random(1000));
myVector.CoerceZero(1.8);
for (int i = 0; i < 1000; i++)
{
myMatrix.SetRow(i, myVector);
}
List <Vector <double> > myList = new List <Vector <double> >(myMatrix.EnumerateRows());
List <List <double> > my2DList = new List <List <double> >();
Dictionary <Tuple <int, int>, double> myDict = new Dictionary <Tuple <int, int>, double>();
Dictionary <int, Dictionary <int, double> > myDict2 =
new Dictionary <int, Dictionary <int, double> >();
for (int i = 0; i < 1000; i++)
{
myDict2[i] = new Dictionary <int, double>();
for (int j = 0; j < 1000; j++)
{
myDict[new Tuple <int, int>(i, j)] = i;
myDict2[i][j] = i;
}
}
for (int i = 0; i < 1000; i++)
{
my2DList.Add(new List <double>());
for (int j = 0; j < 1000; j++)
{
my2DList[i].Add(i);
}
}
Utils.StartTimer();
for (int i = 0; i < 1000; i++)
{
for (int j = 0; j < 1000; j++)
{
double foo = myDict[new Tuple <int, int>(i, j)];
myDict[new Tuple <int, int>(i, j)] = foo + 1;
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int i = 0; i < 1000; i++)
{
for (int j = 0; j < 1000; j++)
{
double foo = myDict2[i][j];
myDict2[i][j] = foo + 1;
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int i = 0; i < 1000; i++)
{
for (int j = 0; j < 1000; j++)
{
double foo = myMatrix[i, j];
myMatrix[i, j] = foo + 1;
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int i = 0; i < 1000; i++)
{
for (int j = 0; j < 1000; j++)
{
double foo = myList[i][j];
myList[i][j] = foo + 1;
}
}
Utils.StopTimer();
Utils.StartTimer();
for (int i = 0; i < 1000; i++)
{
for (int j = 0; j < 1000; j++)
{
double foo = my2DList[i][j];
my2DList[i][j] = foo + 1;
}
}
Utils.StopTimer();
Utils.Pause();
}
