public static double CalculateQualityForImpacts(ISymbolicClassificationModel model, IClassificationProblemData problemData, IEnumerable <int> rows)
{
OnlineCalculatorError errorState;
var dataset = problemData.Dataset;
var targetClassValues = dataset.GetDoubleValues(problemData.TargetVariable, rows);
var originalClassValues = model.GetEstimatedClassValues(dataset, rows);
var qualityForImpactsCalculation = OnlineAccuracyCalculator.Calculate(targetClassValues, originalClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
qualityForImpactsCalculation = 0.0;
}
return(qualityForImpactsCalculation);
}
protected override double CalculateQualityForImpacts(ISymbolicDataAnalysisModel model, IDataAnalysisProblemData problemData, IEnumerable <int> rows)
{
var classificationModel = (ISymbolicClassificationModel)model;
var classificationProblemData = (IClassificationProblemData)problemData;
OnlineCalculatorError errorState;
var dataset = problemData.Dataset;
var targetClassValues = dataset.GetDoubleValues(classificationProblemData.TargetVariable, rows);
var originalClassValues = classificationModel.GetEstimatedClassValues(dataset, rows);
var qualityForImpactsCalculation = OnlineAccuracyCalculator.Calculate(targetClassValues, originalClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
qualityForImpactsCalculation = 0.0;
}
return(qualityForImpactsCalculation);
}
protected override void Run()
{
IClassificationProblemData problemData = Problem.ProblemData;
IEnumerable <string> selectedInputVariables = problemData.AllowedInputVariables;
int nSv;
ISupportVectorMachineModel model;
Run(problemData, selectedInputVariables, GetSvmType(SvmType.Value), GetKernelType(KernelType.Value), Cost.Value, Nu.Value, Gamma.Value, Degree.Value, out model, out nSv);
if (CreateSolution)
{
var solution = new SupportVectorClassificationSolution((SupportVectorMachineModel)model, (IClassificationProblemData)problemData.Clone());
Results.Add(new Result("Support vector classification solution", "The support vector classification solution.",
solution));
}
{
// calculate classification metrics
// calculate regression model metrics
var ds = problemData.Dataset;
var trainRows = problemData.TrainingIndices;
var testRows = problemData.TestIndices;
var yTrain = ds.GetDoubleValues(problemData.TargetVariable, trainRows);
var yTest = ds.GetDoubleValues(problemData.TargetVariable, testRows);
var yPredTrain = model.GetEstimatedClassValues(ds, trainRows);
var yPredTest = model.GetEstimatedClassValues(ds, testRows);
OnlineCalculatorError error;
var trainAccuracy = OnlineAccuracyCalculator.Calculate(yPredTrain, yTrain, out error);
if (error != OnlineCalculatorError.None)
{
trainAccuracy = double.MaxValue;
}
var testAccuracy = OnlineAccuracyCalculator.Calculate(yPredTest, yTest, out error);
if (error != OnlineCalculatorError.None)
{
testAccuracy = double.MaxValue;
}
Results.Add(new Result("Accuracy (training)", "The mean of squared errors of the SVR solution on the training partition.", new DoubleValue(trainAccuracy)));
Results.Add(new Result("Accuracy (test)", "The mean of squared errors of the SVR solution on the test partition.", new DoubleValue(testAccuracy)));
Results.Add(new Result("Number of support vectors", "The number of support vectors of the SVR solution.",
new IntValue(nSv)));
}
}
public override void CalculateImpactAndReplacementValues(ISymbolicDataAnalysisModel model, ISymbolicExpressionTreeNode node,
IDataAnalysisProblemData problemData, IEnumerable <int> rows, out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation,
double qualityForImpactsCalculation = Double.NaN)
{
var classificationModel = (ISymbolicClassificationModel)model;
var classificationProblemData = (IClassificationProblemData)problemData;
if (double.IsNaN(qualityForImpactsCalculation))
{
qualityForImpactsCalculation = CalculateQualityForImpacts(classificationModel, classificationProblemData, rows);
}
replacementValue = CalculateReplacementValue(classificationModel, node, classificationProblemData, rows);
var constantNode = new ConstantTreeNode(new Constant())
{
Value = replacementValue
};
var cloner = new Cloner();
var tempModel = cloner.Clone(classificationModel);
var tempModelNode = (ISymbolicExpressionTreeNode)cloner.GetClone(node);
var tempModelParentNode = tempModelNode.Parent;
int i = tempModelParentNode.IndexOfSubtree(tempModelNode);
tempModelParentNode.RemoveSubtree(i);
tempModelParentNode.InsertSubtree(i, constantNode);
OnlineCalculatorError errorState;
var dataset = classificationProblemData.Dataset;
var targetClassValues = dataset.GetDoubleValues(classificationProblemData.TargetVariable, rows);
var estimatedClassValues = tempModel.GetEstimatedClassValues(dataset, rows);
newQualityForImpactsCalculation = OnlineAccuracyCalculator.Calculate(targetClassValues, estimatedClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
newQualityForImpactsCalculation = 0.0;
}
impactValue = qualityForImpactsCalculation - newQualityForImpactsCalculation;
}
private static void CrossValidate(IClassificationProblemData problemData, Tuple <IEnumerable <int>, IEnumerable <int> >[] partitions, int nTrees, double r, double m, int seed, out double avgTestAccuracy)
{
avgTestAccuracy = 0;
var ds = problemData.Dataset;
var targetVariable = GetTargetVariableName(problemData);
foreach (var tuple in partitions)
{
double rmsError, avgRelError, outOfBagAvgRelError, outOfBagRmsError;
var trainingRandomForestPartition = tuple.Item1;
var testRandomForestPartition = tuple.Item2;
var model = RandomForestModel.CreateClassificationModel(problemData, trainingRandomForestPartition, nTrees, r, m, seed, out rmsError, out avgRelError, out outOfBagRmsError, out outOfBagAvgRelError);
var estimatedValues = model.GetEstimatedClassValues(ds, testRandomForestPartition);
var targetValues = ds.GetDoubleValues(targetVariable, testRandomForestPartition);
OnlineCalculatorError calculatorError;
double accuracy = OnlineAccuracyCalculator.Calculate(estimatedValues, targetValues, out calculatorError);
if (calculatorError != OnlineCalculatorError.None)
{
accuracy = double.NaN;
}
avgTestAccuracy += accuracy;
}
avgTestAccuracy /= partitions.Length;
}
