public void ValidateSufficientStatisticsCompareTo() { SufficientStatistics suffStat = SufficientStatistics.Parse("1"); SufficientStatistics suffStat2 = SufficientStatistics.Parse("2"); Assert.AreEqual(-1, suffStat.CompareTo(suffStat2)); }
public void ValidateSufficientStatisticsGetHashCode() { // Not used anymore - changes with each .NET release. SufficientStatistics boolStat1 = SufficientStatistics.Parse("1"); Assert.AreEqual(372029325, boolStat1.GetHashCode()); }
public void ValidateBooleanStatisticsTryParse() { SufficientStatistics result = null; BooleanStatistics boolStat = BooleanStatistics.GetInstance(true); Assert.IsTrue(BooleanStatistics.TryParse("true", out result)); Assert.IsTrue(boolStat.Equals(result)); }
public void ValidateSufficientStatisticsTryParse() { SufficientStatistics result = null; SufficientStatistics continousStat = SufficientStatistics.Parse("1"); Assert.IsTrue(SufficientStatistics.TryParse("1.25658", out result)); Assert.IsFalse(continousStat.Equals(result)); }
public void ValidateDiscreteStatisticsTryParse() { SufficientStatistics result = null; DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1); Assert.IsTrue(DiscreteStatistics.TryParse("1", out result)); Assert.IsTrue(discreteStat.Equals(result)); }
public void ValidateGaussianStatisticsTryParse() { SufficientStatistics result = null; GaussianStatistics gaussStat = GaussianStatistics.GetInstance(1.1, 2.3, 5); Assert.IsTrue(GaussianStatistics.TryParse("1.1,2.3,5", out result)); Assert.IsTrue(gaussStat.Equals(result)); }
public void ValidateContinuousStatisticsTryParse() { SufficientStatistics result = null; ContinuousStatistics continousStat = ContinuousStatistics.GetInstance(1.25658); Assert.IsTrue(ContinuousStatistics.TryParse("1.25658", out result)); Assert.IsTrue(continousStat.Equals(result)); }
/// <summary> /// Compares object with Is Missing. /// </summary> /// <param name="stats">Sufficient Statistics.</param> /// <returns>Returns true if fount equals.</returns> public override bool Equals(SufficientStatistics stats) { if (stats == null) { return false; } return stats.IsMissing(); }
public void ValidateMissingStatisticsTryParse() { SufficientStatistics result = null; MissingStatistics missingStat = MissingStatistics.GetInstance; Assert.IsTrue(MissingStatistics.TryParse("?", out result)); Assert.IsTrue(missingStat.Equals(result)); Assert.IsTrue(MissingStatistics.TryParse("missing", out result)); Assert.IsTrue(missingStat.Equals(result)); }
/// <summary> /// Create Matrix from positional sequence variation. /// </summary> /// <typeparam name="TRow">Row type of matrix.</typeparam> /// <typeparam name="TCol">Column type of matrix</typeparam> /// <typeparam name="TVal">Value of matrix.</typeparam> /// <param name="sequences">List of List of positional sequence variation.</param> /// <param name="headerValues">Values of column headers of matrix</param> /// <param name="keepOneValueVariables">Keeps variables with single value only.</param> /// <param name="matrix">The matrix created</param> /// <returns>True if the function was able to create a matrix from the information in the file; otherwise, false</returns> private static bool TryCreateMatrix <TRow, TCol, TVal>( IList <IList <IList <byte> > > sequences, IEnumerable <string> headerValues, bool keepOneValueVariables, out Matrix <TRow, TCol, TVal> matrix) { IList <string> columnValues; int maxLength = sequences.Max(seq => seq.Count); HashSet <byte>[] positionalAminoAcidDistribution = new HashSet <byte> [maxLength]; foreach (IList <IList <byte> > sequence in sequences) { for (int pos = 0; pos < sequence.Count; pos++) { if (positionalAminoAcidDistribution[pos] == null) { positionalAminoAcidDistribution[pos] = new HashSet <byte>(sequence[pos]); } else { positionalAminoAcidDistribution[pos].AddNewOrOldRange(sequence[pos]); } } } IList <List <SufficientStatistics> > statistics = CreateSequenceStatistics( positionalAminoAcidDistribution, sequences, keepOneValueVariables, out columnValues); if (ColumnType == WriteType.MultiState) { ConvertBinaryToMultistate(statistics, columnValues); } SufficientStatistics[,] matrixValues = new SufficientStatistics[statistics.Count, sequences.Count]; for (int i = 0; i < statistics.Count; i++) { for (int j = 0; j < sequences.Count; j++) { matrixValues[i, j] = statistics[i][j]; } } matrix = new DenseMatrix <string, string, SufficientStatistics>( matrixValues, columnValues, headerValues, MissingStatistics.GetInstance) as DenseMatrix <TRow, TCol, TVal>; if (matrix == null) { return(false); } else { return(true); } }
public void ValidateBooleanStatisticsConvertToBooleanStatistics() { BooleanStatistics boolStat1 = BooleanStatistics.GetInstance(true); SufficientStatistics suffStats = (SufficientStatistics)boolStat1; Dictionary <string, SufficientStatistics> testSuffStats = new Dictionary <string, SufficientStatistics>(); testSuffStats.Add("Test", suffStats); Dictionary <string, BooleanStatistics> boolStats = BooleanStatistics.ConvertToBooleanStatistics(testSuffStats); Assert.AreEqual(boolStat1, boolStats["Test"]); }
/// <summary> /// Try Parse the value. /// </summary> /// <param name="val">The Value.</param> /// <param name="result">Sufficient Statistics result.</param> /// <returns>Returns true if parsed properly.</returns> new public static bool TryParse(string val, out SufficientStatistics result) { result = null; if (string.IsNullOrEmpty(val) || val.Equals("missing", StringComparison.CurrentCultureIgnoreCase) || val.Equals("?", StringComparison.CurrentCultureIgnoreCase)) { result = GetInstance; } return result != null; }
/// <summary> /// Try Parse. /// </summary> /// <param name="val">Value String.</param> /// <param name="result">Sufficient Statistics.</param> /// <returns>Return true in parsed properly.</returns> new public static bool TryParse(string val, out SufficientStatistics result) { double valAsDouble; if (double.TryParse(val, out valAsDouble)) { result = ContinuousStatistics.GetInstance(valAsDouble); return true; } else { result = null; return false; } }
public static bool TryGetDenseAnsiInstance(string filename, SufficientStatistics missingValue, ParallelOptions parallelOptions, out Matrix <string, string, SufficientStatistics> matrix) { matrix = null; Matrix <string, string, char> sscMatrix; if (!DenseAnsi.TryGetInstance(filename, '?', parallelOptions, out sscMatrix)) { return(false); } matrix = sscMatrix.ConvertValueView(MBT.Escience.ValueConverter.CharToSufficientStatistics, missingValue); //matrix = sscMatrix.ConvertValueView(new ValueConverter<char, SufficientStatistics>(c => DiscreteStatistics.GetInstance((int)c), ss => (char)ss.AsDiscreteStatistics()), missingValue); return(true); }
public void ValidateStatisticsListGetInstance() { GaussianStatistics gaussStat = GaussianStatistics.GetInstance(2.33, 1.256, 7); DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1); StatisticsList statList = StatisticsList.GetInstance(gaussStat); statList.Add(discreteStat); SufficientStatistics result = null; foreach (SufficientStatistics stat in statList) { Assert.IsTrue(SufficientStatistics.TryParse(stat.ToString(), out result)); } }
/// <summary> /// Try to Parse the value. /// </summary> /// <param name="val">The value.</param> /// <param name="result">Sufficient Statistics result.</param> /// <returns>Returns true if parsed properly.</returns> new public static bool TryParse(string val, out SufficientStatistics result) { int valAsInt; if (int.TryParse(val, out valAsInt)) { result = DiscreteStatistics.GetInstance(valAsInt); return true; } else { result = null; return false; } }
public void ValidateContinuousStatisticsEquals() { SufficientStatistics suffStat = ContinuousStatistics.GetInstance(2); ContinuousStatistics continousStat = ContinuousStatistics.GetMissingInstance; Assert.IsFalse(continousStat.Equals(suffStat)); suffStat = (SufficientStatistics)continousStat; Assert.IsTrue(continousStat.Equals(suffStat)); continousStat = ContinuousStatistics.GetInstance(1.23565); suffStat = (SufficientStatistics)continousStat; Assert.IsTrue(continousStat.Equals(suffStat)); object suffStatObj = (object)continousStat; Assert.IsTrue(continousStat.Equals(suffStat)); }
public void ValidateMissingStatisticsEquals() { SufficientStatistics suffStat = null; MissingStatistics missingStat = MissingStatistics.GetInstance; Assert.IsFalse(missingStat.Equals(suffStat)); suffStat = (SufficientStatistics)missingStat; Assert.IsTrue(missingStat.Equals(suffStat)); missingStat = MissingStatistics.GetInstance; suffStat = (SufficientStatistics)missingStat; Assert.IsTrue(missingStat.Equals(suffStat)); object suffStatObj = (object)missingStat; Assert.IsTrue(missingStat.Equals(suffStat)); }
public void ValidateGaussianStatisticsEquals() { SufficientStatistics suffStat = null; GaussianStatistics gaussStat = GaussianStatistics.GetMissingInstance; Assert.IsFalse(gaussStat.Equals(suffStat)); suffStat = (SufficientStatistics)gaussStat; Assert.IsTrue(gaussStat.Equals(suffStat)); gaussStat = GaussianStatistics.GetInstance(1.1, 2.2, 3); suffStat = (SufficientStatistics)gaussStat; Assert.IsTrue(gaussStat.Equals(suffStat)); object suffStatObj = (object)gaussStat; Assert.IsTrue(gaussStat.Equals(suffStat)); }
public void ValidateDiscreteStatisticsEquals() { SufficientStatistics suffStat = null; DiscreteStatistics discreteStat = DiscreteStatistics.GetMissingInstance; Assert.IsFalse(discreteStat.Equals(suffStat)); suffStat = (SufficientStatistics)discreteStat; Assert.IsTrue(discreteStat.Equals(suffStat)); discreteStat = DiscreteStatistics.GetInstance(1); suffStat = (SufficientStatistics)discreteStat; Assert.IsTrue(discreteStat.Equals(suffStat)); object suffStatObj = (object)discreteStat; Assert.IsTrue(discreteStat.Equals(suffStat)); }
public void ValidateStatisticsListTryParse() { StatisticsList statList = new StatisticsList(); GaussianStatistics gaussStat = GaussianStatistics.GetInstance(2.33, 1.256, 7); DiscreteStatistics discreteStat = DiscreteStatistics.GetInstance(1); ContinuousStatistics contStat = ContinuousStatistics.GetInstance(2.333); MissingStatistics missingStat = MissingStatistics.GetInstance; BooleanStatistics boolStat = BooleanStatistics.GetInstance(true); statList.Add(gaussStat); statList.Add(discreteStat); statList.Add(contStat); statList.Add(missingStat); statList.Add(boolStat); Assert.AreEqual(5, statList.Count); SufficientStatistics result = null; StatisticsList statListSubSequence = (StatisticsList)statList.SubSequence(0, 2); Assert.IsTrue(StatisticsList.TryParse(statList.ToString(), out result)); Assert.IsTrue(StatisticsList.TryParse(statListSubSequence.ToString(), out result)); }
public void ValidateBooleanStatisticsEquals() { SufficientStatistics suffStat = BooleanStatistics.GetInstance(false); BooleanStatistics boolStat = BooleanStatistics.GetMissingInstance; Assert.IsFalse(boolStat.Equals(suffStat)); suffStat = (SufficientStatistics)boolStat; Assert.IsTrue(boolStat.Equals(suffStat)); boolStat = BooleanStatistics.GetInstance(true); suffStat = (SufficientStatistics)boolStat; Assert.IsTrue(boolStat.Equals(suffStat)); boolStat = BooleanStatistics.GetInstance(false); suffStat = (SufficientStatistics)boolStat; Assert.IsTrue(boolStat.Equals(suffStat)); object suffStatObj = (object)boolStat; Assert.IsTrue(boolStat.Equals(suffStat)); }
/// <summary> /// Convert Binary To Multistate. /// </summary> /// <param name="statistics">statistics.</param> /// <param name="columnValues">column Values.</param> private static void ConvertBinaryToMultistate(IList <List <SufficientStatistics> > statistics, IList <string> columnValues) { var multToBinaryPositions = from binaryKey in columnValues where binaryKey.Contains('@') let merAndPos = GetMerAndPos(binaryKey) let pos = (int)merAndPos.Value group binaryKey by pos into g select new KeyValuePair <string, IList <string> > ( g.Key + "@" + g.StringJoin("#").Replace(g.Key + "@", ""), g.ToList() ); var nonAaKeys = from key in columnValues where !key.Contains('@') select new KeyValuePair <string, IList <string> >(key, new List <string>() { key }); var allKeys = nonAaKeys.Concat(multToBinaryPositions).ToList(); Dictionary <string, List <SufficientStatistics> > values = statistics.Select((key, idx) => new KeyValuePair <string, List <SufficientStatistics> >(columnValues[idx], key)).ToDictionary(); columnValues.Clear(); ((List <string>)columnValues).AddRange(allKeys.Select(keys => keys.Key)); statistics.Clear(); for (int index = 0; index < allKeys.Count; index++) { List <SufficientStatistics> posStatistics = new List <SufficientStatistics>(); for (int index1 = 0; index1 < values.First().Value.Count; index1++) { if (allKeys[index].Value.Count == 1) { posStatistics.Add(values[allKeys[index].Value.First()][index1]); } else { int state = 0; bool valueAdded = false; foreach (string key in allKeys[index].Value) { SufficientStatistics tempValue = values[key][index1]; if (ValueConverters.SufficientStatisticsToInt.ConvertForward(tempValue) == 1) { posStatistics.Add(ValueConverters.SufficientStatisticsToInt.ConvertBackward(state)); valueAdded = true; break; } state++; } if (!valueAdded) { posStatistics.Add(MissingStatistics.GetInstance); } } } statistics.Add(posStatistics); } }
protected void DoLearning(LearningTask learningTask) { if (learningTask.LearningState == ComputationState.Done) { return; } // Grab options. var options = learningTask.Options; // Grab training set. var trainingSet = learningTask.TrainingSet; // Grab variable names. var firstObservation = learningTask.TrainingSet.First(); var variableNames = firstObservation.VariableNames; // Build a starter Bayesian network. var bn = new BayesianNetwork(learningTask.TrainingSet.Name); // Build variables for each variable in the training set. foreach (var variableName in variableNames) { var space = trainingSet.Variables.TryFind(variableName).Value; var rv = new RandomVariable(variableName, space); bn.AddVariable(rv); } // Store in task so that task can send updates to its listeners. learningTask.BayesianNetwork = bn; learningTask.LearningState = ComputationState.Computing; // Build Dirichlet parameters IDictionary <string, DirichletDistribution> priors = new Dictionary <string, DirichletDistribution>(); foreach (var variableName in variableNames) { var space = trainingSet.Variables.TryFind(variableName).Value; DirichletDistribution prior; if (options.DistributionDirichletAlpha > 0) { prior = new DirichletDistribution(); foreach (var value in space.Values) { prior.SetParameter(value, options.DistributionDirichletAlpha); } priors[variableName] = prior; } } // Initialize a sufficient statistics. SufficientStatistics sufficientStatistics = new SufficientStatistics(trainingSet, Utils.Some(priors)); // Learn structure. switch (options.Structure) { case LearningOptions.StructureEnum.DisconnectedStructure: break; case LearningOptions.StructureEnum.RandomStructure: bn.GenerateStructure( StructureClass.Random, Utils.Some(options.StructureSeed), Utils.Some(options.StructureParentLimit)); break; case LearningOptions.StructureEnum.TreeStructure: bn.LearnStructure( sufficientStatistics, StructureClass.Tree, Utils.None <int>(), Utils.None <int>()); break; case LearningOptions.StructureEnum.GeneralStructure: bn.LearnStructure( sufficientStatistics, StructureClass.General, Utils.None <int>(), Utils.Some(options.StructureParentLimit)); break; } // Learn distributions. bn.LearnDistributions(sufficientStatistics); // Done. learningTask.LearningState = ComputationState.Done; }
protected void DoLearning(LearningTask learningTask) { if (learningTask.LearningState == ComputationState.Done) { return; } // Grab options. var options = learningTask.Options; // Grab training set. var trainingSet = learningTask.TrainingSet; // Grab variable names. var firstObservation = learningTask.TrainingSet.First(); var variableNames = firstObservation.VariableNames; // Build a starter Bayesian network. var bn = new BayesianNetwork(learningTask.TrainingSet.Name); // Build variables for each variable in the training set. foreach (var variableName in variableNames) { var space = trainingSet.Variables.TryFind(variableName).Value; var rv = new RandomVariable(variableName, space); bn.AddVariable(rv); } // Store in task so that task can send updates to its listeners. learningTask.BayesianNetwork = bn; learningTask.LearningState = ComputationState.Computing; // Build Dirichlet parameters IDictionary<string, DirichletDistribution> priors = new Dictionary<string, DirichletDistribution>(); foreach (var variableName in variableNames) { var space = trainingSet.Variables.TryFind(variableName).Value; DirichletDistribution prior; if (options.DistributionDirichletAlpha > 0) { prior = new DirichletDistribution(); foreach (var value in space.Values) { prior.SetParameter(value, options.DistributionDirichletAlpha); } priors[variableName] = prior; } } // Initialize a sufficient statistics. SufficientStatistics sufficientStatistics = new SufficientStatistics(trainingSet, Utils.Some(priors)); // Learn structure. switch (options.Structure) { case LearningOptions.StructureEnum.DisconnectedStructure: break; case LearningOptions.StructureEnum.RandomStructure: bn.GenerateStructure( StructureClass.Random, Utils.Some(options.StructureSeed), Utils.Some(options.StructureParentLimit)); break; case LearningOptions.StructureEnum.TreeStructure: bn.LearnStructure( sufficientStatistics, StructureClass.Tree, Utils.None<int>(), Utils.None<int>()); break; case LearningOptions.StructureEnum.GeneralStructure: bn.LearnStructure( sufficientStatistics, StructureClass.General, Utils.None<int>(), Utils.Some(options.StructureParentLimit)); break; } // Learn distributions. bn.LearnDistributions(sufficientStatistics); // Done. learningTask.LearningState = ComputationState.Done; }
/// <summary> /// Try Parse the value. /// </summary> /// <param name="val">The Value.</param> /// <param name="result">Sufficient Statistics result.</param> /// <returns>Returns true if parsed properly.</returns> new public static bool TryParse(string val, out SufficientStatistics result) { result = null; if (string.IsNullOrEmpty(val)) { result = GetMissingInstance; return false; } else { string[] fields = val.Split(','); if (!(fields.Length == 3)) { return false; } double mean, variance; int sampleSize; if (double.TryParse(fields[0], out mean) && double.TryParse(fields[1], out variance) && int.TryParse(fields[2], out sampleSize)) { result = GaussianStatistics.GetInstance(mean, variance, sampleSize); return true; } return false; } }
/// <summary> /// Compares Sufficient Statistics with Discrete Statistics and Boolean Statistics. /// </summary> /// <param name="stats">Sufficient Statistics.</param> /// <returns>Returns true if equal.</returns> public override bool Equals(SufficientStatistics stats) { if (stats == null) { return false; } if (IsMissing() && stats.IsMissing()) { return true; } else if (stats is DiscreteStatistics) { return this.Value == stats.AsDiscreteStatistics().Value; } else if (stats is BooleanStatistics) { return this.Value == stats.AsDiscreteStatistics().Value; } else { return stats.Equals(this); } }
/// <summary> /// Compares Sufficient Statistics. /// </summary> /// <param name="stats">Sufficient Statistics.</param> /// <returns>Returns true if equal.</returns> public override bool Equals(SufficientStatistics stats) { if (stats == null) { return false; } if (IsMissing() && stats.IsMissing()) { return true; } GaussianStatistics gaussStats = stats.AsGaussianStatistics(); return _mean == gaussStats._mean && _variance == gaussStats._variance && _sampleSize == gaussStats._sampleSize; }
public void ValidateSufficientStatisticsGetHashCode() { SufficientStatistics boolStat1 = SufficientStatistics.Parse("1"); Assert.AreEqual(372029325, boolStat1.GetHashCode()); }
/// <summary> /// Try converting the given string into SufficientStatistics object. /// </summary> /// <param name="val">string to be converted.</param> /// <param name="result">SufficentStatistics object which corresponding to the given string.</param> /// <returns>Whether string was successfully converted.</returns> new public static bool TryParse(string val, out SufficientStatistics result) { if (string.IsNullOrEmpty(val)) { throw new ArgumentNullException("val"); } result = null; if (val.Equals("true", StringComparison.CurrentCultureIgnoreCase) || val == "1") { result = BooleanStatistics.GetInstance(true); } else if (val.Equals("false", StringComparison.CurrentCultureIgnoreCase) || val == "0") { result = BooleanStatistics.GetInstance(false); } else if (val.Equals("null", StringComparison.CurrentCultureIgnoreCase) || val == "-1") { result = BooleanStatistics.GetMissingInstance; } return result != null; }
/// <summary> /// Compares a given SufficientStatistics object with the current object. /// </summary> /// <param name="stats">SufficientStatistics object to be compared</param> /// <returns>True if both the objects are equal.</returns> public override bool Equals(SufficientStatistics stats) { if (stats == null) { throw new ArgumentNullException("stats"); } if (stats.IsMissing()) { return IsMissing(); } else if (stats is BooleanStatistics) { return _value == stats.AsBooleanStatistics()._value; } else { return stats.Equals(this); } }
/// <summary> /// Compares a given SufficientStatistics object with the current object. /// </summary> /// <param name="stats">SufficientStatistics object to be compared.</param> /// <returns>True if both the objects are equal.</returns> public override bool Equals(SufficientStatistics stats) { if (stats == null) { throw new ArgumentNullException("stats"); } if (IsMissing() && stats.IsMissing()) { return true; } return this.AsGaussianStatistics().Equals(stats); // let the most general class decide }