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