/// <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;
}
