static AsthmaModel.Beliefs[] RunTraining(
AllergenData data,
int[] numberSensitizationClasses,
bool showFactorGraph = false)
{
AsthmaModel.Beliefs[] result = new AsthmaModel.Beliefs[numberSensitizationClasses.Length];
AsthmaModel[] model = Util.ArrayInit(
numberSensitizationClasses.Length,
n => new AsthmaModel("AsthmaTrainingModel_" + numberSensitizationClasses[n])
{
Iterations = AsthmaModelIterations // Increase this for more classes.
});
Console.WriteLine("Model iteration progress");
var reporter = new ConsoleMultiProgressReporter(
Util.ArrayInit(numberSensitizationClasses.Length, n => "AsthmaTrainingModel_" + numberSensitizationClasses[n]),
Util.ArrayInit(numberSensitizationClasses.Length, n => AsthmaModelIterations));
// Randomly initialize messages externally to parallel loop so we remain deterministic.
for (int n = 0; n < numberSensitizationClasses.Length; n++)
{
int idx = n; // for closure to work
model[n].InitializeMessages(data, numberSensitizationClasses[n]);
model[n].ProgressChanged += (e, p) => reporter.UpdateProgress(idx, p.Iteration + 1);
}
Parallel.For(0, numberSensitizationClasses.Length, n =>
{
result[n] = model[n].Run(data, numberSensitizationClasses[n], initializeMessages: false, showFactorGraph: showFactorGraph);
});
return(result);
}
public static Dictionary <string, IList> GetConditionalProbsOfPositiveTest(AsthmaModel.Beliefs beliefs)
{
var result = new Dictionary <string, IList>();
result[""] = new List <string> {
"Prob. of Pos. Skin Test", "Prob. of Pos. IgE Test",
};
result["If Sensitized"] = new List <Beta> {
beliefs.ProbSkinIfSensitized, beliefs.ProbIgEIfSensitized
};
result["If Not Sensitized"] = new List <Beta> {
beliefs.ProbSkinIfNotSensitized, beliefs.ProbIgEIfNotSensitized
};
return(result);
}
public static Dictionary <string, Dictionary <string, Dictionary <string, double> > > GetSensitizationPerYearPerClass(AsthmaModel.Beliefs beliefs, List <string> allergens, bool usePercentages = false)
{
int nY = AllergenData.NumYears;
int nA = allergens.Count;
var childVulnerabilityClass = beliefs.VulnerabilityClass.Select(cl => cl.GetMode()).ToArray();
var classCount = Enumerable.Range(0, beliefs.NumberOfClasses).Select(c => childVulnerabilityClass.Count(childVuln => childVuln == c)).ToArray();
var sortedClassIndices = classCount.Select((classCnt, classIndex) => new { classCnt, classIndex }).OrderByDescending(ci => ci.classCnt).Select(ic => ic.classIndex).ToArray();
string[] keys = BuildKeys(sortedClassIndices.Select(idx => classCount[idx]).ToArray());
var percentInverseClassCount = classCount.Select(cnt => 100.0 / cnt).ToArray();
return(Enumerable.Range(0, beliefs.NumberOfClasses).ToDictionary(
cx => keys[cx].ToString(),
cx =>
{
int c = sortedClassIndices[cx];
var indicesInClass = Enumerable.Range(0, beliefs.NumberOfChildren).Where(childIndex => childVulnerabilityClass[childIndex] == c);
// The sensitivity counts accumulated over allergens
var sensitivityExpectationsAccumOverAllergens = indicesInClass.Select(childIndex =>
Enumerable.Range(0, nY).Select(
y => Enumerable.Range(0, nA).Sum(a => beliefs.Sensitization[y][childIndex, a].GetProbTrue())).ToArray());
return Enumerable.Range(0, seriesNamesForSensitizationPlots.Length).ToDictionary(
s => seriesNamesForSensitizationPlots[s],
s => Enumerable.Range(0, nY).ToDictionary(
y => AllergenData.Years[y],
y => (usePercentages ? percentInverseClassCount[c] : 1.0) * sensitivityExpectationsAccumOverAllergens.Count(sc => sc[y] >= lowCutoffsForSensitizationPlots[s] && sc[y] < highCutoffsForSensitizationPlots[s])));
}));
}
public static Dictionary <string, Dictionary <string, PointWithBounds[]> > GetTransitionProbabilities(AsthmaModel.Beliefs beliefs, bool getRetain, List <string> allergens)
{
int nY = AllergenData.NumYears;
int nA = allergens.Count;
var childVulnerabilityClass = beliefs.VulnerabilityClass.Select(cl => cl.GetMode()).ToArray();
var classCount = Enumerable.Range(0, beliefs.NumberOfClasses).Select(c => childVulnerabilityClass.Count(childVuln => childVuln == c)).ToArray();
var sortedClassIndices = classCount.Select((classCnt, classIndex) => new { classCnt, classIndex }).OrderByDescending(ci => ci.classCnt).Select(ic => ic.classIndex).ToArray();
string[] keys = BuildKeys(sortedClassIndices.Select(idx => classCount[idx]).ToArray());
return(Enumerable.Range(0, beliefs.NumberOfClasses).ToDictionary(
cx => keys[cx].ToString(),
cx =>
{
return Enumerable.Range(0, nA).ToDictionary(
a => allergens[a],
a =>
{
int startY = getRetain ? 1 : 0;
int c = sortedClassIndices[cx];
return Enumerable.Range(startY, nY - startY).Select(
y =>
{
var beta = y == 0 ?
beliefs.ProbSensitizationAgeOne[a, c] :
getRetain ? beliefs.ProbRetainSensitization[y][a, c] : beliefs.ProbGainSensitization[y][a, c];
return new PointWithBounds(
int.Parse(AllergenData.Years[y]),
beta.GetMean(),
BetaQuantile(beta, 0.25),
BetaQuantile(beta, 0.75));
}).ToArray();
});
}
));
}
public static Dictionary <string, Dictionary <string, string> > GetPlusMinusStringChildrenWithOutcome(AsthmaModel.Beliefs beliefs, AllergenData data, int[] outcomeIndicesToPlot)
{
var childrenCountsPerOutcome = getChildrenCountsPerOutcome(beliefs, data, outcomeIndicesToPlot);
return(childrenCountsPerOutcome.ToDictionary(
kvp => kvp.Key, kvp => kvp.Value.ToDictionary(
kvp1 => kvp1.Key,
kvp1 => PlusMinusString(new Beta(kvp1.Value.Item1 + 1, kvp1.Value.Item2 + 1)))));
}
public static Dictionary <string, Dictionary <string, double> > GetPercentageChildrenWithOutcome(AsthmaModel.Beliefs beliefs, AllergenData data, int[] outcomeIndicesToPlot)
{
var childrenCountsPerOutcome = getChildrenCountsPerOutcome(beliefs, data, outcomeIndicesToPlot);
return(childrenCountsPerOutcome.ToDictionary(
kvp => kvp.Key, kvp => kvp.Value.ToDictionary(
kvp1 => kvp1.Key,
kvp1 =>
{
var denom = kvp1.Value.Item1 + kvp1.Value.Item2;
return denom == 0.0 ? 0.0 : 100.00 * kvp1.Value.Item1 / denom;
})));
}
private static Dictionary <string, Dictionary <string, Tuple <double, double, double> > > getChildrenCountsPerOutcome(AsthmaModel.Beliefs beliefs, AllergenData data, int[] outcomeIndicesToPlot)
{
var childVulnerabilityClass = beliefs.VulnerabilityClass.Select(cl => cl.GetMode()).ToArray();
var classCount = Enumerable.Range(0, beliefs.NumberOfClasses).Select(c => childVulnerabilityClass.Count(childVuln => childVuln == c)).ToArray();
var sortedClassIndices = classCount.Select((classCnt, classIndex) => new { classCnt, classIndex }).OrderByDescending(ci => ci.classCnt).Select(ic => ic.classIndex).ToArray();
return(Enumerable.Range(0, beliefs.NumberOfClasses).Where(cx => classCount[sortedClassIndices[cx]] > 0).ToDictionary(
cx => "Class " + cx.ToString(),
cx =>
{
int c = sortedClassIndices[cx];
var indicesInClass = Enumerable.Range(0, beliefs.NumberOfChildren).Where(childIndex => childVulnerabilityClass[childIndex] == c);
return Enumerable.Range(0, outcomeIndicesToPlot.Length).ToDictionary(
o => data.OutcomeIndexToOutcomeName[outcomeIndicesToPlot[o]],
o =>
{
int oIdx = outcomeIndicesToPlot[o];
var postiveCount = indicesInClass.Count(childIndex => data.Outcomes[oIdx][childIndex] != null && data.Outcomes[oIdx][childIndex].Value == 1);
var negativeCount = indicesInClass.Count(childIndex => data.Outcomes[oIdx][childIndex] != null && data.Outcomes[oIdx][childIndex].Value == 0);
var nullCount = indicesInClass.Count(childIndex => data.Outcomes[oIdx][childIndex] == null);
return Tuple.Create((double)postiveCount, (double)negativeCount, (double)nullCount);
});
}));
}
public static Dictionary <string, Dictionary <string, Dictionary <string, double> > > GetNumberOfChildrenWithInferredSensitization(AsthmaModel.Beliefs beliefs, List <string> allergens, bool usePercentages = false)
{
int nY = AllergenData.NumYears;
int nA = allergens.Count;
var childVulnerabilityClass = beliefs.VulnerabilityClass.Select(cl => cl.GetMode()).ToArray();
var classCount = Enumerable.Range(0, beliefs.NumberOfClasses).Select(c => childVulnerabilityClass.Count(childVuln => childVuln == c)).ToArray();
var sortedClassIndices = classCount.Select((classCnt, classIndex) => new { classCnt, classIndex }).OrderByDescending(ci => ci.classCnt).Select(ic => ic.classIndex).ToArray();
string[] keys = BuildKeys(sortedClassIndices.Select(idx => classCount[idx]).ToArray());
var percentInverseClassCount = classCount.Select(cnt => 100.0 / cnt).ToArray();
return(Enumerable.Range(0, beliefs.NumberOfClasses).ToDictionary(
cx => keys[cx].ToString(),
cx =>
{
int c = sortedClassIndices[cx];
var indicesInClass = Enumerable.Range(0, beliefs.NumberOfChildren).Where(childIndex => childVulnerabilityClass[childIndex] == c);
return Enumerable.Range(0, nY).ToDictionary(
y => $"Age {AllergenData.Years[y]}",
y => Enumerable.Range(0, nA).ToDictionary(
a => allergens[a],
a => (usePercentages ? percentInverseClassCount[c] : 1.0) * indicesInClass.Count(childIndex => beliefs.Sensitization[y][childIndex, a].GetProbTrue() > 0.5)));
}));
}
