/// <summary> /// Query a regression algorithm using equilateral encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> /// <param name="high">The high value.</param> /// <param name="low">The low value.</param> public static void QueryEquilateral( IRegressionAlgorithm alg, IList<BasicData> theTrainingData, IDictionary<string, int> items, double high, double low) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary<int, string> invMap = new Dictionary<int, string>(); foreach (var key in items.Keys) { var value = items[key]; invMap[value] = key; } // now we can query var eq = new Equilateral(items.Count, high, low); foreach (var data in theTrainingData) { var output = alg.ComputeRegression(data.Input); var idealIndex = eq.Decode(data.Ideal); var actualIndex = eq.Decode(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
public void PerformTraining(ILearningMethod method, object model, IEnumerable validationData) { IRegressionAlgorithm regression = model as IRegressionAlgorithm; if (regression != null) { IErrorCalculation errorCalc; switch (ErrorCalculation) { case ErrorCaclulationType.MeanSquare: errorCalc = new ErrorCalculationMSE(); break; case ErrorCaclulationType.RootMeanSquare: errorCalc = new ErrorCalculationRMS(); break; case ErrorCaclulationType.SumOfSquares: errorCalc = new ErrorCalculationSSE(); break; default: throw new ArgumentOutOfRangeException(); } new SimpleLearn().PerformIterationsEarlyStop(method, regression, (IList <BasicData>)validationData, Tolerate, errorCalc); } else { IClassificationAlgorithm classification = (IClassificationAlgorithm)model; new SimpleLearn().PerformIterationsClassifyEarlyStop(method, classification, (IList <BasicData>)validationData, Tolerate); } }
/// <summary> /// Query a regression algorithm using one-of-n encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> public static void QueryOneOfN( IRegressionAlgorithm alg, IList <BasicData> theTrainingData, IDictionary <String, int> items) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary <int, String> invMap = new Dictionary <int, string>(); foreach (string key in items.Keys) { int value = items[key]; invMap[value] = key; } // now we can query foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); int idealIndex = VectorUtil.MaxIndex(data.Ideal); int actualIndex = VectorUtil.MaxIndex(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Query a regression algorithm using equilateral encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> /// <param name="high">The high value.</param> /// <param name="low">The low value.</param> public static void QueryEquilateral( IRegressionAlgorithm alg, IList <BasicData> theTrainingData, IDictionary <string, int> items, double high, double low) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary <int, string> invMap = new Dictionary <int, string>(); foreach (var key in items.Keys) { var value = items[key]; invMap[value] = key; } // now we can query var eq = new Equilateral(items.Count, high, low); foreach (var data in theTrainingData) { var output = alg.ComputeRegression(data.Input); var idealIndex = eq.Decode(data.Ideal); var actualIndex = eq.Decode(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Query a regression algorithm and see how close it matches the training data. /// </summary> /// <param name="alg">The algorithm to evaluate.</param> /// <param name="theTrainingData">The training data.</param> public static void Query(IRegressionAlgorithm alg, IList <BasicData> theTrainingData) { foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + VectorUtil.DoubleArrayToString(output) + ", Ideal: " + VectorUtil.DoubleArrayToString(data.Ideal)); } }
/// <summary> /// Query a regression algorithm and see how close it matches the training data. /// </summary> /// <param name="alg">The algorithm to evaluate.</param> /// <param name="theTrainingData">The training data.</param> public static void Query(IRegressionAlgorithm alg, IList<BasicData> theTrainingData) { foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + VectorUtil.DoubleArrayToString(output) + ", Ideal: " + VectorUtil.DoubleArrayToString(data.Ideal)); } }
/// <summary> /// Calculate error for regression. /// </summary> /// <param name="dataset">The dataset.</param> /// <param name="model">The model to evaluate.</param> /// <param name="calc">The error calculation.</param> /// <returns>The error.</returns> public static double CalculateRegressionError(IList <BasicData> dataset, IRegressionAlgorithm model, IErrorCalculation calc) { calc.Clear(); foreach (var item in dataset) { var output = model.ComputeRegression(item.Input); calc.UpdateError(output, item.Ideal, 1.0); } return(calc.Calculate()); }
/// <summary> /// Train and stop when the validation set does not improve anymore. /// </summary> /// <param name="train">The trainer to use.</param> /// <param name="model">The model that is trained.</param> /// <param name="validationData">The validation data.</param> /// <param name="tolerate">Number of iterations to tolerate no improvement to the validation error.</param> /// <param name="errorCalc">The error calculation method.</param> public void PerformIterationsEarlyStop(ILearningMethod train, IRegressionAlgorithm model, IList <BasicData> validationData, int tolerate, IErrorCalculation errorCalc) { var iterationNumber = 0; var done = false; var bestError = double.PositiveInfinity; var badIterations = 0; do { iterationNumber++; train.Iteration(); var validationError = DataUtil.CalculateRegressionError(validationData, model, errorCalc); if (validationError < bestError) { badIterations = 0; bestError = validationError; } else { badIterations++; } if (train.Done) { done = true; } else if (validationError > bestError && badIterations > tolerate) { done = true; } else if (double.IsNaN(train.LastError)) { Console.WriteLine("Training failed."); done = true; } Console.WriteLine("Iteration #" + iterationNumber + ", Iteration Score=" + train.LastError + ", Validation Score=" + validationError + ", " + train.Status); } while (!done); train.FinishTraining(); Console.WriteLine("Final score: " + train.LastError); }
/// <inheritdoc/> public double CalculateScore(IMLMethod algo) { IErrorCalculation ec = ErrorCalc.Create(); IRegressionAlgorithm ralgo = (IRegressionAlgorithm)algo; // evaulate ec.Clear(); foreach (BasicData pair in _trainingData) { double[] output = ralgo.ComputeRegression(pair.Input); ec.UpdateError(output, pair.Ideal, 1.0); } return(ec.Calculate()); }
public static IRegressionAlgorithm CreateRegressor(RegressorType type, RegressionTypeIdentifier identifier) { IRegressionAlgorithm regressor = null; switch (type) { case RegressorType.LcmsRegressor: regressor = new LcmsRegressor(identifier); break; default: break; } return(regressor); }
/// <summary> /// Query a regression algorithm using one-of-n encoding. /// </summary> /// <param name="alg">The algorithm being used.</param> /// <param name="theTrainingData">The training data.</param> /// <param name="items">The category items classified.</param> public static void QueryOneOfN( IRegressionAlgorithm alg, IList<BasicData> theTrainingData, IDictionary<String, int> items) { // first, we need to invert the items. Right now it maps from category to index. We need index to category. IDictionary<int, String> invMap = new Dictionary<int, string>(); foreach (string key in items.Keys) { int value = items[key]; invMap[value] = key; } // now we can query foreach (BasicData data in theTrainingData) { double[] output = alg.ComputeRegression(data.Input); int idealIndex = VectorUtil.MaxIndex(data.Ideal); int actualIndex = VectorUtil.MaxIndex(output); Console.WriteLine(VectorUtil.DoubleArrayToString(data.Input) + " -> " + invMap[actualIndex] + ", Ideal: " + invMap[idealIndex]); } }
/// <summary> /// Train and stop when the validation set does not improve anymore. /// </summary> /// <param name="train">The trainer to use.</param> /// <param name="model">The model that is trained.</param> /// <param name="validationData">The validation data.</param> /// <param name="tolerate">Number of iterations to tolerate no improvement to the validation error.</param> /// <param name="errorCalc">The error calculation method.</param> public void PerformIterationsEarlyStop(ILearningMethod train, IRegressionAlgorithm model, IList<BasicData> validationData, int tolerate, IErrorCalculation errorCalc) { var iterationNumber = 0; var done = false; var bestError = double.PositiveInfinity; var badIterations = 0; do { iterationNumber++; train.Iteration(); var validationError = DataUtil.CalculateRegressionError(validationData, model, errorCalc); if (validationError < bestError) { badIterations = 0; bestError = validationError; } else { badIterations++; } if (train.Done) { done = true; } else if (validationError > bestError && badIterations > tolerate) { done = true; } else if (double.IsNaN(train.LastError)) { Console.WriteLine("Training failed."); done = true; } Console.WriteLine("Iteration #" + iterationNumber + ", Iteration Score=" + train.LastError + ", Validation Score=" + validationError + ", " + train.Status); } while (!done); train.FinishTraining(); Console.WriteLine("Final score: " + train.LastError); }
private void ProcessAnalysisJobInternal(Analysis analysis, Options options, IRetentionTimePredictor predictor) { analysis.ProcessedState = ProcessingState.Processing; if (this.ProcessingAnalysis != null) { ProcessingAnalysis(this, new AnalysisCompletedEventArgs(1, 1, analysis)); } IAnalysisReader reader = SequenceAnalysisToolsFactory.CreateReader(analysis.Tool); ITargetFilter filter = TargetFilterFactory.CreateFilters(analysis.Tool, options); IRegressionAlgorithm regressor = RegressorFactory.CreateRegressor(RegressorType.LcmsRegressor, options.Regression); Analysis results = reader.Read(analysis.FilePath, analysis.Name); List <Target> targets = new List <Target>(); Dictionary <string, Protein> proteins = new Dictionary <string, Protein>(); foreach (var target in results.Targets) { if (options.ShouldFilter(target)) { continue; } targets.Add(target); foreach (var protein in target.Proteins) { if (!proteins.ContainsKey(protein.Reference)) { analysis.Proteins.Add(protein); proteins.Add(protein.Reference, protein); } } } analysis.AddTargets(targets); // Calculate the regression based on the target data List <float> predicted = new List <float>(); List <float> scans = new List <float>(); int maxScan = 0; int minScan = 0; foreach (Target target in analysis.Targets) { // Filter the target here...based on use for alignment. if (filter.ShouldFilter(target)) { continue; } maxScan = Math.Max(maxScan, target.Scan); minScan = Math.Min(minScan, target.Scan); target.IsPredicted = true; target.NetPredicted = predictor.GetElutionTime(target.CleanSequence); scans.Add(target.Scan); predicted.Add(Convert.ToSingle(target.NetPredicted)); } analysis.RegressionResults = regressor.CalculateRegression(scans, predicted); //analysis.RegressionResults.Regressor = regressor; analysis.RegressionResults.MinScan = minScan; analysis.RegressionResults.MaxScan = maxScan; // Make the regression line data. int scan = 0; int delta = 5; while (scan <= maxScan) { double y = regressor.GetTransformedNET(scan); scan += delta; analysis.RegressionResults.XValues.Add(Convert.ToDouble(scan)); analysis.RegressionResults.YValues.Add(y); } // Then make sure we align all against the predicted self regressor.ApplyTransformation(analysis.Targets); analysis.ProcessedState = ProcessingState.Processed; }