public static Character CreateCharacter(Skeleton skeleton, Matrix<double> kinectToGlobal)
{
Character res = new Character();
res.Position = kinectToGlobal.Multiply(new DenseVector(new double[] { skeleton.Position.X, skeleton.Position.Y, skeleton.Position.Z }));
var rightHand = skeleton.Joints[JointType.HandRight];
res.Position = kinectToGlobal.Multiply(new DenseVector(new double[] { rightHand.Position.X, rightHand.Position.Y, rightHand.Position.Z }));
return res;
}
/// <summary>
/// Decision function of the linear model.
/// </summary>
/// <param name="x">(n_samples, n_features)Samples.</param>
/// <returns>Predicted values.</returns>
public Matrix<double> DecisionFunction(Matrix<double> x)
{
int nFeatures = this.Coef.ColumnCount;
if (x.ColumnCount != nFeatures)
{
throw new ArgumentException(
string.Format(
"X has {0} features per sample; expecting {1}",
x.ColumnCount,
nFeatures));
}
// todo: use TransposeAndMultiply. But there's bug in Math.Net
// which appears with sparse matrices.
var tmp = x.Multiply(this.Coef.Transpose());
tmp.AddRowVector(this.Intercept, tmp);
//tmp.MapIndexedInplace((i, j, v) => v + this.InterceptVector[j]);
return tmp;
}
public static Vector<double> GetWeights(Matrix<double> data, Vector<double> targetClassification)
{
var features = data.ColumnCount;
// these are things we are trying to solve for
Vector<double> weights = DenseVector.Create(features, i => 1.0);
var alpha = 0.001;
foreach (var cycle in Enumerable.Range(0, 500))
{
#region Sigmoid Explanation
/*
* multiply all the data by the weights, this gives you the estimation of the current function
* given the weights. multiplying by the sigmoid moves a point into one class vs the other
* if its larger than 0.5 it'll be in class 1, if its smaller than it'll be in class 0. The closer it is
* to 1 means that with the given weights that value is highly probably to be in class 1.
*
* it doesn't matter if the instance is the class the sigmoid says it is,
* the error will shift the weights gradient so over the iterations of the cycles
* the weights will move the final data point towards its actual expected class
*
* for example, if there is a data point with values
*
* [1.0, -0.017612, 14.053064]
*
* where value 1 is the initial weight factor, and values 2 and 3 are the x y coordinates
*
* and lets say the point is categorized at class 0.
*
* Calculating the initial sigma gives you something like 0.9999998
*
* which says its class 1, but thats obviously wrong. However, the error rate here is large
*
* meaning that the gradient wants to move towards the expected data.
*
* As you run the ascent this data point will get smaller and smaller and eventually
*
* the sigmoid will classify it properly
*/
#endregion
var currentData = DenseVector.OfEnumerable(data.Multiply(weights).Select(Sigmoid));
#region Error Explanation
// find out how far off we are from the actual expectation. this is
// like the x2 - x1 part of a derivative
#endregion
var error = targetClassification.Subtract(currentData);
#region Gradient Explanation
// this gives you the direction of change from the current
// set of data. At this point every point is moving in the direction
// of the error rate. A large error means we are far off and trying to move
// towards the actual data, a low error rate means we are really close
// to the target data (so the gradient will be smaller, meaning less delta)
#endregion
var gradient = data.Transpose() * error;
#region Weights Update Explanation
// multiplying by alpha means we'll take a small step in the direction
// of the gradient and add it to the current weights. An initial weights of 1.0
// means we're going to start at the current location of where we are.
#endregion
weights = weights + alpha * gradient;
}
return weights;
}
/// <summary>
/// Multiplies each element of the matrix by a scalar and places results into the result matrix.
/// </summary>
/// <param name="scalar">The scalar to multiply the matrix with.</param>
/// <param name="result">The matrix to multiply.</param>
/// <exception cref="ArgumentNullException">If the result matrix is <see langword="null" />.</exception>
/// <exception cref="ArgumentException">If the result matrix's dimensions are not the same as this matrix.</exception>
public virtual void Multiply(double scalar, Matrix result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
if (result.RowCount != RowCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension, "result");
}
if (result.ColumnCount != ColumnCount)
{
throw new ArgumentException(Resources.ArgumentMatrixSameColumnDimension, "result");
}
CopyTo(result);
result.Multiply(scalar);
}
private Vector MultiplyByIndex(Matrix RightM, Vector LeftV, List<int> Index)
{
Vector leftVector = new DenseVector(Index.Count);
int i = 0;
foreach (int index in Index)
{
leftVector[i] = LeftV[index];
i++;
}
leftVector = (Vector)RightM.Multiply(leftVector);
return leftVector;
}