private double CalculateZExpectationsScaled()
{
CalculatePredScaled();
var residuals = ArrayMath.Pow(dys - predY, 2.0);
var residuals1 = residuals / (-2 * dsds[0] * dsds[0]);
//Console.WriteLine(residuals);
var residuals2 = residuals / (-2 * dsds[1] * dsds[1]);
//Console.WriteLine(dsds[1]);
var weights = dpAs.ElementDivide(dsds);
var t1 = weights[0] * ArrayMath.Exp(residuals1);
var t2 = weights[1] * ArrayMath.Exp(residuals2);
var l = t1.Zip(t2, (x, y) => (x + y));
var ll = l.Select(x => Math.Log(x)).Sum();
var denom = t1 + t2;
t1 = t1.ElementDivide(denom);
t2 = t2.ElementDivide(denom);
for (int i = 0; i < ys.Length; i++)
{
zs[i, 0] = t1[i];
zs[i, 1] = t2[i];
}
//return the log likelihood
return(ll);
}
public virtual double[] GetConditionalDistribution(int[] sequence, int position)
{
double[] probs = ScoresOf(sequence, position);
ArrayMath.LogNormalize(probs);
probs = ArrayMath.Exp(probs);
//System.out.println(this);
return(probs);
}
public virtual void TestExpLog()
{
double[] d1prime = ArrayMath.Log(ArrayMath.Exp(d1));
double[] diff = ArrayMath.PairwiseSubtract(d1, d1prime);
double norm2 = ArrayMath.Norm(diff);
NUnit.Framework.Assert.AreEqual(norm2, 1e-5, 0.0);
}
// SEQUENCE MODEL METHODS
/// <summary>
/// Computes the distribution over values of the element at position pos in the
/// sequence, conditioned on the values of the elements in all other positions
/// of the provided sequence.
/// </summary>
/// <param name="sequence">the sequence containing the rest of the values to condition on</param>
/// <param name="position">the position of the element to give a distribution for</param>
/// <returns>
/// an array of type double, representing a probability distribution;
/// sums to 1.0
/// </returns>
public virtual double[] GetConditionalDistribution(int[] sequence, int position)
{
double[] result = ScoresOf(sequence, position);
ArrayMath.LogNormalize(result);
// System.out.println("marginal: " + ArrayMath.toString(marginal,
// nf));
// System.out.println("conditional: " + ArrayMath.toString(result,
// nf));
result = ArrayMath.Exp(result);
// System.out.println("conditional: " + ArrayMath.toString(result,
// nf));
return(result);
}
//The E Step
private double CalculateZExpectations()
{
//OLDER VALIDATION CODE
//Console.WriteLine(InitialPopSize);
//Console.WriteLine(GrowthRate);
//int n = xs.Length;
//double[] residualsaa = (xs.Zip(ys, (x,y)=>Math.Pow((y-InitialPopSize*Math.Exp(x*GrowthRate)),2.0)).ToArray());
//double var1 = -2 * sds[0] * sds[0];
//double var2 = -2 * sds[1] * sds[1];
//var residuals1a = residualsaa.Select(x =>x/ var1).ToArray();
//var residuals2a = residualsaa.Select(x => x / var2).ToArray();
//double w1 = Passignments[0] / sds[0];
//double w2 = Passignments[1] / sds[1];
//double loglik=0;
//for (int i = 0; i < n; i++)
//{
// loglik += Math.Log(w1 * Math.Exp(residuals1a[i]) + w2 * Math.Exp(residuals2a[i]));
//}
CalculatePred();
var residuals = ArrayMath.Pow(dys - predY, 2.0);
var residuals1 = residuals / (-2 * dsds[0] * dsds[0]);
//Console.WriteLine(residuals);
var residuals2 = residuals / (-2 * dsds[1] * dsds[1]);
//Console.WriteLine(dsds[1]);
var weights = dpAs.ElementDivide(dsds);
var t1 = weights[0] * ArrayMath.Exp(residuals1);
var t2 = weights[1] * ArrayMath.Exp(residuals2);
var l = t1.Zip(t2, (x, y) => (x + y));
var ll = l.Select(x => Math.Log(x)).Sum();
var denom = t1 + t2;
t1 = t1.ElementDivide(denom);
t2 = t2.ElementDivide(denom);
for (int i = 0; i < ys.Length; i++)
{
zs[i, 0] = t1[i];
zs[i, 1] = t2[i];
}
//return the log likelihood
return(ll);
}
//private double GetDerivativesLBFGS(Vector value, ref Vector grad)
//{
// double A = value[(int)ParametersIndex.P0Index];
// double r = value[(int)ParametersIndex.rIndex];
// //First the R Gradient
// double rGradient = 0.0;
// double AGradient = 0.0;
// double ss = 0.0;
// for (int i = 0; i < xs.Length; i++)
// {
// for (int j = 0; j < 2; j++)
// {
// double cy = ys[i];
// double cx = xs[i];
// double cz = zs[i, j];
// double csd = sds[j];
// double cvd = Math.Pow(csd, 2.0);
// double ercx = Math.Exp(r * cx);
// //ss += -cz*(Math.Log(Passignments[j])-Math.Log(csd)-.5*Math.Pow(cy - A * ercx, 2)/(2*cvd));
// ss += cz * Math.Pow(cy - A * ercx, 2) / (2 * cvd);
// rGradient += (-cz * (cy - A * ercx) * A * cx * ercx) / cvd;
// AGradient += (-cz * (cy - A * ercx) * ercx) / cvd;
// }
// }
// grad[(int)ParametersIndex.P0Index] = AGradient;
// grad[(int)ParametersIndex.rIndex] = rGradient;
// // Qualities.Add(ss);
// //var b = grad.ToList();
// // b.ForEach(x => Math.Pow(x, 2));
// // Gradients.Add(b.Sum() / 2);
// return ss;
//}
private void CalculatePredLog()
{
predY = Math.Exp(InitialPopSize) * ArrayMath.Exp(dxs * Math.Exp(GrowthRate));
}
/// <summary>
/// OLDER METHODS
/// </summary>
/// <param name="value"></param>
/// <param name="grad"></param>
/// <returns></returns>
///
private void CalculatePred()
{
predY = InitialPopSize * ArrayMath.Exp(dxs * GrowthRate);
}
public static double[] CalculateSigmoids(double[][] weights, int[] featureIndices, double[] featureValues)
{
return(ArrayMath.Exp(CalculateSums(weights, featureIndices, featureValues)));
}
