VisualizationServer <- (id, ) {
moduleServer(
id,
(input, output, session) {
<- session$
# reactive values for task
Task_properties <- reactiveValues(task = , overview = , target = , featTypes = , positive = , tableOptions = , plotRdy = , featureImputed = )
features_to_use <- reactiveValues(features = )
learner <- reactiveValues(model = )
# count plots + additional information
counter <- reactiveValues(plotNumber = 4, nameIndicator = , plotType = , plotType2 = , plotType3 = , plotType4 = , chosenPlots = )
# final plot settings: ggplot or plotly object
finalPlots <- reactiveValues(plot1 = , plot2 = , plot3 = , plot4 = )
# plot 1 initialize values
settingPlot1 <- reactiveValues(plotName = "Importance Plot", featuresPDP = , featuresHM = , featuresPCP = , gridsize = 15, = 2, ICE = 2, targetRange = (0,1), labelSide = "Top",
labelTarget = 1, colbarReverse = 2, autoSort = 2, labelAngle = 0, plotFunction = "mean", plotPoints = 2, lossFunction = "mae")
# plot 2 initialize values
settingPlot2 <- reactiveValues(plotName = "PDP", featuresPDP = , featuresHM = , featuresPCP = , gridsize = 15, = 2, ICE = 2, targetRange = (0,1), labelSide = "Top",
labelTarget = 1, colbarReverse = 2, autoSort = 2, labelAngle = 0, plotFunction = "mean", plotPoints = 2, lossFunction = "mae")
# plot 3 initialize values
settingPlot3 <- reactiveValues(plotName = "PCP", featuresPDP = , featuresHM = , featuresPCP = , gridsize = 15, = 2, ICE = 2, targetRange = (0,1), labelSide = "Top",
labelTarget = 1, colbarReverse = 2, autoSort = 2, labelAngle = 0, plotFunction = "mean", plotPoints = 2, lossFunction = "mae")
# plot 4 initialize values
settingPlot4 <- reactiveValues(plotName = "Heatmap", featuresPDP = , featuresHM = , featuresPCP = , gridsize = 15, = 2, ICE = 2, targetRange = (0,1), labelSide = "Top",
labelTarget = 1, colbarReverse = 2, autoSort = 2, labelAngle = 0, plotFunction = "mean", plotPoints = 2, lossFunction = "mae")
##################################################################################################################
##################################################### UI #########################################################
##################################################################################################################
# first the plot types need to be initialized
# 4 different initializations of all plot types are required
# UI Plot 1
plotTypes1 <- reactive({
# initialize selected values for the 1st plot and always use current settings!
((counter$plotType))
settingPlot1$plotName <- settingPlot1$plotName
(!(input$selectPlot))
settingPlot1$plotName <- counter$plotType
(settingPlot1$plotName == "PDP") {
((input$plotFeaturesPDP))
settingPlot1$featuresPDP <- Task_properties$featureImputed[c(1)]
settingPlot1$featuresPDP <- input$plotFeaturesPDP
(!(input$gridsizePDP))
settingPlot1$gridsize <- input$gridsizePDP
(!(input$rugPDP))
settingPlot1$ <- input$rugPDP
}
(settingPlot1$plotName == "PCP") {
((input$plotFeaturesPCP))
settingPlot1$featuresPCP <- Task_properties$featureImputed
settingPlot1$featuresPCP <- input$plotFeaturesPCP
}
(settingPlot1$plotName == "Heatmap") {
((input$plotFeaturesHM))
settingPlot1$featuresHM <- Task_properties$featureImputed[c(1,2)]
settingPlot1$featuresHM <- input$plotFeaturesHM
(!(input$gridsizeHM))
settingPlot1$gridsize <- input$gridsizeHM
(!(input$rugHM))
settingPlot1$ <- input$rugHM
}
(!(input$plotIce))
settingPlot1$ICE <- input$plotIce
(!(input$constrainRange))
settingPlot1$targetRange <- input$constrainRange
(!(input$labelSide))
settingPlot1$labelSide <- input$labelSide
(!(input$labelTarget))
settingPlot1$labelTarget <- input$labelTarget
(!(input$colbarReverse))
settingPlot1$colbarReverse <- input$colbarReverse
(!(input$autoSort))
settingPlot1$autoSort <- input$autoSort
(!(input$labelAngle))
settingPlot1$labelAngle <- input$labelAngle
(!(input$plotFunction))
settingPlot1$plotFunction <- input$plotFunction
(!(input$plotPoints))
settingPlot1$plotPoints <- input$plotPoints
(!(input$lossFunction))
settingPlot1$lossFunction <- input$lossFunction
# UI for the first plot
tabsetPanel(
id = ("FunctionChoice"),
= "hidden",
header = selectInput(("selectPlot"), label = h5("Select Plot"),
choices = ("PDP", "PCP", "Heatmap","Importance Plot"),
selected = settingPlot1$plotName),
tabPanel("PDP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesPDP"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot1$featuresPDP,
= (maxItems = 2)))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizePDP"), , value = settingPlot1$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugPDP"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$, inline = ))),
conditionalPanel( = ("output['", ("numberFeatures"), "'] == false"),
fluidRow(column( 12, h5("Show ICE Curves"))),
fluidRow(column( 12, radioButtons(("plotIce"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$ICE, inline = ))))
),
tabPanel("PCP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, pickerInput(("plotFeaturesPCP"), label = ,
choices = Task_properties$featureImputed, = (`actions-box` = ), multiple = T,
selected = settingPlot1$featuresPCP))),
fluidRow(column( 12, h5("Restrict Target Range"))),
fluidRow(column( 12, sliderInput(("constrainRange"), label = , = 0,
= 1, value = settingPlot1$targetRange))),
fluidRow(column( 12, h5("Label Side"))),
fluidRow(column( 12, radioButtons(("labelSide"), label = ,
choices = ("Top" = "Top", "Bottom" = "Bottom"),
selected = settingPlot1$labelSide, inline = ))),
fluidRow(column( 12, h5("Show Target Name"))),
fluidRow(column( 12, radioButtons(("labelTarget"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$labelTarget, inline = ))),
fluidRow(column( 12, h5("Inverted Color Bar"))),
fluidRow(column( 12, radioButtons(("colbarReverse"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$colbarReverse, inline = ))),
fluidRow(column( 12, h5("Automatic Sorting"))),
fluidRow(column( 12, radioButtons(("autoSort"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$autoSort, inline = ))),
fluidRow(column( 12, h5("Label Angle"))),
fluidRow(column( 12, numericInput(("labelAngle"), , value = settingPlot1$labelAngle))),
),
tabPanel("Heatmap",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesHM"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot1$featuresHM,
= ( maxItems = 2)))),
fluidRow(column( 12, h5("Choose Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFunction"), label = ,
choices = ("mean","sd"), selected = settingPlot1$plotFunction))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizeHM"), , value = settingPlot1$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugHM"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$, inline = ))),
fluidRow(column( 12, h5("Show Plotpoints"))),
fluidRow(column( 12, radioButtons(("plotPoints"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot1$plotPoints, inline = )))
),
tabPanel("Importance Plot",
fluidRow(column( 12, h5("Select Loss Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("lossFunction"), label = ,
choices = ("ce", "f1", "mae", "mse", "rmse", "mape",
"mdae", "msle", "percent_bias", "rae", "rmsle",
"rse", "rrse", "smape"), selected = settingPlot1$lossFunction))),
), selected = settingPlot1$plotName
)
})
# UI Plot 2
plotTypes2 <- reactive({
# initialize selected values for the 2nd plot and always use current settings!
((counter$plotType2))
settingPlot2$plotName <- settingPlot2$plotName
(!(input$selectPlot2))
settingPlot2$plotName <- counter$plotType2
(settingPlot2$plotName == "PDP") {
((input$plotFeaturesPDP2))
settingPlot2$featuresPDP <- Task_properties$featureImputed[c(1)]
settingPlot2$featuresPDP <- input$plotFeaturesPDP2
(!(input$gridsizePDP2))
settingPlot2$gridsize <- input$gridsizePDP2
(!(input$rugPDP2))
settingPlot2$ <- input$rugPDP2
}
(settingPlot2$plotName == "PCP") {
((input$plotFeaturesPCP2))
settingPlot2$featuresPCP <- Task_properties$featureImputed
settingPlot2$featuresPCP <- input$plotFeaturesPCP2
}
(settingPlot2$plotName == "Heatmap") {
((input$plotFeaturesHM2))
settingPlot2$featuresHM <- Task_properties$featureImputed[c(1,2)]
settingPlot2$featuresHM <- input$plotFeaturesHM2
(!(input$gridsizeHM2))
settingPlot2$gridsize <- input$gridsizeHM2
(!(input$rugHM2))
settingPlot2$ <- input$rugHM2
}
(!(input$plotIce2))
settingPlot2$ICE <- input$plotIce2
(!(input$constrainRange2))
settingPlot2$targetRange <- input$constrainRange2
(!(input$labelSide2))
settingPlot2$labelSide <- input$labelSide2
(!(input$labelTarget2))
settingPlot2$labelTarget <- input$labelTarget2
(!(input$colbarReverse2))
settingPlot2$colbarReverse <- input$colbarReverse2
(!(input$autoSort2))
settingPlot2$autoSort <- input$autoSort2
(!(input$labelAngle2))
settingPlot2$labelAngle <- input$labelAngle2
(!(input$plotFunction2))
settingPlot2$plotFunction <- input$plotFunction2
(!(input$plotPoints2))
settingPlot2$plotPoints <- input$plotPoints2
(!(input$lossFunction2))
settingPlot2$lossFunction <- input$lossFunction2
# UI for the second plot
tabsetPanel(
id = ("FunctionChoice2"),
= "hidden",
header = selectInput(("selectPlot2"), label = h5("Select Plot"),
choices = ("PDP", "PCP", "Heatmap","Importance Plot"),
selected = settingPlot2$plotName),
tabPanel("PDP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesPDP2"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot2$featuresPDP,
= (maxItems = 2)))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizePDP2"), , value = settingPlot2$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugPDP2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$, inline = ))),
conditionalPanel( = ("output['", ("numberFeatures2"), "'] == false"),
fluidRow(column( 12, h5("Show ICE Curves"))),
fluidRow(column( 12, radioButtons(("plotIce2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$ICE, inline = ))))
),
tabPanel("PCP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, pickerInput(("plotFeaturesPCP2"), label = ,
choices = Task_properties$featureImputed, = (`actions-box` = ), multiple = T,
selected = settingPlot2$featuresPCP))),
fluidRow(column( 12, h5("Restrict Target Range"))),
fluidRow(column( 12, sliderInput(("constrainRange2"), label = , = 0,
= 1, value = settingPlot2$targetRange))),
fluidRow(column( 12, h5("Label Side"))),
fluidRow(column( 12, radioButtons(("labelSide2"), label = ,
choices = ("Top" = "Top", "Bottom" = "Bottom"),
selected = settingPlot2$labelSide, inline = ))),
fluidRow(column( 12, h5("Show Target Name"))),
fluidRow(column( 12, radioButtons(("labelTarget2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$labelTarget, inline = ))),
fluidRow(column( 12, h5("Inverted Color Bar"))),
fluidRow(column( 12, radioButtons(("colbarReverse2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$colbarReverse, inline = ))),
fluidRow(column( 12, h5("Automatic Sorting"))),
fluidRow(column( 12, radioButtons(("autoSort2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$autoSort, inline = ))),
fluidRow(column( 12, h5("Label Angle"))),
fluidRow(column( 12, numericInput(("labelAngle2"), , value = settingPlot2$labelAngle))),
),
tabPanel("Heatmap",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesHM2"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot2$featuresHM,
= ( maxItems = 2)))),
fluidRow(column( 12, h5("Choose Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFunction2"), label = ,
choices = ("mean","sd"), selected = settingPlot2$plotFunction))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizeHM2"), , value = settingPlot2$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugHM2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$, inline = ))),
fluidRow(column( 12, h5("Show Plotpoints"))),
fluidRow(column( 12, radioButtons(("plotPoints2"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot2$plotPoints, inline = )))
),
tabPanel("Importance Plot",
fluidRow(column( 12, h5("Select Loss Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("lossFunction2"), label = ,
choices = ("ce", "f1", "mae", "mse", "rmse", "mape",
"mdae", "msle", "percent_bias", "rae", "rmse", "rmsle",
"rse", "rrse", "smape"), selected = settingPlot2$lossFunction))),
), selected = settingPlot2$plotName
)
})
# UI plot 3
plotTypes3 <- reactive({
# initialize selected values for the 3rd plot and always use current settings!
((counter$plotType3))
settingPlot3$plotName <- settingPlot3$plotName
(!(input$selectPlot3))
settingPlot3$plotName <- counter$plotType3
(settingPlot3$plotName == "PDP") {
((input$plotFeaturesPDP3))
settingPlot3$featuresPDP <- Task_properties$featureImputed[c(1)]
settingPlot3$featuresPDP <- input$plotFeaturesPDP3
(!(input$gridsizePDP3))
settingPlot3$gridsize <- input$gridsizePDP3
(!(input$rugPDP3))
settingPlot3$ <- input$rugPDP3
}
(settingPlot3$plotName == "PCP") {
((input$plotFeaturesPCP3))
settingPlot3$featuresPCP <- Task_properties$featureImputed
settingPlot3$featuresPCP <- input$plotFeaturesPCP3
}
(settingPlot3$plotName == "Heatmap") {
((input$plotFeaturesHM3))
settingPlot3$featuresHM <- Task_properties$featureImputed[c(1,2)]
settingPlot3$featuresHM <- input$plotFeaturesHM3
(!(input$gridsizeHM3))
settingPlot3$gridsize <- input$gridsizeHM3
(!(input$rugHM3))
settingPlot3$ <- input$rugHM3
}
(!(input$plotIce3))
settingPlot3$ICE <- input$plotIce3
(!(input$constrainRange3))
settingPlot3$targetRange <- input$constrainRange3
(!(input$labelSide3))
settingPlot3$labelSide <- input$labelSide3
(!(input$labelTarget3))
settingPlot3$labelTarget <- input$labelTarget3
(!(input$colbarReverse3))
settingPlot3$colbarReverse <- input$colbarReverse3
(!(input$autoSort3))
settingPlot3$autoSort <- input$autoSort3
(!(input$labelAngle3))
settingPlot3$labelAngle <- input$labelAngle3
(!(input$plotFunction3))
settingPlot3$plotFunction <- input$plotFunction3
(!(input$plotPoints3))
settingPlot3$plotPoints <- input$plotPoints3
(!(input$lossFunction3))
settingPlot3$lossFunction <- input$lossFunction3
# UI for the third plot
tabsetPanel(
id = ("FunctionChoice3"),
= "hidden",
header = selectInput(("selectPlot3"), label = h5("Select Plot"),
choices = ("PDP", "PCP", "Heatmap","Importance Plot"),
selected = settingPlot3$plotName),
tabPanel("PDP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesPDP3"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot3$featuresPDP,
= (maxItems = 2)))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizePDP3"), , value = settingPlot3$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugPDP3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$, inline = ))),
conditionalPanel( = ("output['", ("numberFeatures3"), "'] == false"),
fluidRow(column( 12, h5("Show ICE Curves"))),
fluidRow(column( 12, radioButtons(("plotIce3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$ICE, inline = ))))
),
tabPanel("PCP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, pickerInput(("plotFeaturesPCP3"), label = ,
choices = Task_properties$featureImputed, = (`actions-box` = ), multiple = T,
selected = settingPlot3$featuresPCP))),
fluidRow(column( 12, h5("Restrict Target Range"))),
fluidRow(column( 12, sliderInput(("constrainRange3"), label = , = 0,
= 1, value = settingPlot3$targetRange))),
fluidRow(column( 12, h5("Label Side"))),
fluidRow(column( 12, radioButtons(("labelSide3"), label = ,
choices = ("Top" = "Top", "Bottom" = "Bottom"),
selected = settingPlot3$labelSide, inline = ))),
fluidRow(column( 12, h5("Show Target Name"))),
fluidRow(column( 12, radioButtons(("labelTarget3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$labelTarget, inline = ))),
fluidRow(column( 12, h5("Inverted Color Bar"))),
fluidRow(column( 12, radioButtons(("colbarReverse3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$colbarReverse, inline = ))),
fluidRow(column( 12, h5("Automatic Sorting"))),
fluidRow(column( 12, radioButtons(("autoSort3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$autoSort, inline = ))),
fluidRow(column( 12, h5("Label Angle"))),
fluidRow(column( 12, numericInput(("labelAngle3"), , value = settingPlot3$labelAngle))),
),
tabPanel("Heatmap",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesHM3"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot3$featuresHM,
= ( maxItems = 2)))),
fluidRow(column( 12, h5("Choose Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFunction3"), label = ,
choices = ("mean","sd"), selected = settingPlot3$plotFunction))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizeHM3"), , value = settingPlot3$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugHM3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$, inline = ))),
fluidRow(column( 12, h5("Show Plotpoints"))),
fluidRow(column( 12, radioButtons(("plotPoints3"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot3$plotPoints, inline = )))
),
tabPanel("Importance Plot",
fluidRow(column( 12, h5("Select Loss Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("lossFunction3"), label = ,
choices = ("ce", "f1", "mae", "mse", "rmse", "mape",
"mdae", "msle", "percent_bias", "rae", "rmse", "rmsle",
"rse", "rrse", "smape"), selected = settingPlot3$lossFunction))),
), selected = settingPlot3$plotName
)
})
# UI plot 4
plotTypes4 <- reactive({
# initialize selected values for the 4th plotand always use current settings!
((counter$plotType4))
settingPlot4$plotName <- settingPlot4$plotName
(!(input$selectPlot4))
settingPlot4$plotName <- counter$plotType4
(settingPlot4$plotName == "PDP") {
((input$plotFeaturesPDP4))
settingPlot4$featuresPDP <- Task_properties$featureImputed[c(1)]
settingPlot4$featuresPDP <- input$plotFeaturesPDP4
(!(input$gridsizePDP4))
settingPlot4$gridsize <- input$gridsizePDP4
(!(input$rugPDP4))
settingPlot4$ <- input$rugPDP4
}
(settingPlot4$plotName == "PCP") {
((input$plotFeaturesPCP4))
settingPlot4$featuresPCP <- Task_properties$featureImputed
settingPlot4$featuresPCP <- input$plotFeaturesPCP4
}
(settingPlot4$plotName == "Heatmap") {
((input$plotFeaturesHM4))
settingPlot4$featuresHM <- Task_properties$featureImputed[c(1,2)]
settingPlot4$featuresHM <- input$plotFeaturesHM4
(!(input$gridsizeHM4))
settingPlot4$gridsize <- input$gridsizeHM4
(!(input$rugHM4))
settingPlot4$ <- input$rugHM4
}
(!(input$plotIce4))
settingPlot4$ICE <- input$plotIce4
(!(input$constrainRange4))
settingPlot4$targetRange <- input$constrainRange4
(!(input$labelSide4))
settingPlot4$labelSide <- input$labelSide4
(!(input$labelTarget4))
settingPlot4$labelTarget <- input$labelTarget4
(!(input$colbarReverse4))
settingPlot4$colbarReverse <- input$colbarReverse4
(!(input$autoSort4))
settingPlot4$autoSort <- input$autoSort4
(!(input$labelAngle4))
settingPlot4$labelAngle <- input$labelAngle4
(!(input$plotFunction4))
settingPlot4$plotFunction <- input$plotFunction4
(!(input$plotPoints4))
settingPlot4$plotPoints <- input$plotPoints4
(!(input$lossFunction4))
settingPlot4$lossFunction <- input$lossFunction4
# UI for the fourth plot
tabsetPanel(
id = ("FunctionChoice4"),
= "hidden",
header = selectInput(("selectPlot4"), label = h5("Select Plot"),
choices = ("PDP", "PCP", "Heatmap","Importance Plot"),
selected = settingPlot4$plotName),
tabPanel("PDP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesPDP4"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot4$featuresPDP,
= (maxItems = 2)))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizePDP4"), , value = settingPlot4$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugPDP4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$, inline = ))),
conditionalPanel( = ("output['", ("numberFeatures4"), "'] == false"),
fluidRow(column( 12, h5("Show ICE Curves"))),
fluidRow(column( 12, radioButtons(("plotIce4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$ICE, inline = ))))
),
tabPanel("PCP",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, pickerInput(("plotFeaturesPCP4"), label = ,
choices = Task_properties$featureImputed, = (`actions-box` = ), multiple = T,
selected = settingPlot4$featuresPCP))),
fluidRow(column( 12, h5("Restrict Target Range"))),
fluidRow(column( 12, sliderInput(("constrainRange4"), label = , = 0,
= 1, value = settingPlot4$targetRange))),
fluidRow(column( 12, h5("Label Side"))),
fluidRow(column( 12, radioButtons(("labelSide4"), label = ,
choices = ("Top" = "Top", "Bottom" = "Bottom"),
selected = settingPlot4$labelSide, inline = ))),
fluidRow(column( 12, h5("Show Target Name"))),
fluidRow(column( 12, radioButtons(("labelTarget4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$labelTarget, inline = ))),
fluidRow(column( 12, h5("Inverted Color Bar"))),
fluidRow(column( 12, radioButtons(("colbarReverse4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$colbarReverse, inline = ))),
fluidRow(column( 12, h5("Automatic Sorting"))),
fluidRow(column( 12, radioButtons(("autoSort4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$autoSort, inline = ))),
fluidRow(column( 12, h5("Label Angle"))),
fluidRow(column( 12, numericInput(("labelAngle4"), , value = settingPlot4$labelAngle))),
),
tabPanel("Heatmap",
fluidRow(column( 12, h5("Select Features"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFeaturesHM4"), label = ,
choices = Task_properties$featureImputed,
multiple = ,
selected = settingPlot4$featuresHM,
= ( maxItems = 2)))),
fluidRow(column( 12, h5("Choose Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("plotFunction4"), label = ,
choices = ("mean","sd"), selected = settingPlot4$plotFunction))),
fluidRow(column( 12, h5("Gridsize"))),
fluidRow(column( 12, numericInput(("gridsizeHM4"), , value = settingPlot4$gridsize))),
fluidRow(column( 12, h5("Show Rug"))),
fluidRow(column( 12, radioButtons(("rugHM4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$, inline = ))),
fluidRow(column( 12, h5("Show Plotpoints"))),
fluidRow(column( 12, radioButtons(("plotPoints4"), label = ,
choices = ("Yes" = 1, "No" = 2),
selected = settingPlot4$plotPoints, inline = )))
),
tabPanel("Importance Plot",
fluidRow(column( 12, h5("Select Loss Function"))),
fluidRow(column( 12, selectizeInput(inputId = ("lossFunction4"), label = ,
choices = ("ce", "f1", "mae", "mse", "rmse", "mape",
"mdae", "msle", "percent_bias", "rae", "rmse", "rmsle",
"rse", "rrse", "smape"), selected = settingPlot4$lossFunction))),
), selected = settingPlot4$plotName
)
})
# UI-Output: choose plots section
output$choosePlots <- renderUI({
<- session$
plotNames <- ("1st Plot" = 1, "2nd Plot" = 2, "3rd Plot" = 3, "4th Plot" = 4)
(!(input$selectPlot) & !(counter$plotType))
(plotNames)[1] <- counter$plotType
(!(input$selectPlot2) & !(counter$plotType2))
(plotNames)[2] <- counter$plotType2
(!(input$selectPlot3) & !(counter$plotType3))
(plotNames)[3] <- counter$plotType3
(!(input$selectPlot4) & !(counter$plotType4))
(plotNames)[4] <- counter$plotType4
checkboxGroupInput(("numberPlots"), label = h5("Choose which plots should be calculated and displayed"),
choices = plotNames,
selected = (1,2,3,4), inline = )
})
# UI: condition for the ICE curves
# (1st plot)
output$numberFeatures <- reactive({
<- (input$plotFeaturesPDP) == 2
()
})
outputOptions(output, "numberFeatures", suspendWhenHidden = )
# (2nd plot)
output$numberFeatures2 <- reactive({
<- (input$plotFeaturesPDP2) == 2
()
})
outputOptions(output, "numberFeatures2", suspendWhenHidden = )
# (3rd plot)
output$numberFeatures3 <- reactive({
<- (input$plotFeaturesPDP3) == 2
()
})
outputOptions(output, "numberFeatures3", suspendWhenHidden = )
# (4th plot)
output$numberFeatures4 <- reactive({
<- (input$plotFeaturesPDP4) == 2
()
})
outputOptions(output, "numberFeatures4", suspendWhenHidden = )
# UI-Output: TabsetPanel
output$tabPanelUi <- renderUI({
((counter$nameIndicator))
selectedPlot <- "Plot 1"
selectedPlot <- counter$nameIndicator
tabsetPanel( = "tabs",
id = ("plotsPanel"),
tabPanel(counter$plotType, value = "Plot 1", plotTypes1()),
tabPanel(counter$plotType2, value = "Plot 2", plotTypes2()),
tabPanel(counter$plotType3, value = "Plot 3", plotTypes3()),
tabPanel(counter$plotType4, value = "Plot 4", plotTypes4()),
selected = selectedPlot)
})
# UI-Output: plot 1 rendering (final display of the plot 1)
plot1 <- reactive({
((input$numberPlots))
()
((input$numberPlots) == 1)
(is.ggplot(finalPlots$plot1))
renderPlot(finalPlots$plot1)
renderPlotly(finalPlots$plot1)
((input$numberPlots) == 2)
(is.ggplot(finalPlots$plot2))
renderPlot(finalPlots$plot2)
renderPlotly(finalPlots$plot2)
((input$numberPlots) == 3)
(is.ggplot(finalPlots$plot3))
renderPlot(finalPlots$plot3)
renderPlotly(finalPlots$plot3)
(is.ggplot(finalPlots$plot4))
renderPlot(finalPlots$plot4)
renderPlotly(finalPlots$plot4)
})
# UI-Output: plot 2 rendering (final display of the plot 2)
plot2 <- reactive({
((input$numberPlots))
()
plot1 <- (input$numberPlots)
(2 %in% input$numberPlots & 2 > plot1)
(is.ggplot(finalPlots$plot2))
renderPlot(finalPlots$plot2)
renderPlotly(finalPlots$plot2)
(3 %in% input$numberPlots & 3 > plot1)
(is.ggplot(finalPlots$plot3))
renderPlot(finalPlots$plot3)
renderPlotly(finalPlots$plot3)
(is.ggplot(finalPlots$plot4))
renderPlot(finalPlots$plot4)
renderPlotly(finalPlots$plot4)
})
# UI-Output: plot 3 rendering (final display of the plot 3)
plot3 <- reactive({
((input$numberPlots))
()
plot1 <- (input$numberPlots)
plot2 <- input$numberPlots[2]
(3 %in% input$numberPlots & 3 > plot2)
(is.ggplot(finalPlots$plot3))
renderPlot(finalPlots$plot3)
renderPlotly(finalPlots$plot3)
(is.ggplot(finalPlots$plot4))
renderPlot(finalPlots$plot4)
renderPlotly(finalPlots$plot4)
})
# UI-Output: plot 4 rendering (final display of the plot 4)
plot4 <- reactive({
(is.ggplot(finalPlots$plot4))
renderPlot(finalPlots$plot4)
renderPlotly(finalPlots$plot4)
})
# UI-Output: plot the output together! (Formatting the plots)
output$plots <- renderUI({
req(!(Task_properties$task))
req(input$FunctionChoice)
req(counter$plotNumber)
(counter$plotNumber == 1) {
fluidRow(
column(12, plot1())
)
} (counter$plotNumber == 2) {
fluidPage(
fluidRow(
column(12, plot1())
),
fluidRow(
column(12, plot2())
)
)
} (counter$plotNumber == 3) {
fluidPage(
fluidRow(
column(6, plot1()),
column(6, plot2())
),
fluidRow(
column(12, plot3())
),
)
} (counter$plotNumber == 4) {
fluidPage(
fluidRow(
column(6, plot1()),
column(6, plot2())
),
fluidRow(
column(6, plot3()),
column(6, plot4())
),
)
}
})
##################################################################################################################
######################################### observe and observerEvent ##############################################
##################################################################################################################
# create a classification or regression task
observe ({
req(!($subsetData))
req(!($target))
req($taskRdy == )
Task_properties$target <- $subsetData[data$target]]
if ((Task_properties$target)) {
Task_properties$task <- TaskRegr$(id = "current_task", backend = $subsetData, target = $target)
} if ((Task_properties$target)) {
Task_properties$task <- TaskClassif$(id = "current_task", backend = $subsetData, target = $target)
} (!(Task_properties$target)) {
shinyalert( = "Target Selection",
= userhelp"Task Creation Target"]], closeOnClickOutside = , animation = )
}
# make the task more robust for feature selection
$subsetData <- ($subsetData)
n <- ($subsetData)
featureImputed <- ()
for (i 1:n) {
(($subsetData,i])) {
((($subsetData,i])) > 2) {
newName <- ($subsetData[i])
featureImputed <- (featureImputed, newName)
}
}
{
((($subsetData,i])) > 1) {
newName <- ($subsetData[i])
featureImputed <- (featureImputed, newName)
}
}
}
Task_properties$featureImputed <- featureImputed!featureImputed %in% $target]
})
# create names for the tab panels
observeEvent(input$selectPlot, {
counter$plotType <- input$selectPlot
})
observeEvent(input$selectPlot2, {
counter$plotType2 <- input$selectPlot2
})
observeEvent(input$selectPlot3, {
counter$plotType3 <- input$selectPlot3
})
observeEvent(input$selectPlot4, {
counter$plotType4 <- input$selectPlot4
})
#observe the choice of the plot for each tab
observe({
req(!(Task_properties$task))
req(input$selectPlot)
req(input$plotsPanel)
updateTabsetPanel(inputId = "FunctionChoice", selected = input$selectPlot)
updateTabsetPanel(inputId = "FunctionChoice2", selected = input$selectPlot2)
updateTabsetPanel(inputId = "FunctionChoice3", selected = input$selectPlot3)
updateTabsetPanel(inputId = "FunctionChoice4", selected = input$selectPlot4)
Task_properties$plotRdy <-
})
# count number of plots for the output
observeEvent(input$numberPlots, {
((input$numberPlots))
counter$plotNumber <- 0
counter$plotNumber <- (input$numberPlots)
})
# observeEvent startButton to recalculate the plots
observeEvent(input$startButton, {
req(Task_properties$plotRdy == )
((input$numberPlots))
shinyalert( = "No Plot Selected!", = userhelp"No Plot Selected!"]], closeOnClickOutside = , animation = )
withProgress( = 'Making Plots:', value = 0.0, {
(1 %in% input$numberPlots){
# increase the progress bar, and update the detail text.
incProgress( detail = ("Calculating ", counter$plotType), amount = 0.2)
# pause for 0.1 seconds to simulate a long computation.
(0.1)
# plot 1
# since the output is always a string (character), we have to change each UI element by hand.
# PDP
rugPDP <- (input$rugPDP == 1, , )
plotIce <- (input$plotIce == 1, , )
# PCP
autoSort <- (input$autoSort == 1, , )
colbarReverse <- (input$colbarReverse == 1, , )
labelTarget <- (input$labelTarget == 1, , )
<- ((input$labelAngle) > 20, , )
# heatmap
plotPoints <- (input$plotPoints == 1, , )
rugHM <- (input$rugHM == 1, , )
(input$FunctionChoice == "PDP")
finalPlots$plot1 <- (task = Task_properties$task, features = input$plotFeaturesPDP, learner = learner$model, gridsize = input$gridsizePDP, = rugPDP, plotICE = plotIce)
(input$FunctionChoice == "PCP")
((input$plotFeaturesPCP) == 1) {
shinyalert( = "please select more than one parameter!", = userhelp"Not enough Parameter PCP"]], closeOnClickOutside = , animation = )
finalPlots$plot1 <- }
finalPlots$plot1 <- (task = Task_properties$task, features = input$plotFeaturesPCP, autosort = autoSort, labelside = input$labelSide, labelangle = input$labelAngle,
constrainrange = input$constrainRange, labeltarget = labelTarget, colbarreverse = colbarReverse, = , titleheight = 0.95)
(input$FunctionChoice == "Heatmap")
((input$plotFeaturesHM) != 2 & (input$plotFeaturesHM) != 0) {
shinyalert( = "please select two parameters!", = userhelp"Not enough Parameter"]], closeOnClickOutside = , animation = )
finalPlots$plot1 <- }
(input$plotFunction == "mean")
finalPlots$plot1 <- (task = Task_properties$task, features = input$plotFeaturesHM, fun = , gridsize = input$gridsizeHM, scatterplot = plotPoints, = rugHM)
finalPlots$plot1 <- (task = Task_properties$task, features = input$plotFeaturesHM, fun = , gridsize = input$gridsizeHM, scatterplot = plotPoints, = rugHM)
(input$FunctionChoice == "Importance Plot")
finalPlots$plot1 <- (task = Task_properties$task, learner = learner$model, loss = input$lossFunction)
}
(2 %in% input$numberPlots){
# increase the progress bar, and update the detail text.
incProgress( detail = ("Calculating ", counter$plotType2), amount = 0.2)
# pause for 0.1 seconds to simulate a long computation.
(0.1)
# plot 2
# since the output is always a string (character), we have to change each UI element by hand.
# PDP
rugPDP2 <- (input$rugPDP2 == 1, , )
plotIce2 <- (input$plotIce2 == 1, , )
# PCP
autoSort2 <- (input$autoSort2 == 1, , )
colbarReverse2 <- (input$colbarReverse2 == 1, , )
labelTarget2 <- (input$labelTarget2 == 1, , )
title2 <- ((input$labelAngle2) > 20, , )
# heatmap
plotPoints2 <- (input$plotPoints2 == 1, , )
rugHM2 <- (input$rugHM2 == 1, , )
(input$FunctionChoice2 == "PDP")
finalPlots$plot2 <- (task = Task_properties$task, features = input$plotFeaturesPDP2, learner = learner$model, gridsize = input$gridsizePDP2, = rugPDP2, plotICE = plotIce2)
(input$FunctionChoice2 == "PCP")
((input$plotFeaturesPCP2) == 1) {
shinyalert( = "please select more than one parameter!", = userhelp"Not enough Parameter PCP"]], closeOnClickOutside = , animation = )
finalPlots$plot2 <- }
finalPlots$plot2 <- (task = Task_properties$task, features = input$plotFeaturesPCP2, autosort = autoSort2, labelside = input$labelSide2, labelangle = input$labelAngle2,
constrainrange = input$constrainRange2, labeltarget = labelTarget2, colbarreverse = colbarReverse2, = title2, titleheight = 0.95)
(input$FunctionChoice2 == "Heatmap")
((input$plotFeaturesHM2) != 2 & (input$plotFeaturesHM2) != 0) {
shinyalert( = "please select two parameters!", = userhelp"Not enough Parameter"]], closeOnClickOutside = , animation = )
finalPlots$plot2 <- }
(input$plotFunction2 == "mean")
finalPlots$plot2 <- (task = Task_properties$task, features = input$plotFeaturesHM2, fun = , gridsize = input$gridsizeHM2, scatterplot = plotPoints2, = rugHM2)
finalPlots$plot2 <- (task = Task_properties$task, features = input$plotFeaturesHM2, fun = , gridsize = input$gridsizeHM2, scatterplot = plotPoints2, = rugHM2)
(input$FunctionChoice2 == "Importance Plot")
finalPlots$plot2 <- (task = Task_properties$task, learner = learner$model, loss = input$lossFunction2)
}
(3 %in% input$numberPlots){
# increase the progress bar, and update the detail text.
incProgress( detail = ("Calculating ", counter$plotType3), amount = 0.2)
# pause for 0.1 seconds to simulate a long computation.
(0.1)
# plot 3
# since the output is always a string (character), we have to change each UI element by hand.
# PDP
rugPDP3 <- (input$rugPDP3 == 1, , )
plotIce3 <- (input$plotIce3 == 1, , )
# PCP
autoSort3 <- (input$autoSort3 == 1, , )
colbarReverse3 <- (input$colbarReverse3 == 1, , )
labelTarget3 <- (input$labelTarget3 == 1, , )
title3 <- ((input$labelAngle3) > 20, , )
# Heatmap
plotPoints3 <- (input$plotPoints3 == 1, , )
rugHM3 <- (input$rugHM3 == 1, , )
(input$FunctionChoice3 == "PDP")
((input$plotFeaturesPDP3) == 2)
finalPlots$plot3 <- (task = Task_properties$task, features = input$plotFeaturesPDP3, learner = learner$model, gridsize = input$gridsizePDP3, = rugPDP3)
finalPlots$plot3 <- (task = Task_properties$task, features = input$plotFeaturesPDP3, learner = learner$model, gridsize = input$gridsizePDP3, = rugPDP3, plotICE = plotIce3)
(input$FunctionChoice3 == "PCP")
((input$plotFeaturesPCP3) == 1) {
shinyalert( = "please select more than one parameter!", = userhelp"Not enough Parameter PCP"]], closeOnClickOutside = , animation = )
finalPlots$plot3 <- }
finalPlots$plot3 <- (task = Task_properties$task, features = input$plotFeaturesPCP3, autosort = autoSort3, labelside = input$labelSide3, labelangle = input$labelAngle3,
constrainrange = input$constrainRange3, labeltarget = labelTarget3, colbarreverse = colbarReverse3, = title3, titleheight = 0.95)
(input$FunctionChoice3 == "Heatmap")
((input$plotFeaturesHM3) != 2 & (input$plotFeaturesHM3) != 0) {
shinyalert( = "please select two parameters!", = userhelp"Not enough Parameter"]], closeOnClickOutside = , animation = )
finalPlots$plot3 <- }
(input$plotFunction3 == "mean")
finalPlots$plot3 <- (task = Task_properties$task, features = input$plotFeaturesHM3, fun = , gridsize = input$gridsizeHM3, scatterplot = plotPoints3, = rugHM3)
finalPlots$plot3 <- (task = Task_properties$task, features = input$plotFeaturesHM3, fun = , gridsize = input$gridsizeHM3, scatterplot = plotPoints3, = rugHM3)
(input$FunctionChoice3 == "Importance Plot")
finalPlots$plot3 <- (task = Task_properties$task, learner = learner$model, loss = input$lossFunction3)
}
(4 %in% input$numberPlots){
# increase the progress bar, and update the detail text.
incProgress( detail = ("Calculating ", counter$plotType4), amount = 0.2)
# pause for 0.1 seconds to simulate a long computation.
(0.1)
# plot 4
# since the output is always a string (character), we have to change each UI element by hand.
# PDP
rugPDP4 <- (input$rugPDP4 == 1, , )
plotIce4 <- (input$plotIce4 == 1, , )
# PCP
autoSort4 <- (input$autoSort4 == 1, , )
colbarReverse4 <- (input$colbarReverse4 == 1, , )
labelTarget4 <- (input$labelTarget4 == 1, , )
title4 <- ((input$labelAngle4) > 20, , )
# heatmap
plotPoints4 <- (input$plotPoints4 == 1, , )
rugHM4 <- (input$rugHM4 == 1, , )
(input$FunctionChoice4 == "PDP")
finalPlots$plot4 <- (task = Task_properties$task, features = input$plotFeaturesPDP4, learner = learner$model, gridsize = input$gridsizePDP4, = rugPDP4, plotICE = plotIce4)
(input$FunctionChoice4 == "PCP")
((input$plotFeaturesPCP3) == 1) {
shinyalert( = "please select more than one parameter!", = userhelp"Not enough Parameter PCP"]], closeOnClickOutside = , animation = )
finalPlots$plot4 <- }
finalPlots$plot4 <- (task = Task_properties$task, features = input$plotFeaturesPCP4, autosort = autoSort4, labelside = input$labelSide4, labelangle = input$labelAngle4,
constrainrange = input$constrainRange4, labeltarget = labelTarget4, colbarreverse = colbarReverse4, = title4, titleheight = 0.95)
(input$FunctionChoice4 == "Heatmap")
((input$plotFeaturesHM4) != 2 & (input$plotFeaturesHM4) != 0) {
shinyalert( = "please select two parameters!", = userhelp"Not enough Parameter"]], closeOnClickOutside = , animation = )
finalPlots$plot4 <- }
(input$plotFunction4 == "mean")
finalPlots$plot4 <- (task = Task_properties$task, features = input$plotFeaturesHM4, fun = , gridsize = input$gridsizeHM4, scatterplot = plotPoints4, = rugHM4)
finalPlots$plot4 <- (task = Task_properties$task, features = input$plotFeaturesHM4, fun = , gridsize = input$gridsizeHM4, scatterplot = plotPoints4, = rugHM4)
(input$FunctionChoice4 == "Importance Plot")
finalPlots$plot4 <- (task = Task_properties$task, learner = learner$model, loss = input$lossFunction4)
}
incProgress( detail = "Rendering Plots", amount = 0.2)
})
})
# set random forest as the learner
observe({
req(!(Task_properties$task))
(Task_properties$task$task_type == "regr") {
learner$model = lrn("regr.ranger")
} {
learner$model = lrn("classif.ranger")
}
})
# when the data is changed, the reactive values of the current task are reset
observeEvent({$originalData
$subsetData
$manipulateData}, {
Task_properties$task <-
Task_properties$overview <-
Task_properties$target <-
Task_properties$featTypes <-
Task_properties$positive <-
Task_properties$tableOptions <-
features_to_use$features <-
Task_properties$plotRdy <-
Task_properties$featureImputed <-
})
# reset plots if the original data change
observeEvent({$originalData},{
# reset initialization of the values of plot 1
counter$plotType <- "Importance Plot"
updateSelectizeInput(session,"plotFeaturesHM", selected = Task_properties$featureImputed[c(1,2)])
updateSelectizeInput(session,"plotFeaturesPCP", selected = Task_properties$featureImputed)
updateSelectizeInput(session,"plotFeaturesPDP", selected = Task_properties$featureImputed[c(1)])
updateNumericInput(session,"gridsizePDP", value = 15)
updateNumericInput(session,"gridsizeHM", value = 15)
updateRadioButtons(session,"rugHM", selected = 2)
updateRadioButtons(session,"rugPDP", selected = 2)
updateRadioButtons(session,"plotIce", selected = 2)
updateSliderInput(session,"constrainRange", value = (0,1))
updateRadioButtons(session,"labelSide", selected = "Top")
updateRadioButtons(session,"labelTarget", selected = 1)
updateRadioButtons(session,"colbarReverse", selected = 2)
updateRadioButtons(session,"autoSort", selected = 2)
updateNumericInput(session,"labelAngle", value = 0)
updateSelectizeInput(session,"plotFunction", selected = "mean")
updateRadioButtons(session,"plotPoints", selected = 2)
updateSelectizeInput(session, "lossFunction", selected = "mae")
# reset initialization of the values of plot 2
counter$plotType2 <- "PDP"
updateSelectizeInput(session,"plotFeaturesHM2", selected = Task_properties$featureImputed[c(1,2)])
updateSelectizeInput(session,"plotFeaturesPCP2", selected = Task_properties$featureImputed)
updateSelectizeInput(session,"plotFeaturesPDP2", selected = Task_properties$featureImputed[c(1)])
updateNumericInput(session,"gridsizePDP2", value = 15)
updateNumericInput(session,"gridsizeHM2", value = 15)
updateRadioButtons(session,"rugHM2", selected = 2)
updateRadioButtons(session,"rugPDP2", selected = 2)
updateRadioButtons(session,"plotIce2", selected = 2)
updateSliderInput(session,"constrainRange2", value = (0,1))
updateRadioButtons(session,"labelSide2", selected = "Top")
updateRadioButtons(session,"labelTarget2", selected = 1)
updateRadioButtons(session,"colbarReverse2", selected = 2)
updateRadioButtons(session,"autoSort2", selected = 2)
updateNumericInput(session,"labelAngle2", value = 0)
updateSelectizeInput(session,"plotFunction2", selected = "mean")
updateRadioButtons(session,"plotPoints2", selected = 2)
updateSelectizeInput(session, "lossFunction2", selected = "mae")
# reset initialization of the values of plot 3
counter$plotType3 <- "PCP"
updateSelectizeInput(session,"plotFeaturesHM3", selected = Task_properties$featureImputed[c(1,2)])
updateSelectizeInput(session,"plotFeaturesPCP3", selected = Task_properties$featureImputed)
updateSelectizeInput(session,"plotFeaturesPDP3", selected = Task_properties$featureImputed[c(1)])
updateNumericInput(session,"gridsizePDP3", value = 15)
updateNumericInput(session,"gridsizeHM3", value = 15)
updateRadioButtons(session,"rugHM3", selected = 2)
updateRadioButtons(session,"rugPDP3", selected = 2)
updateRadioButtons(session,"plotIce3", selected = 2)
updateSliderInput(session,"constrainRange3", value = (0,1))
updateRadioButtons(session,"labelSide3", selected = "Top")
updateRadioButtons(session,"labelTarget3", selected = 1)
updateRadioButtons(session,"colbarReverse3", selected = 2)
updateRadioButtons(session,"autoSort3", selected = 2)
updateNumericInput(session,"labelAngle3", value = 0)
updateSelectizeInput(session,"plotFunction3", selected = "mean")
updateRadioButtons(session,"plotPoints3", selected = 2)
updateSelectizeInput(session, "lossFunction3", selected = "mae")
# initialization of the values of plot 4
counter$plotType4 <- "Heatmap"
updateSelectizeInput(session,"plotFeaturesHM4", selected = Task_properties$featureImputed[c(1,2)])
updateSelectizeInput(session,"plotFeaturesPCP4", selected = Task_properties$featureImputed)
updateSelectizeInput(session,"plotFeaturesPDP4", selected = Task_properties$featureImputed[c(1)])
updateNumericInput(session,"gridsizePDP4", value = 15)
updateNumericInput(session,"gridsizeHM4", value = 15)
updateRadioButtons(session,"rugHM4", selected = 2)
updateRadioButtons(session,"rugPDP4", selected = 2)
updateRadioButtons(session,"plotIce4", selected = 2)
updateSliderInput(session,"constrainRange4", value = (0,1))
updateRadioButtons(session,"labelSide4", selected = "Top")
updateRadioButtons(session,"labelTarget4", selected = 1)
updateRadioButtons(session,"colbarReverse4", selected = 2)
updateRadioButtons(session,"autoSort4", selected = 2)
updateNumericInput(session,"labelAngle4", value = 0)
updateSelectizeInput(session,"plotFunction4", selected = "mean")
updateRadioButtons(session,"plotPoints4", selected = 2)
updateSelectizeInput(session, "lossFunction4", selected = "mae")
finalPlots$plot1 <-
finalPlots$plot2 <-
finalPlots$plot3 <-
finalPlots$plot4 <-
plot1()
plot2()
plot3()
plot4()
})
# observe the task and filter the data if necessary. This code block is mostly taken from mlr3Shiny.
observe({
req(!(Task_properties$task))
# get bad features
allfeat <- Task_properties$task$feature_types
bad <- ("POSIXct", "complex", "Date")
badfeat <- allfeat[which(allfeat, 2]$ %in% bad), ]$id
features_to_use$features <- allfeat!badfeat,]$id
# deactivate unwanted features
Task_properties$task$select(cols = features_to_use$features)
if ((badfeat)) {
shinyalert( = "Features Dropped", = userhelp"Features Dropped"]], closeOnClickOutside = , animation = )
}
### mlr task is R6 Object, Shiny cannot see, when this object's state changes cause its modified in place
### to ensure that the table still updates when the features are removed later on, assign it an extra reactive value
Task_properties$featTypes <- Task_properties$task$feature_types
if (!(Task_properties$task$properties, (0)) && Task_properties$task$properties == "twoclass") {
Task_properties$positive <- Task_properties$task$positive
}
# add positive label if twoclass
Task_properties$overview <- (
task_id <- Task_properties$task$id,
task_property = Task_properties$task$properties,
task_type = Task_properties$task$task_type,
cols = Task_properties$task$,
observations = Task_properties$task$,
target = (Task_properties$task$target_names),
features = Task_properties$featTypes
)
})
# always give feedback when the user switched the plot
observeEvent(
input$plotsPanel, {
(input$plotsPanel == "Plot 1")
counter$nameIndicator <- "Plot 1"
(input$plotsPanel == "Plot 2")
counter$nameIndicator <- "Plot 2"
(input$plotsPanel == "Plot 3")
counter$nameIndicator <- "Plot 3"
(input$plotsPanel == "Plot 4")
counter$nameIndicator <- "Plot 4"
},priority = 2
)
}
)
}
