private static IScope CreateRulesResult(RegressionRuleModel regressionRuleModel, IRegressionProblemData pd, bool displayModels, out IRegressionProblemData notCovered)
{
var training = pd.TrainingIndices.Where(x => !regressionRuleModel.Covers(pd.Dataset, x)).ToArray();
var test = pd.TestIndices.Where(x => !regressionRuleModel.Covers(pd.Dataset, x)).ToArray();
if (training.Length > 0 || test.Length > 0)
{
var data = new Dataset(pd.Dataset.DoubleVariables, pd.Dataset.DoubleVariables.Select(v => pd.Dataset.GetDoubleValues(v, training.Concat(test)).ToArray()));
notCovered = new RegressionProblemData(data, pd.AllowedInputVariables, pd.TargetVariable);
notCovered.TestPartition.Start = notCovered.TrainingPartition.End = training.Length;
notCovered.TestPartition.End = training.Length + test.Length;
}
else
{
notCovered = null;
}
var training2 = pd.TrainingIndices.Where(x => regressionRuleModel.Covers(pd.Dataset, x)).ToArray();
var test2 = pd.TestIndices.Where(x => regressionRuleModel.Covers(pd.Dataset, x)).ToArray();
var data2 = new Dataset(pd.Dataset.DoubleVariables, pd.Dataset.DoubleVariables.Select(v => pd.Dataset.GetDoubleValues(v, training2.Concat(test2)).ToArray()));
var covered = new RegressionProblemData(data2, pd.AllowedInputVariables, pd.TargetVariable);
covered.TestPartition.Start = covered.TrainingPartition.End = training2.Length;
covered.TestPartition.End = training2.Length + test2.Length;
var res2 = new Scope("RuleModels");
res2.Variables.Add(new Variable(ConditionResultName, new StringValue(regressionRuleModel.ToCompactString())));
res2.Variables.Add(new Variable(CoverResultName, new IntValue(pd.TrainingIndices.Count() - training.Length)));
if (displayModels)
{
res2.Variables.Add(new Variable(RuleModelResultName, regressionRuleModel.CreateRegressionSolution(covered)));
}
return(res2);
}
protected RegressionRuleModel(RegressionRuleModel original, Cloner cloner) : base(original, cloner)
{
if (original.SplitAttributes != null)
{
SplitAttributes = original.SplitAttributes.ToArray();
}
if (original.SplitValues != null)
{
SplitValues = original.SplitValues.ToArray();
}
if (original.Comparisons != null)
{
Comparisons = original.Comparisons.ToArray();
}
RuleModel = cloner.Clone(original.RuleModel);
if (original.variables != null)
{
variables = original.variables.ToList();
}
}
public void Build(IReadOnlyList <int> trainingRows, IReadOnlyList <int> pruningRows, IScope stateScope, ResultCollection results, CancellationToken cancellationToken)
{
var regressionTreeParams = (RegressionTreeParameters)stateScope.Variables[DecisionTreeRegression.RegressionTreeParameterVariableName].Value;
var ruleSetState = (RuleSetState)stateScope.Variables[RuleSetStateVariableName].Value;
if (ruleSetState.Code <= 0)
{
ruleSetState.Rules.Clear();
ruleSetState.TrainingRows = trainingRows;
ruleSetState.PruningRows = pruningRows;
ruleSetState.Code = 1;
}
do
{
var tempRule = RegressionRuleModel.CreateRuleModel(regressionTreeParams.TargetVariable, regressionTreeParams);
cancellationToken.ThrowIfCancellationRequested();
if (!results.ContainsKey(NumRulesResultName))
{
results.Add(new Result(NumRulesResultName, new IntValue(0)));
}
if (!results.ContainsKey(CoveredInstancesResultName))
{
results.Add(new Result(CoveredInstancesResultName, new IntValue(0)));
}
var t1 = ruleSetState.TrainingRows.Count;
tempRule.Build(ruleSetState.TrainingRows, ruleSetState.PruningRows, stateScope, results, cancellationToken);
ruleSetState.TrainingRows = ruleSetState.TrainingRows.Where(i => !tempRule.Covers(regressionTreeParams.Data, i)).ToArray();
ruleSetState.PruningRows = ruleSetState.PruningRows.Where(i => !tempRule.Covers(regressionTreeParams.Data, i)).ToArray();
ruleSetState.Rules.Add(tempRule);
((IntValue)results[NumRulesResultName].Value).Value++;
((IntValue)results[CoveredInstancesResultName].Value).Value += t1 - ruleSetState.TrainingRows.Count;
}while (ruleSetState.TrainingRows.Count > 0);
Rules = ruleSetState.Rules;
}
