public void UpdateColumn(int index, IIndexableVector vector, int rowIndex)
{
for (var i = 0; i < vector.Count; i++)
{
_matrix[rowIndex + i, index] = vector[i];
}
}
//public void Normalise(MatrixGrouping group, NormalisationType type)
//{
// if (type == NormalisationType.FeatureScale) {
// IEnumerable<Vector<float>> list = (group == MatrixGrouping.ByRow) ? _matrix.EnumerateRows() : _matrix.EnumerateColumns();
// var norm = list.Select(row => {
// float min = 0f, max = 0f;
// foreach (var val in row.Enumerate(Zeros.AllowSkip)) {
// if (val > max)
// max = val;
// if (val < min)
// min = val;
// }
// float range = max - min;
// return Tuple.Create(min, range);
// }).ToList();
// if (group == MatrixGrouping.ByRow)
// _matrix.MapIndexedInplace((x, y, v) => norm[x].Item2 > 0 ? (v - norm[x].Item1) / norm[x].Item2 : v);
// else
// _matrix.MapIndexedInplace((x, y, v) => norm[y].Item2 > 0 ? (v - norm[y].Item1) / norm[y].Item2 : v);
// }
// else if(type == NormalisationType.Standard) {
// IEnumerable<Vector<float>> list = (group == MatrixGrouping.ByRow) ? _matrix.EnumerateRows() : _matrix.EnumerateColumns();
// var norm = list.Select(row => {
// var mean = row.Average();
// var stdDev = Convert.ToSingle(Math.Sqrt(row.Average(c => Math.Pow(c - mean, 2))));
// return Tuple.Create(mean, stdDev);
// }).ToList();
// if(group == MatrixGrouping.ByRow)
// _matrix.MapIndexedInplace((x, y, v) => norm[x].Item2 != 0 ? (v - norm[x].Item1) / norm[x].Item2 : v);
// else
// _matrix.MapIndexedInplace((x, y, v) => norm[y].Item2 != 0 ? (v - norm[y].Item1) / norm[y].Item2 : v);
// }else if(type == NormalisationType.Euclidean || type == NormalisationType.Infinity || type == NormalisationType.Manhattan) {
// var p = (type == NormalisationType.Manhattan) ? 1.0 : (type == NormalisationType.Manhattan) ? 2.0 : double.PositiveInfinity;
// var norm = (group == MatrixGrouping.ByColumn) ? _matrix.NormalizeColumns(p) : _matrix.NormalizeRows(p);
// norm.CopyTo(_matrix);
// }
//}
public void UpdateRow(int index, IIndexableVector vector, int columnIndex)
{
for (var i = 0; i < vector.Count; i++)
{
_matrix[index, columnIndex + i] = vector[i];
}
}
public static void AssertEqual(IIndexableVector v1, IIndexableVector v2, int maxDifference = 6)
{
Assert.AreEqual(v1.Count, v2.Count);
for (var i = 0; i < v1.Count; i++)
{
AssertEqual(v1[i], v2[i], maxDifference);
}
}
public void UpdateRow(int index, IIndexableVector vector, int columnIndex)
{
Debug.Assert(IsValid);
// TODO: use faster BLAS routine
for (var i = 0; i < vector.Count; i++)
{
_data[(columnIndex + i) * _rows + index] = vector[i];
}
}
public void UpdateColumn(int index, IIndexableVector vector, int rowIndex)
{
Debug.Assert(IsValid);
// TODO: use faster BLAS routine
for (var i = 0; i < vector.Count; i++)
{
_data[index * _rows + rowIndex + i] = vector[i];
}
}
public float Compute(IIndexableVector output, IIndexableVector expectedOutput)
{
float ret = 0;
for (var i = 0; i < output.Count; i++)
{
var val = (output[i] >= 0.5) ? 1.0f : 0.0f;
ret += (val == expectedOutput[i]) ? 1.0f : 0.0f;
}
return(ret / output.Count);
}
public float Compute(IIndexableVector output, IIndexableVector expectedOutput)
{
float ret = 0;
var len = output.Count;
for (var i = 0; i < len; i++)
{
var a = output[i];
var y = expectedOutput[i];
ret += BoundMath.Constrain(-y * BoundMath.Log(a) - (1.0f - y) * BoundMath.Log(1.0f - a));
}
return(ret / len);
}
public float Compute(IIndexableVector output, IIndexableVector expectedOutput)
{
using (var diff = output.Subtract(expectedOutput))
return(0.5f * BoundMath.Pow(diff.L2Norm(), 2));
}
public float Compute(IIndexableVector output, IIndexableVector expectedOutput)
{
return(Convert.ToSingle(Math.Sqrt(output.Values.Zip(expectedOutput.Values, (d1, d2) => Math.Pow(d1 - d2, 2)).Average())));
}
public IVector Create(IIndexableVector vector)
{
return(Create(vector.Count, x => vector[x]));
}
public FeedForwardOutput(IIndexableVector output, IIndexableVector expectedOutput)
{
Output = output;
ExpectedOutput = expectedOutput;
}
/// <summary>
/// Create a vector
/// </summary>
/// <param name="lap"></param>
/// <param name="data">Indexable vector to copy</param>
/// <returns></returns>
public static IVector CreateVector(this ILinearAlgebraProvider lap, IIndexableVector data)
{
return(lap.CreateVector(data.Count, i => data[i]));
}
public GpuVector(CudaProvider cuda, IIndexableVector vector) : this(cuda, vector.Count, i => vector[i])
{
}
public RecurrentOutput(IIndexableVector output, IIndexableVector memory)
{
Output = output;
Memory = memory;
}
public float Compute(IIndexableVector output, IIndexableVector expectedOutput)
{
return(output.MaximumIndex() == expectedOutput.MaximumIndex() ? 1f : 0f);
}
public RecurrentExecutionResults(IIndexableVector output, IIndexableVector target, IIndexableVector memory)
{
Output = output; ExpectedOutput = target; Memory = memory;
}
