private RandomForestModelSurrogate(RandomForestModelSurrogate original, Cloner cloner) : base(original, cloner)
        {
            IRandomForestModel clonedModel = null;

            if (original.actualModel.IsValueCreated)
            {
                clonedModel = cloner.Clone(original.ActualModel);
            }
            actualModel = new Lazy <IRandomForestModel>(CreateLazyInitFunc(clonedModel)); // only capture clonedModel in the closure

            // clone data which is necessary to rebuild the model
            this.originalTrainingData = cloner.Clone(original.originalTrainingData);
            this.seed        = original.seed;
            this.classValues = original.classValues;
            this.nTrees      = original.nTrees;
            this.r           = original.r;
            this.m           = original.m;
        }
        private IRandomForestModel RecalculateModel()
        {
            IRandomForestModel randomForestModel = null;

            double rmsError, oobRmsError, relClassError, oobRelClassError;
            var    classificationProblemData = originalTrainingData as IClassificationProblemData;

            if (originalTrainingData is IRegressionProblemData regressionProblemData)
            {
                randomForestModel = RandomForestRegression.CreateRandomForestRegressionModel(regressionProblemData,
                                                                                             nTrees, r, m, seed, out rmsError, out oobRmsError,
                                                                                             out relClassError, out oobRelClassError);
            }
            else if (classificationProblemData != null)
            {
                randomForestModel = RandomForestClassification.CreateRandomForestClassificationModel(classificationProblemData,
                                                                                                     nTrees, r, m, seed, out rmsError, out oobRmsError,
                                                                                                     out relClassError, out oobRelClassError);
            }
            return(randomForestModel);
        }
 public RandomForestClassificationSolution(IClassificationProblemData problemData, IRandomForestModel randomForestModel)
   : base(randomForestModel, problemData) {
 }
 public RandomForestClassificationSolution(IClassificationProblemData problemData, IRandomForestModel randomForestModel)
     : base(randomForestModel, problemData)
 {
 }
Beispiel #5
0
 public RandomForestRegressionSolution(IRandomForestModel randomForestModel, IRegressionProblemData problemData)
     : base(randomForestModel, problemData)
 {
 }
 public RandomForestRegressionSolution(IRegressionProblemData problemData, IRandomForestModel randomForestModel)
   : base(randomForestModel, problemData) {
 }
 // wrap an actual model in a surrograte
 public RandomForestModelSurrogate(IRandomForestModel model, string targetVariable, IDataAnalysisProblemData originalTrainingData,
                                   int seed, int nTrees, double r, double m, double[] classValues = null) : this(targetVariable, originalTrainingData, seed, nTrees, r, m, classValues)
 {
     actualModel = new Lazy <IRandomForestModel>(() => model);
 }
 private Func <IRandomForestModel> CreateLazyInitFunc(IRandomForestModel clonedModel)
 {
     return(() => {
         return clonedModel ?? RecalculateModel();
     });
 }