R/modelbuilder.h.R

Defines functions modelbuilder

# This file is automatically generated, you probably don't want to edit this

modelbuilderOptions <- if (requireNamespace("jmvcore", quietly=TRUE)) R6::R6Class(
    "modelbuilderOptions",
    inherit = jmvcore::Options,
    public = list(
        initialize = function(
            outcome = NULL,
            outcomePositive = NULL,
            splitData = TRUE,
            randomSeed = 123,
            buildBasicModel = TRUE,
            basicPredictors = NULL,
            basicModelName = "basic_model",
            buildEnhancedModel = FALSE,
            enhancedPredictors = NULL,
            enhancedModelName = "enhanced_model",
            buildBiomarkerModel = FALSE,
            biomarkerPredictors = NULL,
            biomarkerModelName = "biomarker_model",
            buildCustomModel = FALSE,
            customPredictors = NULL,
            customModelName = "custom_model",
            includeInteractions = FALSE,
            interactionTerms = "",
            useStepwise = FALSE,
            stepwiseDirection = "both",
            selectionCriterion = "aic",
            transformVariables = FALSE,
            transformMethod = "log",
            missingDataMethod = "complete_cases",
            imputationSets = 5,
            crossValidation = FALSE,
            cvFolds = 5,
            bootstrapValidation = FALSE,
            bootstrapReps = 1000,
            showModelSummary = TRUE,
            showPerformanceMetrics = TRUE,
            showCalibrationPlots = TRUE,
            showROCCurves = TRUE,
            compareModels = TRUE,
            createPredictions = TRUE,
            exportForDCA = TRUE,
            calculateNRI = FALSE,
            nriThresholds = "0.05, 0.10, 0.20",
            calculateIDI = FALSE,
            penalizedRegression = FALSE,
            penaltyType = "lasso",
            generateRiskScore = FALSE,
            riskScorePoints = "simple", ...) {

            super$initialize(
                package="ClinicoPath",
                name="modelbuilder",
                requiresData=TRUE,
                ...)

            private$..outcome <- jmvcore::OptionVariable$new(
                "outcome",
                outcome,
                suggested=list(
                    "nominal"),
                permitted=list(
                    "factor"))
            private$..outcomePositive <- jmvcore::OptionLevel$new(
                "outcomePositive",
                outcomePositive,
                variable="(outcome)")
            private$..splitData <- jmvcore::OptionBool$new(
                "splitData",
                splitData,
                default=TRUE)
            private$..randomSeed <- jmvcore::OptionNumber$new(
                "randomSeed",
                randomSeed,
                default=123,
                min=1,
                max=99999)
            private$..buildBasicModel <- jmvcore::OptionBool$new(
                "buildBasicModel",
                buildBasicModel,
                default=TRUE)
            private$..basicPredictors <- jmvcore::OptionVariables$new(
                "basicPredictors",
                basicPredictors,
                suggested=list(
                    "continuous",
                    "ordinal",
                    "nominal"),
                permitted=list(
                    "numeric",
                    "factor"))
            private$..basicModelName <- jmvcore::OptionString$new(
                "basicModelName",
                basicModelName,
                default="basic_model")
            private$..buildEnhancedModel <- jmvcore::OptionBool$new(
                "buildEnhancedModel",
                buildEnhancedModel,
                default=FALSE)
            private$..enhancedPredictors <- jmvcore::OptionVariables$new(
                "enhancedPredictors",
                enhancedPredictors,
                suggested=list(
                    "continuous",
                    "ordinal",
                    "nominal"),
                permitted=list(
                    "numeric",
                    "factor"))
            private$..enhancedModelName <- jmvcore::OptionString$new(
                "enhancedModelName",
                enhancedModelName,
                default="enhanced_model")
            private$..buildBiomarkerModel <- jmvcore::OptionBool$new(
                "buildBiomarkerModel",
                buildBiomarkerModel,
                default=FALSE)
            private$..biomarkerPredictors <- jmvcore::OptionVariables$new(
                "biomarkerPredictors",
                biomarkerPredictors,
                suggested=list(
                    "continuous",
                    "ordinal",
                    "nominal"),
                permitted=list(
                    "numeric",
                    "factor"))
            private$..biomarkerModelName <- jmvcore::OptionString$new(
                "biomarkerModelName",
                biomarkerModelName,
                default="biomarker_model")
            private$..buildCustomModel <- jmvcore::OptionBool$new(
                "buildCustomModel",
                buildCustomModel,
                default=FALSE)
            private$..customPredictors <- jmvcore::OptionVariables$new(
                "customPredictors",
                customPredictors,
                suggested=list(
                    "continuous",
                    "ordinal",
                    "nominal"),
                permitted=list(
                    "numeric",
                    "factor"))
            private$..customModelName <- jmvcore::OptionString$new(
                "customModelName",
                customModelName,
                default="custom_model")
            private$..includeInteractions <- jmvcore::OptionBool$new(
                "includeInteractions",
                includeInteractions,
                default=FALSE)
            private$..interactionTerms <- jmvcore::OptionString$new(
                "interactionTerms",
                interactionTerms,
                default="")
            private$..useStepwise <- jmvcore::OptionBool$new(
                "useStepwise",
                useStepwise,
                default=FALSE)
            private$..stepwiseDirection <- jmvcore::OptionList$new(
                "stepwiseDirection",
                stepwiseDirection,
                options=list(
                    "both",
                    "forward",
                    "backward"),
                default="both")
            private$..selectionCriterion <- jmvcore::OptionList$new(
                "selectionCriterion",
                selectionCriterion,
                options=list(
                    "aic",
                    "bic"),
                default="aic")
            private$..transformVariables <- jmvcore::OptionBool$new(
                "transformVariables",
                transformVariables,
                default=FALSE)
            private$..transformMethod <- jmvcore::OptionList$new(
                "transformMethod",
                transformMethod,
                options=list(
                    "log",
                    "polynomial",
                    "spline"),
                default="log")
            private$..missingDataMethod <- jmvcore::OptionList$new(
                "missingDataMethod",
                missingDataMethod,
                options=list(
                    "complete_cases",
                    "mean_imputation",
                    "multiple_imputation",
                    "exclude_missing"),
                default="complete_cases")
            private$..imputationSets <- jmvcore::OptionNumber$new(
                "imputationSets",
                imputationSets,
                default=5,
                min=3,
                max=20)
            private$..crossValidation <- jmvcore::OptionBool$new(
                "crossValidation",
                crossValidation,
                default=FALSE)
            private$..cvFolds <- jmvcore::OptionNumber$new(
                "cvFolds",
                cvFolds,
                default=5,
                min=3,
                max=10)
            private$..bootstrapValidation <- jmvcore::OptionBool$new(
                "bootstrapValidation",
                bootstrapValidation,
                default=FALSE)
            private$..bootstrapReps <- jmvcore::OptionNumber$new(
                "bootstrapReps",
                bootstrapReps,
                default=1000,
                min=100,
                max=5000)
            private$..showModelSummary <- jmvcore::OptionBool$new(
                "showModelSummary",
                showModelSummary,
                default=TRUE)
            private$..showPerformanceMetrics <- jmvcore::OptionBool$new(
                "showPerformanceMetrics",
                showPerformanceMetrics,
                default=TRUE)
            private$..showCalibrationPlots <- jmvcore::OptionBool$new(
                "showCalibrationPlots",
                showCalibrationPlots,
                default=TRUE)
            private$..showROCCurves <- jmvcore::OptionBool$new(
                "showROCCurves",
                showROCCurves,
                default=TRUE)
            private$..compareModels <- jmvcore::OptionBool$new(
                "compareModels",
                compareModels,
                default=TRUE)
            private$..createPredictions <- jmvcore::OptionBool$new(
                "createPredictions",
                createPredictions,
                default=TRUE)
            private$..exportForDCA <- jmvcore::OptionBool$new(
                "exportForDCA",
                exportForDCA,
                default=TRUE)
            private$..calculateNRI <- jmvcore::OptionBool$new(
                "calculateNRI",
                calculateNRI,
                default=FALSE)
            private$..nriThresholds <- jmvcore::OptionString$new(
                "nriThresholds",
                nriThresholds,
                default="0.05, 0.10, 0.20")
            private$..calculateIDI <- jmvcore::OptionBool$new(
                "calculateIDI",
                calculateIDI,
                default=FALSE)
            private$..penalizedRegression <- jmvcore::OptionBool$new(
                "penalizedRegression",
                penalizedRegression,
                default=FALSE)
            private$..penaltyType <- jmvcore::OptionList$new(
                "penaltyType",
                penaltyType,
                options=list(
                    "lasso",
                    "ridge",
                    "elastic_net"),
                default="lasso")
            private$..generateRiskScore <- jmvcore::OptionBool$new(
                "generateRiskScore",
                generateRiskScore,
                default=FALSE)
            private$..riskScorePoints <- jmvcore::OptionList$new(
                "riskScorePoints",
                riskScorePoints,
                options=list(
                    "framingham",
                    "simple",
                    "deciles"),
                default="simple")

            self$.addOption(private$..outcome)
            self$.addOption(private$..outcomePositive)
            self$.addOption(private$..splitData)
            self$.addOption(private$..randomSeed)
            self$.addOption(private$..buildBasicModel)
            self$.addOption(private$..basicPredictors)
            self$.addOption(private$..basicModelName)
            self$.addOption(private$..buildEnhancedModel)
            self$.addOption(private$..enhancedPredictors)
            self$.addOption(private$..enhancedModelName)
            self$.addOption(private$..buildBiomarkerModel)
            self$.addOption(private$..biomarkerPredictors)
            self$.addOption(private$..biomarkerModelName)
            self$.addOption(private$..buildCustomModel)
            self$.addOption(private$..customPredictors)
            self$.addOption(private$..customModelName)
            self$.addOption(private$..includeInteractions)
            self$.addOption(private$..interactionTerms)
            self$.addOption(private$..useStepwise)
            self$.addOption(private$..stepwiseDirection)
            self$.addOption(private$..selectionCriterion)
            self$.addOption(private$..transformVariables)
            self$.addOption(private$..transformMethod)
            self$.addOption(private$..missingDataMethod)
            self$.addOption(private$..imputationSets)
            self$.addOption(private$..crossValidation)
            self$.addOption(private$..cvFolds)
            self$.addOption(private$..bootstrapValidation)
            self$.addOption(private$..bootstrapReps)
            self$.addOption(private$..showModelSummary)
            self$.addOption(private$..showPerformanceMetrics)
            self$.addOption(private$..showCalibrationPlots)
            self$.addOption(private$..showROCCurves)
            self$.addOption(private$..compareModels)
            self$.addOption(private$..createPredictions)
            self$.addOption(private$..exportForDCA)
            self$.addOption(private$..calculateNRI)
            self$.addOption(private$..nriThresholds)
            self$.addOption(private$..calculateIDI)
            self$.addOption(private$..penalizedRegression)
            self$.addOption(private$..penaltyType)
            self$.addOption(private$..generateRiskScore)
            self$.addOption(private$..riskScorePoints)
        }),
    active = list(
        outcome = function() private$..outcome$value,
        outcomePositive = function() private$..outcomePositive$value,
        splitData = function() private$..splitData$value,
        randomSeed = function() private$..randomSeed$value,
        buildBasicModel = function() private$..buildBasicModel$value,
        basicPredictors = function() private$..basicPredictors$value,
        basicModelName = function() private$..basicModelName$value,
        buildEnhancedModel = function() private$..buildEnhancedModel$value,
        enhancedPredictors = function() private$..enhancedPredictors$value,
        enhancedModelName = function() private$..enhancedModelName$value,
        buildBiomarkerModel = function() private$..buildBiomarkerModel$value,
        biomarkerPredictors = function() private$..biomarkerPredictors$value,
        biomarkerModelName = function() private$..biomarkerModelName$value,
        buildCustomModel = function() private$..buildCustomModel$value,
        customPredictors = function() private$..customPredictors$value,
        customModelName = function() private$..customModelName$value,
        includeInteractions = function() private$..includeInteractions$value,
        interactionTerms = function() private$..interactionTerms$value,
        useStepwise = function() private$..useStepwise$value,
        stepwiseDirection = function() private$..stepwiseDirection$value,
        selectionCriterion = function() private$..selectionCriterion$value,
        transformVariables = function() private$..transformVariables$value,
        transformMethod = function() private$..transformMethod$value,
        missingDataMethod = function() private$..missingDataMethod$value,
        imputationSets = function() private$..imputationSets$value,
        crossValidation = function() private$..crossValidation$value,
        cvFolds = function() private$..cvFolds$value,
        bootstrapValidation = function() private$..bootstrapValidation$value,
        bootstrapReps = function() private$..bootstrapReps$value,
        showModelSummary = function() private$..showModelSummary$value,
        showPerformanceMetrics = function() private$..showPerformanceMetrics$value,
        showCalibrationPlots = function() private$..showCalibrationPlots$value,
        showROCCurves = function() private$..showROCCurves$value,
        compareModels = function() private$..compareModels$value,
        createPredictions = function() private$..createPredictions$value,
        exportForDCA = function() private$..exportForDCA$value,
        calculateNRI = function() private$..calculateNRI$value,
        nriThresholds = function() private$..nriThresholds$value,
        calculateIDI = function() private$..calculateIDI$value,
        penalizedRegression = function() private$..penalizedRegression$value,
        penaltyType = function() private$..penaltyType$value,
        generateRiskScore = function() private$..generateRiskScore$value,
        riskScorePoints = function() private$..riskScorePoints$value),
    private = list(
        ..outcome = NA,
        ..outcomePositive = NA,
        ..splitData = NA,
        ..randomSeed = NA,
        ..buildBasicModel = NA,
        ..basicPredictors = NA,
        ..basicModelName = NA,
        ..buildEnhancedModel = NA,
        ..enhancedPredictors = NA,
        ..enhancedModelName = NA,
        ..buildBiomarkerModel = NA,
        ..biomarkerPredictors = NA,
        ..biomarkerModelName = NA,
        ..buildCustomModel = NA,
        ..customPredictors = NA,
        ..customModelName = NA,
        ..includeInteractions = NA,
        ..interactionTerms = NA,
        ..useStepwise = NA,
        ..stepwiseDirection = NA,
        ..selectionCriterion = NA,
        ..transformVariables = NA,
        ..transformMethod = NA,
        ..missingDataMethod = NA,
        ..imputationSets = NA,
        ..crossValidation = NA,
        ..cvFolds = NA,
        ..bootstrapValidation = NA,
        ..bootstrapReps = NA,
        ..showModelSummary = NA,
        ..showPerformanceMetrics = NA,
        ..showCalibrationPlots = NA,
        ..showROCCurves = NA,
        ..compareModels = NA,
        ..createPredictions = NA,
        ..exportForDCA = NA,
        ..calculateNRI = NA,
        ..nriThresholds = NA,
        ..calculateIDI = NA,
        ..penalizedRegression = NA,
        ..penaltyType = NA,
        ..generateRiskScore = NA,
        ..riskScorePoints = NA)
)

modelbuilderResults <- if (requireNamespace("jmvcore", quietly=TRUE)) R6::R6Class(
    "modelbuilderResults",
    inherit = jmvcore::Group,
    active = list(
        instructions = function() private$.items[["instructions"]],
        dataSummary = function() private$.items[["dataSummary"]],
        dcaReadyMessage = function() private$.items[["dcaReadyMessage"]],
        basicModelSummary = function() private$.items[["basicModelSummary"]],
        enhancedModelSummary = function() private$.items[["enhancedModelSummary"]],
        biomarkerModelSummary = function() private$.items[["biomarkerModelSummary"]],
        customModelSummary = function() private$.items[["customModelSummary"]],
        modelComparisonTable = function() private$.items[["modelComparisonTable"]],
        validationResults = function() private$.items[["validationResults"]],
        nriTable = function() private$.items[["nriTable"]],
        idiTable = function() private$.items[["idiTable"]],
        riskScoreTable = function() private$.items[["riskScoreTable"]],
        rocCurvesPlot = function() private$.items[["rocCurvesPlot"]],
        calibrationPlotsArray = function() private$.items[["calibrationPlotsArray"]],
        modelComparisonPlot = function() private$.items[["modelComparisonPlot"]],
        validationPlot = function() private$.items[["validationPlot"]],
        dcaPreparationSummary = function() private$.items[["dcaPreparationSummary"]]),
    private = list(),
    public=list(
        initialize=function(options) {
            super$initialize(
                options=options,
                name="",
                title="Prediction Model Builder",
                refs=list(
                    "glmnet",
                    "rms",
                    "pROC",
                    "mice",
                    "VIM",
                    "ClinicoPathJamoviModule"))
            self$add(jmvcore::Html$new(
                options=options,
                name="instructions",
                title="Instructions",
                visible=TRUE))
            self$add(jmvcore::Html$new(
                options=options,
                name="dataSummary",
                title="Data Summary",
                visible=TRUE))
            self$add(jmvcore::Html$new(
                options=options,
                name="dcaReadyMessage",
                title="Ready for Decision Curve Analysis",
                visible="(createPredictions)"))
            self$add(jmvcore::Table$new(
                options=options,
                name="basicModelSummary",
                title="Basic Clinical Model",
                visible="(buildBasicModel && showModelSummary)",
                columns=list(
                    list(
                        `name`="term", 
                        `title`="Variable", 
                        `type`="text"),
                    list(
                        `name`="estimate", 
                        `title`="Coefficient", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="std_error", 
                        `title`="Std. Error", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="z_value", 
                        `title`="z-value", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="p_value", 
                        `title`="p-value", 
                        `type`="number", 
                        `format`="zto,pvalue"),
                    list(
                        `name`="odds_ratio", 
                        `title`="Odds Ratio", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_lower", 
                        `title`="OR 95% CI Lower", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_upper", 
                        `title`="OR 95% CI Upper", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "basicPredictors",
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Table$new(
                options=options,
                name="enhancedModelSummary",
                title="Enhanced Clinical Model",
                visible="(buildEnhancedModel && showModelSummary)",
                columns=list(
                    list(
                        `name`="term", 
                        `title`="Variable", 
                        `type`="text"),
                    list(
                        `name`="estimate", 
                        `title`="Coefficient", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="std_error", 
                        `title`="Std. Error", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="z_value", 
                        `title`="z-value", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="p_value", 
                        `title`="p-value", 
                        `type`="number", 
                        `format`="zto,pvalue"),
                    list(
                        `name`="odds_ratio", 
                        `title`="Odds Ratio", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_lower", 
                        `title`="OR 95% CI Lower", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_upper", 
                        `title`="OR 95% CI Upper", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "enhancedPredictors",
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Table$new(
                options=options,
                name="biomarkerModelSummary",
                title="Biomarker Model",
                visible="(buildBiomarkerModel && showModelSummary)",
                columns=list(
                    list(
                        `name`="term", 
                        `title`="Variable", 
                        `type`="text"),
                    list(
                        `name`="estimate", 
                        `title`="Coefficient", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="std_error", 
                        `title`="Std. Error", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="z_value", 
                        `title`="z-value", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="p_value", 
                        `title`="p-value", 
                        `type`="number", 
                        `format`="zto,pvalue"),
                    list(
                        `name`="odds_ratio", 
                        `title`="Odds Ratio", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_lower", 
                        `title`="OR 95% CI Lower", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_upper", 
                        `title`="OR 95% CI Upper", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "biomarkerPredictors",
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Table$new(
                options=options,
                name="customModelSummary",
                title="Custom Model",
                visible="(buildCustomModel && showModelSummary)",
                columns=list(
                    list(
                        `name`="term", 
                        `title`="Variable", 
                        `type`="text"),
                    list(
                        `name`="estimate", 
                        `title`="Coefficient", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="std_error", 
                        `title`="Std. Error", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="z_value", 
                        `title`="z-value", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="p_value", 
                        `title`="p-value", 
                        `type`="number", 
                        `format`="zto,pvalue"),
                    list(
                        `name`="odds_ratio", 
                        `title`="Odds Ratio", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_lower", 
                        `title`="OR 95% CI Lower", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="ci_upper", 
                        `title`="OR 95% CI Upper", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "customPredictors",
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Table$new(
                options=options,
                name="modelComparisonTable",
                title="Model Performance Comparison",
                visible="(compareModels && showPerformanceMetrics)",
                columns=list(
                    list(
                        `name`="model", 
                        `title`="Model", 
                        `type`="text"),
                    list(
                        `name`="n_predictors", 
                        `title`="Variables", 
                        `type`="integer"),
                    list(
                        `name`="auc_training", 
                        `title`="AUC (Training)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="auc_validation", 
                        `title`="AUC (Validation)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="calibration_slope", 
                        `title`="Calibration Slope", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="calibration_intercept", 
                        `title`="Calibration Intercept", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="brier_score", 
                        `title`="Brier Score", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="log_likelihood", 
                        `title`="Log-Likelihood", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="aic", 
                        `title`="AIC", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="bic", 
                        `title`="BIC", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "outcome",
                    "outcomePositive",
                    "splitData")))
            self$add(jmvcore::Table$new(
                options=options,
                name="validationResults",
                title="Cross-Validation Results",
                visible="(crossValidation)",
                columns=list(
                    list(
                        `name`="model", 
                        `title`="Model", 
                        `type`="text"),
                    list(
                        `name`="cv_auc_mean", 
                        `title`="CV AUC (Mean)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="cv_auc_sd", 
                        `title`="CV AUC (SD)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="cv_calibration_slope", 
                        `title`="CV Calibration Slope", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="cv_brier_score", 
                        `title`="CV Brier Score", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="optimism", 
                        `title`="Optimism", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "cvFolds",
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Table$new(
                options=options,
                name="nriTable",
                title="Net Reclassification Index",
                visible="(calculateNRI)",
                columns=list(
                    list(
                        `name`="comparison", 
                        `title`="Comparison", 
                        `type`="text"),
                    list(
                        `name`="nri_events", 
                        `title`="NRI (Events)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="nri_non_events", 
                        `title`="NRI (Non-Events)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="nri_overall", 
                        `title`="NRI (Overall)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="nri_p_value", 
                        `title`="P-value", 
                        `type`="number", 
                        `format`="zto,pvalue")),
                clearWith=list(
                    "nriThresholds",
                    "outcome")))
            self$add(jmvcore::Table$new(
                options=options,
                name="idiTable",
                title="Integrated Discrimination Index",
                visible="(calculateIDI)",
                columns=list(
                    list(
                        `name`="comparison", 
                        `title`="Comparison", 
                        `type`="text"),
                    list(
                        `name`="idi", 
                        `title`="IDI", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="idi_p_value", 
                        `title`="P-value", 
                        `type`="number", 
                        `format`="zto,pvalue"),
                    list(
                        `name`="discrimination_slope_new", 
                        `title`="Disc. Slope (New)", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="discrimination_slope_old", 
                        `title`="Disc. Slope (Reference)", 
                        `type`="number", 
                        `format`="zto")),
                clearWith=list(
                    "outcome")))
            self$add(jmvcore::Table$new(
                options=options,
                name="riskScoreTable",
                title="Clinical Risk Score",
                visible="(generateRiskScore)",
                columns=list(
                    list(
                        `name`="variable", 
                        `title`="Risk Factor", 
                        `type`="text"),
                    list(
                        `name`="category", 
                        `title`="Category", 
                        `type`="text"),
                    list(
                        `name`="points", 
                        `title`="Points", 
                        `type`="integer"),
                    list(
                        `name`="coefficient", 
                        `title`="Coefficient", 
                        `type`="number", 
                        `format`="zto"),
                    list(
                        `name`="interpretation", 
                        `title`="Clinical Impact", 
                        `type`="text")),
                clearWith=list(
                    "riskScorePoints",
                    "outcome")))
            self$add(jmvcore::Image$new(
                options=options,
                name="rocCurvesPlot",
                title="ROC Curves Comparison",
                width=600,
                height=450,
                renderFun=".plotROCCurves",
                visible="(showROCCurves)",
                clearWith=list(
                    "outcome",
                    "outcomePositive",
                    "splitData")))
            self$add(jmvcore::Array$new(
                options=options,
                name="calibrationPlotsArray",
                title="Calibration Plots",
                visible="(showCalibrationPlots)",
                template=jmvcore::Image$new(
                    options=options,
                    title="$key",
                    width=500,
                    height=400,
                    renderFun=".plotCalibration",
                    clearWith=list(
                        "outcome",
                        "outcomePositive",
                        "splitData"))))
            self$add(jmvcore::Image$new(
                options=options,
                name="modelComparisonPlot",
                title="Model Performance Comparison",
                width=700,
                height=500,
                renderFun=".plotModelComparison",
                visible="(compareModels)",
                clearWith=list(
                    "outcome",
                    "outcomePositive")))
            self$add(jmvcore::Image$new(
                options=options,
                name="validationPlot",
                title="Cross-Validation Results",
                width=600,
                height=450,
                renderFun=".plotValidation",
                visible="(crossValidation || bootstrapValidation)",
                clearWith=list(
                    "cvFolds",
                    "bootstrapReps")))
            self$add(jmvcore::Html$new(
                options=options,
                name="dcaPreparationSummary",
                title="Decision Curve Analysis Preparation",
                visible="(exportForDCA)"))}))

modelbuilderBase <- if (requireNamespace("jmvcore", quietly=TRUE)) R6::R6Class(
    "modelbuilderBase",
    inherit = jmvcore::Analysis,
    public = list(
        initialize = function(options, data=NULL, datasetId="", analysisId="", revision=0) {
            super$initialize(
                package = "ClinicoPath",
                name = "modelbuilder",
                version = c(0,0,3),
                options = options,
                results = modelbuilderResults$new(options=options),
                data = data,
                datasetId = datasetId,
                analysisId = analysisId,
                revision = revision,
                pause = NULL,
                completeWhenFilled = FALSE,
                requiresMissings = FALSE,
                weightsSupport = 'auto')
        }))

#' Prediction Model Builder
#'
#' Build and validate prediction models for medical decision making. Creates 
#' multiple logistic regression models with predicted probabilities that can 
#' be directly used in Decision Curve Analysis.
#' 
#'
#' @examples
#' \donttest{
#' # example will be added
#'}
#' @param data The data as a data frame.
#' @param outcome Binary outcome variable to predict (e.g., disease presence,
#'   adverse event occurrence).
#' @param outcomePositive Which level of the outcome variable represents the
#'   positive case.
#' @param splitData Split data into training (70\%) and validation (30\%) sets
#'   for unbiased model evaluation.
#' @param randomSeed Random seed for reproducible data splitting and results.
#' @param buildBasicModel Build a basic clinical model using demographic and
#'   primary risk factors.
#' @param basicPredictors Variables for the basic clinical model (e.g., age,
#'   sex, primary risk factors).
#' @param basicModelName Name for the basic model (used as column name for
#'   predictions).
#' @param buildEnhancedModel Build an enhanced model with additional clinical
#'   variables.
#' @param enhancedPredictors Variables for the enhanced model (should include
#'   basic predictors plus additional ones).
#' @param enhancedModelName Name for the enhanced model (used as column name
#'   for predictions).
#' @param buildBiomarkerModel Build a model incorporating biomarkers or
#'   advanced diagnostics.
#' @param biomarkerPredictors Variables for the biomarker model (clinical
#'   variables plus biomarkers).
#' @param biomarkerModelName Name for the biomarker model (used as column name
#'   for predictions).
#' @param buildCustomModel Build a custom model with user-specified variables.
#' @param customPredictors Variables for the custom model.
#' @param customModelName Name for the custom model (used as column name for
#'   predictions).
#' @param includeInteractions Include two-way interactions between predictor
#'   variables.
#' @param interactionTerms Specify interactions (e.g., "age*sex,
#'   diabetes*smoking"). Leave empty for all pairwise.
#' @param useStepwise Use stepwise variable selection to optimize models.
#' @param stepwiseDirection Direction for stepwise variable selection.
#' @param selectionCriterion Criterion for stepwise variable selection.
#' @param transformVariables Apply automatic transformations to continuous
#'   variables.
#' @param transformMethod Type of transformation to apply to continuous
#'   variables.
#' @param missingDataMethod Method for handling missing data in predictor
#'   variables.
#' @param imputationSets Number of imputation sets for multiple imputation.
#' @param crossValidation Perform k-fold cross-validation for robust model
#'   assessment.
#' @param cvFolds Number of folds for cross-validation.
#' @param bootstrapValidation Perform bootstrap validation to assess optimism
#'   and shrinkage.
#' @param bootstrapReps Number of bootstrap replications for validation.
#' @param showModelSummary Display regression coefficients and model
#'   statistics.
#' @param showPerformanceMetrics Display AUC, calibration, and other
#'   performance measures.
#' @param showCalibrationPlots Display calibration plots for each model.
#' @param showROCCurves Display ROC curves for discrimination assessment.
#' @param compareModels Display side-by-side comparison of all models.
#' @param createPredictions Add predicted probability columns to dataset for
#'   DCA use.
#' @param exportForDCA Format output specifically for use in Decision Curve
#'   Analysis module.
#' @param calculateNRI Calculate NRI comparing enhanced models to basic model.
#' @param nriThresholds Risk thresholds for NRI calculation (comma-separated).
#' @param calculateIDI Calculate IDI comparing models.
#' @param penalizedRegression Use penalized regression (LASSO/Ridge) for
#'   variable selection.
#' @param penaltyType Type of penalty for regularized regression.
#' @param generateRiskScore Create integer risk score from best model for
#'   clinical use.
#' @param riskScorePoints Method for creating clinical risk score.
#' @return A results object containing:
#' \tabular{llllll}{
#'   \code{results$instructions} \tab \tab \tab \tab \tab a html \cr
#'   \code{results$dataSummary} \tab \tab \tab \tab \tab a html \cr
#'   \code{results$dcaReadyMessage} \tab \tab \tab \tab \tab a html \cr
#'   \code{results$basicModelSummary} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$enhancedModelSummary} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$biomarkerModelSummary} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$customModelSummary} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$modelComparisonTable} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$validationResults} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$nriTable} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$idiTable} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$riskScoreTable} \tab \tab \tab \tab \tab a table \cr
#'   \code{results$rocCurvesPlot} \tab \tab \tab \tab \tab an image \cr
#'   \code{results$calibrationPlotsArray} \tab \tab \tab \tab \tab an array of images \cr
#'   \code{results$modelComparisonPlot} \tab \tab \tab \tab \tab an image \cr
#'   \code{results$validationPlot} \tab \tab \tab \tab \tab an image \cr
#'   \code{results$dcaPreparationSummary} \tab \tab \tab \tab \tab a html \cr
#' }
#'
#' Tables can be converted to data frames with \code{asDF} or \code{\link{as.data.frame}}. For example:
#'
#' \code{results$basicModelSummary$asDF}
#'
#' \code{as.data.frame(results$basicModelSummary)}
#'
#' @export
modelbuilder <- function(
    data,
    outcome,
    outcomePositive,
    splitData = TRUE,
    randomSeed = 123,
    buildBasicModel = TRUE,
    basicPredictors,
    basicModelName = "basic_model",
    buildEnhancedModel = FALSE,
    enhancedPredictors,
    enhancedModelName = "enhanced_model",
    buildBiomarkerModel = FALSE,
    biomarkerPredictors,
    biomarkerModelName = "biomarker_model",
    buildCustomModel = FALSE,
    customPredictors,
    customModelName = "custom_model",
    includeInteractions = FALSE,
    interactionTerms = "",
    useStepwise = FALSE,
    stepwiseDirection = "both",
    selectionCriterion = "aic",
    transformVariables = FALSE,
    transformMethod = "log",
    missingDataMethod = "complete_cases",
    imputationSets = 5,
    crossValidation = FALSE,
    cvFolds = 5,
    bootstrapValidation = FALSE,
    bootstrapReps = 1000,
    showModelSummary = TRUE,
    showPerformanceMetrics = TRUE,
    showCalibrationPlots = TRUE,
    showROCCurves = TRUE,
    compareModels = TRUE,
    createPredictions = TRUE,
    exportForDCA = TRUE,
    calculateNRI = FALSE,
    nriThresholds = "0.05, 0.10, 0.20",
    calculateIDI = FALSE,
    penalizedRegression = FALSE,
    penaltyType = "lasso",
    generateRiskScore = FALSE,
    riskScorePoints = "simple") {

    if ( ! requireNamespace("jmvcore", quietly=TRUE))
        stop("modelbuilder requires jmvcore to be installed (restart may be required)")

    if ( ! missing(outcome)) outcome <- jmvcore::resolveQuo(jmvcore::enquo(outcome))
    if ( ! missing(basicPredictors)) basicPredictors <- jmvcore::resolveQuo(jmvcore::enquo(basicPredictors))
    if ( ! missing(enhancedPredictors)) enhancedPredictors <- jmvcore::resolveQuo(jmvcore::enquo(enhancedPredictors))
    if ( ! missing(biomarkerPredictors)) biomarkerPredictors <- jmvcore::resolveQuo(jmvcore::enquo(biomarkerPredictors))
    if ( ! missing(customPredictors)) customPredictors <- jmvcore::resolveQuo(jmvcore::enquo(customPredictors))
    if (missing(data))
        data <- jmvcore::marshalData(
            parent.frame(),
            `if`( ! missing(outcome), outcome, NULL),
            `if`( ! missing(basicPredictors), basicPredictors, NULL),
            `if`( ! missing(enhancedPredictors), enhancedPredictors, NULL),
            `if`( ! missing(biomarkerPredictors), biomarkerPredictors, NULL),
            `if`( ! missing(customPredictors), customPredictors, NULL))

    for (v in outcome) if (v %in% names(data)) data[[v]] <- as.factor(data[[v]])

    options <- modelbuilderOptions$new(
        outcome = outcome,
        outcomePositive = outcomePositive,
        splitData = splitData,
        randomSeed = randomSeed,
        buildBasicModel = buildBasicModel,
        basicPredictors = basicPredictors,
        basicModelName = basicModelName,
        buildEnhancedModel = buildEnhancedModel,
        enhancedPredictors = enhancedPredictors,
        enhancedModelName = enhancedModelName,
        buildBiomarkerModel = buildBiomarkerModel,
        biomarkerPredictors = biomarkerPredictors,
        biomarkerModelName = biomarkerModelName,
        buildCustomModel = buildCustomModel,
        customPredictors = customPredictors,
        customModelName = customModelName,
        includeInteractions = includeInteractions,
        interactionTerms = interactionTerms,
        useStepwise = useStepwise,
        stepwiseDirection = stepwiseDirection,
        selectionCriterion = selectionCriterion,
        transformVariables = transformVariables,
        transformMethod = transformMethod,
        missingDataMethod = missingDataMethod,
        imputationSets = imputationSets,
        crossValidation = crossValidation,
        cvFolds = cvFolds,
        bootstrapValidation = bootstrapValidation,
        bootstrapReps = bootstrapReps,
        showModelSummary = showModelSummary,
        showPerformanceMetrics = showPerformanceMetrics,
        showCalibrationPlots = showCalibrationPlots,
        showROCCurves = showROCCurves,
        compareModels = compareModels,
        createPredictions = createPredictions,
        exportForDCA = exportForDCA,
        calculateNRI = calculateNRI,
        nriThresholds = nriThresholds,
        calculateIDI = calculateIDI,
        penalizedRegression = penalizedRegression,
        penaltyType = penaltyType,
        generateRiskScore = generateRiskScore,
        riskScorePoints = riskScorePoints)

    analysis <- modelbuilderClass$new(
        options = options,
        data = data)

    analysis$run()

    analysis$results
}
sbalci/ClinicoPathJamoviModule documentation built on June 13, 2025, 9:34 a.m.