Upload app.R

app.R

@@ -0,0 +1,763 @@
+library(shiny)
+library(shinyjs)
+library(bslib)
+library(dplyr)
+library(ggplot2)
+library(tm)
+library(SnowballC)
+library(plotly)
+library(text2vec)
+library(tokenizers)
+library(dplyr)
+library(tidyr)
+library(igraph)
+library(ggraph)
+library(topicmodels)
+library(wordcloud)
+library(wordcloud2)
+library(reshape2)
+library(SnowballC)
+library(RColorBrewer)
+library(syuzhet)
+library(cluster)
+library(tidytext)
+library(word2vec)
+library(Rtsne)
+library(umap)
+library(MASS)
+library(koRpus)
+library(openxlsx)
+library(tools)
+library(shinyWidgets)
+library(reticulate)
+library(keras)
+library(tensorflow)
+library(neuralnet)
+library(rsample)
+library(tfdatasets)
+library(statnet)
+library(UserNetR)
+library(visNetwork)
+library(networkD3)
+library(ergm)
+library(ergm.count)
+library(network)
+library(tidyverse)
+options(width = 150)
+options(digits = 4, scipen = 1000000000)
+options(shiny.maxRequestSize=30*1024^2)
+
+
+
+ui <- fluidPage(
+  theme = bs_theme(version = 5, bootswatch = "spacelab"),
+  useShinyjs(),  # Initialize shinyjs
+  titlePanel("PtteM Data Science"),
+  tags$head(tags$link(rel = "stylesheet", href="https://fonts.googleapis.com/css?family=Montserrat:100,300,400,700&display=swap"),
+            tags$style(HTML("
+        body, h1, h2, h3, h4, h5, h6, .nav, p, a, .shiny-input-container {
+        font-family: 'Montserrat'; /* Font type for the title attribute */
+        font-weight: 385;
+        color: #007c9e !important;
+      }
+        * {
+        font-family: 'Montserrat', sans-serif;
+        font-weight: 385; 
+        color: #195576; /* Blue color */
+      }
+        body { 
+        background-color: #f7f7f7; /* Light gray background */
+        }
+      .icon-btn {
+        border: 1px solid #0d6efd; /* Example border: solid, 2 pixels, #555 color */
+        border-radius: 15%; /* Circular border */
+        color: #00969e; /* Icon color */
+        font-family: 'Montserrat'; /* Font type for the title attribute */
+        font-weight: 385;
+        background-color: #f7f7f7;
+        padding: 125px; /* Space around the icon */
+        margin: 25px; /* Space around the button */
+        font-size: 24px; /* Icon size */
+        box-shadow: 0 2px 4px rgba(0,0,0,0.2);
+      }
+      .icon-btn:hover {
+        color: #00969e; /* Icon color on hover */
+        border-color: #007c9e;
+        background-color: #ebfbfd;/* Border color on hover */
+      }
+           /* Add custom styles here */
+      .shiny-input-container {
+        margin-bottom: 15px;
+      }
+      .box {
+        border: 1px solid #ddd;
+        padding: 20px;
+        border-radius: 50px;
+        margin-bottom: 200px;
+        gap: 200px;
+        align-items: center;
+      }
+    #statsTable_wrapper {
+      margin: 0 auto;
+    }
+    .shiny-output-error {
+    border: 1px solid #FF0000; /* Red border on error */
+    }
+      /* If you want to change the font size of the tooltip, you can add custom CSS for the 'title' attribute's default styling. */
+    "))),
+  tags$head(
+    # Include JavaScript to reload the page
+    tags$script(HTML("
+    document.addEventListener('DOMContentLoaded', function() {
+    document.getElementById('myElement').style.color = '#0d6efd'; // Change to your desired color
+  });
+"))
+  ),
+  tags$head(
+    tags$script(HTML("
+      function reloadPage() {
+        window.location.reload();
+      }
+    "))
+  ),
+  # Refresh button that calls the JavaScript function
+  actionButton("refresh", "Refresh Analysis", onclick = "reloadPage();"),
+  # Help Text or Information for the user
+  helpText("Bu uygulama ile pekiştirmeli öğrenme başlığı altındaki veri bilimi fonksiyonlarına erişebilirsiniz."),
+        #Reinforcement Learning
+        h2("Reinforcement Learning Section"),
+        tabsetPanel(
+          tabPanel("Multi-Armed Bandit (MAB) Algorithms",
+                   tabsetPanel(
+                     tabPanel("Epsilon-Greedy",
+                              sidebarLayout(
+                                sidebarPanel(
+                                  fileInput('epsgreefile', 'Upload Data File', accept = c(".csv", ".xlsx", ".xls")),
+                                  uiOutput('selectActionColumn'),
+                                  uiOutput('selectRewardColumn'),
+                                  numericInput("epsilon", "Epsilon (Exploration Rate)", value = 0.1, min = 0, max = 1, step = 0.01),
+                                  actionButton("runMAB", "Run MAB Decision"),
+                                ),
+                                mainPanel(
+                                  tableOutput("actionResults"),
+                                  textOutput("selectedAction"),
+                                )
+                              )
+                     ),
+                     tabPanel("Upper Confidence Bound (UCB)",
+                              sidebarLayout(
+                                sidebarPanel(
+                                  fileInput("ucbfile", "Upload Data File", accept = c(".csv", ".xlsx", ".xls")),
+                                  uiOutput("selectStrategyColucb"),
+                                  uiOutput("selectRewardColucb"),
+                                  numericInput("epsilon", "Epsilon (Exploration Rate)", value = 0.1, min = 0, max = 1, step = 0.01),
+                                  actionButton("runMABucb", "Run MAB Decision")
+                                ),
+                                mainPanel(
+                                  tabsetPanel(
+                                    tabPanel("Results", tableOutput("actionResultsucb")),
+                                    tabPanel("Reward History", plotlyOutput("rewardHistoryucb", width = "100%", height = "750px"))
+                                  )
+                                )
+                              )
+                     ),
+                     tabPanel("Thompson Sampling",
+                              sidebarLayout(
+                                sidebarPanel(
+                                  fileInput("tsfile", "Upload Data File", accept = c(".csv", ".xlsx", ".xls")),
+                                  uiOutput("selectStrategyColumnTS"),  # This should be in the UI part
+                                  uiOutput("selectRewardColumnTS"),
+                                  textInput("successConditionsTS", "Enter success conditions (comma separated)"),
+                                  actionButton("runMABTS", "Run MAB Thompson Sampling")
+                                ),
+                                mainPanel(
+                                  tabsetPanel(
+                                    tabPanel("Best Display", verbatimTextOutput("bestStrategyDisplayTS")),
+                                    tabPanel("Reward History TS", plotlyOutput("rewardHistoryTS", width = "100%", height = "750px")),
+                                    tabPanel("Strategy Frequency", plotlyOutput("strFrePlotTS", width = "100%", height = "750px"))
+                                  )
+                                )
+                              )
+                     ),
+                     
+                     
+                   )
+          ),
+          tabPanel("Contextual Bandits",
+                   tabsetPanel(
+                     tabPanel("Linear Regression UCB",
+                              sidebarLayout(
+                                sidebarPanel(
+                                  fileInput("lrucbfile", "Upload your dataset", accept = c(".csv", ".xlsx", ".xls")),
+                                  actionButton("loadlrucb", "Load Data"),
+                                  selectInput("targetlrucb", "Select Target Column", choices = NULL),
+                                  selectizeInput("independentVarlrucb", "Select Independent Variable", choices = NULL, multiple = FALSE),
+                                  actionButton("runModellrucb", "Run Linear Regression UCB")
+                                ),
+                                mainPanel(
+                                  tabsetPanel(
+                                    tabPanel("Model Summary", verbatimTextOutput("modelSummarylrucb")),
+                                    tabPanel("Diagnostics",
+                                             plotlyOutput("resFitlrucbPlot"),
+                                             plotlyOutput("qqPlotlrucb"),
+                                             plotlyOutput("scaleLoclrucbPlot"),
+                                             plotlyOutput("resLevlrucbPlot")
+                                    ),
+                                    tabPanel("Regression Plot", plotlyOutput("regressionPlot", width = "100%", height = "750px"))
+                                  )
+                                )
+                              )
+                     )
+                     
+                     
+                   )
+          )
+        )
+        
+
+
+)
+
+server <- function(input, output, session) {
+  ##Reinforcement Learning
+  ###Multi-Armed Bandit (MAB) Algorithms
+  ####Epsilon-Greedy
+  # Reactive to store uploaded data
+  uploadedepsgree <- reactive({
+    req(input$epsgreefile)
+    ext <- tools::file_ext(input$epsgreefile$name)
+    switch(ext,
+           csv = read.csv(input$epsgreefile$datapath, stringsAsFactors = FALSE),
+           xlsx = readxl::read_excel(input$epsgreefile$datapath),
+           stop("Unsupported file type"))
+  })
+  
+  # Dynamic UI to select the action and reward columns
+  output$selectActionColumn <- renderUI({
+    df <- uploadedepsgree()
+    req(df)
+    selectInput("actionColumn", "Select Action Column", choices = names(df))
+  })
+  
+  output$selectRewardColumn <- renderUI({
+    df <- uploadedepsgree()
+    req(df)
+    selectInput("rewardColumn", "Select Reward Column", choices = names(df))
+  })
+  
+  # Reactive values to store actions and performance metrics
+  actionRewards <- reactiveValues(actions = NULL, rewards = NULL, counts = NULL)
+  
+  observeEvent(input$runMAB, {
+    req(input$epsilon, input$actionColumn, input$rewardColumn)
+    df <- uploadedepsgree()
+    df <- df %>% dplyr::select(all_of(input$actionColumn), all_of(input$rewardColumn)) %>% na.omit() 
+    uniqueActions <- unique(df[[input$actionColumn]])
+    summedRewards <- tapply(df[[input$rewardColumn]], df[[input$actionColumn]], sum, na.rm = TRUE)
+    
+    # Store processed data in actionRewards
+    actionRewards$actions <- uniqueActions
+    actionRewards$rewards <- summedRewards
+    actionRewards$counts <- rep(10, length(uniqueActions)) # Initialize with some counts
+    
+    # Run epsilon-greedy algorithm
+    if (runif(1) < input$epsilon) {
+      # Exploration
+      selectedActionIndex <- sample(length(uniqueActions), 1)
+    } else {
+      # Exploitation
+      averages <- summedRewards / actionRewards$counts
+      selectedActionIndex <- which.max(averages)
+    }
+    
+    selectedAction <- uniqueActions[selectedActionIndex]
+    simulatedReward <- runif(1, min = 0, max = max(summedRewards)) # Simulate a reward
+    actionRewards$rewards[selectedActionIndex] <- actionRewards$rewards[selectedActionIndex] + simulatedReward
+    actionRewards$counts[selectedActionIndex] <- actionRewards$counts[selectedActionIndex] + 1
+    
+    # Update UI
+    output$selectedAction <- renderText({ selectedAction })
+    output$actionResults <- renderTable({
+      data.frame(Action = actionRewards$actions, Reward = actionRewards$rewards, Count = actionRewards$counts)
+    })
+  })
+  
+  ####Upper Confidence Bound (UCB)
+  # Reactive values to store actions and performance metrics
+  actionData <- reactiveValues(
+    actions = NULL,
+    counts = NULL,
+    rewards = NULL,
+    history = list() # Initialize the history list here
+  )
+  
+  uploadeducb <- reactive({
+    req(input$ucbfile)
+    ext <- tools::file_ext(input$ucbfile$name)
+    switch(ext,
+           csv = read.csv(input$ucbfile$datapath, stringsAsFactors = FALSE),
+           xlsx = readxl::read_excel(input$ucbfile$datapath),
+           xls = readxl::read_excel(input$ucbfile$datapath),
+           stop("Unsupported file type")
+    )
+  })
+  
+  output$selectStrategyColucb <- renderUI({
+    req(input$ucbfile)
+    data <- uploadeducb()
+    selectInput("strategyColumn", "Select Strategy Column",
+                choices = names(data), selected = names(data)[1])
+  })
+  
+  output$selectRewardColucb <- renderUI({
+    req(input$ucbfile)
+    data <- uploadeducb()
+    selectInput("rewardColumn", "Select Reward Column",
+                choices = names(data), selected = names(data)[2])
+  })
+  
+  
+  
+  observeEvent(input$runMABucb, {
+    
+    data <- uploadeducb()
+    strategyColumn <- input$strategyColumn
+    rewardColumn <- input$rewardColumn
+    
+    # Ensure numerical data for computation
+    data[[rewardColumn]] <- as.numeric(as.character(data[[rewardColumn]]))
+    
+    # Unique strategies
+    strategies <- unique(data[[strategyColumn]])
+    n <- nrow(data) # Total number of events
+    
+    if (is.null(actionData$actions)) {
+      actionData$actions <- strategies
+      actionData$counts <- rep(0, length(strategies))
+      actionData$rewards <- rep(0, length(strategies))
+      # Initialize history for each strategy
+      actionData$history <- setNames(vector("list", length(strategies)), strategies)
+      for(strategy in strategies) {
+        actionData$history[[strategy]] <- data.frame(Time = integer(), Reward = numeric())
+      }
+    }
+    
+    # Loop over strategies to compute UCB and update history
+    for (strategy in strategies) {
+      strategy_data <- data[data[[strategyColumn]] == strategy, ]
+      ni <- nrow(strategy_data) # Number of times this strategy was tried
+      avg_reward <- mean(strategy_data[[rewardColumn]], na.rm = TRUE)
+      
+      if (ni > 0) {
+        ucb_value <- avg_reward + sqrt((2 * log(n)) / ni)
+      } else {
+        ucb_value <- Inf # Encourage exploration of untried strategies
+      }
+      # Define strategy_index here, inside the loop, before you use it
+      strategy_index <- which(actionData$actions == strategy)
+      
+      actionData$counts[strategy_index] <- actionData$counts[strategy_index] + ni
+      actionData$rewards[strategy_index] <- ucb_value
+      actionData$history[[strategy]] <- rbind(
+        actionData$history[[strategy]],
+        data.frame(Time = as.integer(actionData$counts[strategy_index]), Reward = ucb_value)
+      )
+    }
+    # After the loop, the history should be updated
+  })
+  
+  output$actionResultsucb <- renderTable({
+    req(actionData$actions) # Ensure the action data is not NULL
+    data.frame(
+      Strategy = actionData$actions, 
+      Counts = actionData$counts, 
+      Rewards = actionData$rewards
+    )
+  })
+  
+  
+  
+  # Create the plot in a separate reactive context, responding to changes in actionData
+  output$rewardHistoryucb <- renderPlotly({
+    req(actionData$history) # Ensure that the history is not NULL or empty
+    
+    # Create plot_data for plotting
+    plot_data <- do.call(rbind, Filter(Negate(is.null), lapply(names(actionData$history), function(strategy) {
+      history_data <- actionData$history[[strategy]]
+      if(nrow(history_data) > 0) {
+        return(data.frame(Strategy = strategy, Time = history_data$Time, Reward = history_data$Reward))
+      }
+    })))
+    
+    # Only attempt to create a plot if plot_data is a data frame and not NULL
+    if(!is.null(plot_data) && is.data.frame(plot_data)) {
+      # Create a custom color palette with as many colors as there are strategies
+      colors <- grDevices::colorRampPalette(RColorBrewer::brewer.pal(8, "Set2"))(length(unique(plot_data$Strategy)))
+      
+      plot_ly(plot_data, x = ~Time, y = ~Reward, color = ~Strategy, colors = colors, type = 'scatter', mode = 'lines+markers') %>%
+        layout(title = "Reward History Over Time",
+               xaxis = list(title = "Time"),
+               yaxis = list(title = "Reward"))
+    } else {
+      plot_ly() %>% 
+        add_annotations(text = "No data available for plot", x = 0.5, y = 0.5, showarrow = FALSE, xref = "paper", yref = "paper")
+    }
+  })
+  
+  ####Thompson Sampling
+  uploadedTS <- reactive({
+    req(input$tsfile)
+    ext <- tools::file_ext(input$tsfile$name)
+    switch(ext,
+           csv = read.csv(input$tsfile$datapath, stringsAsFactors = FALSE),
+           xlsx = readxl::read_excel(input$tsfile$datapath),
+           xls = readxl::read_excel(input$tsfile$datapath),
+           stop("Unsupported file type: ", ext)
+    )
+  })
+  
+  # Initialize actionDataTS similar to actionData for UCB
+  actionDataTS <- reactiveValues(
+    actions = NULL,
+    successes = NULL,
+    failures = NULL,
+    theta = NULL
+  )
+  
+  
+  output$selectStrategyColumnTS <- renderUI({
+    req(input$tsfile)
+    data <- uploadedTS()
+    selectInput("selectStrategyColumnTS", "Select Strategy Column",
+                choices = names(data), selected = names(data)[1])
+  })
+  
+  output$selectRewardColumnTS <- renderUI({
+    req(input$tsfile)
+    data <- uploadedTS()
+    selectInput("selectRewardColumnTS", "Select Reward Column",
+                choices = names(data), selected = names(data)[2])
+  })
+  
+  
+  observeEvent(input$runMABTS, {
+    req(input$tsfile)
+    data <- uploadedTS()  
+    
+    strategyColumn <- input$selectStrategyColumnTS
+    rewardColumn <- input$selectRewardColumnTS
+    success_conditions <- unlist(strsplit(input$successConditionsTS, ",")) # split the input string into a vector
+    
+    if (is.null(actionDataTS$actions)) {
+      actionDataTS$actions <- unique(data[[strategyColumn]])
+      actionDataTS$successes <- rep(1, length(actionDataTS$actions)) # Start with 1 success for beta distribution
+      actionDataTS$failures <- rep(1, length(actionDataTS$actions)) # Start with 1 failure for beta distribution
+      actionDataTS$theta <- rep(0, length(actionDataTS$actions))
+      actionDataTS$history <- list() # Initialize history for plotting
+      actionDataTS$selectionCount <- rep(0, length(actionDataTS$actions)) # Initialize with zeros
+    }
+    
+    for (strategy in actionDataTS$actions) {
+      strategy_index <- which(actionDataTS$actions == strategy)
+      
+      # Define strategy_data and num_successes/num_failures after defining strategy_index
+      strategy_data <- data[data[[strategyColumn]] == strategy, ]
+      strategy_data[[rewardColumn]] <- as.numeric(strategy_data[[rewardColumn]] %in% success_conditions) # Convert to binary
+      
+      num_successes <- sum(strategy_data[[rewardColumn]], na.rm = TRUE)
+      num_failures <- nrow(strategy_data) - num_successes
+      
+      actionDataTS$successes[strategy_index] <- actionDataTS$successes[strategy_index] + num_successes
+      actionDataTS$failures[strategy_index] <- actionDataTS$failures[strategy_index] + num_failures
+      actionDataTS$theta[strategy_index] <- rbeta(1, actionDataTS$successes[strategy_index], actionDataTS$failures[strategy_index])
+      actionDataTS$selectionCount[strategy_index] <- actionDataTS$selectionCount[strategy_index] + 1
+      
+      # Update the history with the new data for plotting
+      if (is.null(actionDataTS$history[[strategy]])) {
+        actionDataTS$history[[strategy]] <- data.frame(Time = seq_along(strategy_data[[rewardColumn]]), Reward = strategy_data[[rewardColumn]])
+      } else {
+        actionDataTS$history[[strategy]] <- rbind(actionDataTS$history[[strategy]], data.frame(Time = seq_along(strategy_data[[rewardColumn]]) + nrow(actionDataTS$history[[strategy]]), Reward = strategy_data[[rewardColumn]]))
+      }
+    }
+  })
+  
+  output$bestStrategyDisplayTS <- renderPrint({
+    req(actionDataTS$theta)  # Ensure theta values have been calculated
+    best_strategy_index <- which.max(actionDataTS$theta)
+    best_strategy <- actionDataTS$actions[best_strategy_index] # Ensure this variable matches throughout your code
+    theta_value <- actionDataTS$theta[best_strategy_index]
+    
+    cat("The best strategy is:", best_strategy, "\n",
+        "Estimated success probability (theta):", theta_value)
+  })
+  
+  
+  createPlotData <- function(history) {
+    if (is.list(history) && length(history) > 0 && all(sapply(history, is.data.frame))) {
+      # Combine all strategy data frames into one, adding a 'Strategy' column
+      plot_data <- do.call(rbind, lapply(names(history), function(strategy) {
+        strategy_data <- history[[strategy]]
+        if ("Time" %in% names(strategy_data) && "Reward" %in% names(strategy_data)) {
+          strategy_data$Strategy <- strategy  # Add the 'Strategy' column
+          return(strategy_data)
+        } else {
+          # Return a data frame with missing values if required columns are not present
+          return(data.frame(Time = NA, Reward = NA, Strategy = strategy))
+        }
+      }))
+      # Remove rows with missing values
+      plot_data <- na.omit(plot_data)
+      return(plot_data)
+    } else {
+      # If history is not as expected, return an empty data frame with the correct columns
+      return(data.frame(Time = integer(0), Reward = numeric(0), Strategy = factor()))
+    }
+  }
+  
+  
+  output$rewardHistoryTS <- renderPlotly({
+    req(actionDataTS$history)  # Ensure that the history is not NULL or empty
+    
+    # Create the required plot_data using the createPlotData function
+    plot_data <- createPlotData(actionDataTS$history)
+    
+    # Check if the plot_data has rows to plot
+    if (!is.null(plot_data) && nrow(plot_data) > 0) {
+      # Create the plot with plotly
+      plot_ly(
+        data = plot_data,
+        x = ~Time,
+        y = ~Reward,
+        color = ~Strategy,
+        type = 'scatter',  # Use 'scatter' for line and point plots
+        mode = 'markers',  # Combine line and marker styles
+        marker = list(color = 'rgba(74, 93, 191, 0.7))', line = list(color = 'rgba(55, 128, 191, 1.0)', width = 2))  # Optionally, adjust marker size
+      ) %>%
+        layout(
+          title = "Reward History Over Time",
+          xaxis = list(title = "Time"),
+          yaxis = list(title = "Reward"),
+          hovermode = 'closest'  # Improves tooltip behavior
+        )
+    } else {
+      # Provide a message or an empty plot if plot_data is empty
+      return(plotly_empty())
+    }
+  })
+  output$strFrePlotTS <- renderPlotly({
+    req(input$tsfile) # Make sure a file is uploaded
+    data <- uploadedTS() # Get the uploaded data
+    
+    # Calculate the frequency of each strategy
+    strategy_freq <- table(data[[input$selectStrategyColumnTS]])
+    
+    # Convert to a data frame for plotting
+    strategy_freq_df <- as.data.frame(strategy_freq)
+    
+    # Create the plot with plotly
+    plot_ly(
+      data = strategy_freq_df,
+      x = ~Var1, # The strategy names
+      y = ~Freq, # The frequency counts
+      type = 'scatter', # Use a scatter chart
+      mode = 'markers',
+      marker = list(color = 'rgba(74, 93, 191, 0.7)', line = list(color = 'rgba(55, 128, 191, 1.0)', width = 2))
+    ) %>%
+      layout(
+        title = "Strategy Frequency",
+        xaxis = list(title = "Strategy"),
+        yaxis = list(title = "Frequency"),
+        hovermode = 'closest'
+      )
+  })
+  
+  ####Linear Regression UCB
+  # Reactive value to store preprocessed data
+  datalrucb <- reactiveVal(NULL)
+  modelsList <- reactiveVal(list())
+  # Function to read and clean data
+  read_data <- function(filepath) {
+    ext <- tools::file_ext(filepath)
+    if (ext == "csv") {
+      read.csv(filepath, stringsAsFactors = FALSE)
+    } else if (ext == "xlsx") {
+      readxl::read_excel(filepath)
+    } else {
+      stop("Invalid file format. Please select a CSV or XLSX file.")
+    }
+  }
+  
+  clean_column_names <- function(dataframe) {
+    colnames(dataframe) <- gsub("[^[:alnum:]_]", "", make.names(colnames(dataframe), unique = TRUE))
+    return(dataframe)
+  }
+  
+  # Observe load data button click
+  observeEvent(input$loadlrucb, {
+    file <- input$lrucbfile
+    req(file)
+    data_lrucb <- read_data(file$datapath)
+    data_lrucb <- clean_column_names(data_lrucb)
+    datalrucb(data_lrucb)  # Store the data
+    updateSelectInput(session, "targetlrucb", choices = colnames(data_lrucb))
+    updateSelectizeInput(session, "independentVarlrucb", choices = setdiff(colnames(data_lrucb), input$targetlrucb))
+  })
+  
+  # Function to perform safe regression
+  safe_regression <- function(data, responseVar, var) {
+    tryCatch({
+      # Print types to debug
+      #print(paste("Type of response variable:", class(data[[responseVar]])))
+      #print(paste("Type of independent variable:", class(data[[var]])))
+      
+      #if(!is.numeric(data[[var]])) {
+      #stop(paste(var, "is not numeric and will be skipped."))
+      #}
+      #if(!is.numeric(data[[responseVar]])) {
+      #stop(paste(responseVar, "is not numeric and will be skipped."))
+      #}
+      
+      # Check for missing or infinite values
+      #if(any(!is.finite(data[[var]])) || any(!is.finite(data[[responseVar]]))) {
+      #stop("Non-finite values detected in variables.")
+      #}
+      # Assuming 'data' is your data frame and 'responseVar' and 'var' are column names
+      data <- na.omit(data[c(responseVar, var)])
+      formula <- as.formula(paste(responseVar, "~", var))
+      model <- lm(formula, data = data)
+      summary_model <- summary(model)
+      ucb_estimate <- summary_model$coefficients[var, "Estimate"]
+      # Store the entire model object along with variable names
+      return(list(variable = var, model = model, ucb_estimate = ucb_estimate))
+    }, error = function(e) {
+      message("Error in regression with variable: ", var, "; Error: ", e$message)
+      return(NULL)  # Skip this variable
+    })
+  }
+  
+  
+  # Perform regression on Run Model button click
+  observeEvent(input$runModellrucb, {
+    data <- req(datalrucb())
+    responseVar <- req(input$targetlrucb)
+    var <- req(input$independentVarlrucb)
+    
+    if(!responseVar %in% names(data)) {
+      stop("Selected response variable is not in the dataset.")
+    }
+    
+    results <- safe_regression(data, responseVar, var)
+    modelsList(list(results))  # Append new result to the list
+    output$modelSummarylrucb <- renderPrint({
+      req(results)
+      if (is.null(results$ucb_estimate)) {
+        paste("Regression could not be performed for variable:", var)
+      } else {
+        paste("UCB estimate for variable", var, "is", results$ucb_estimate)
+      }
+    })
+  })
+  
+  # Server function to create diagnostic plots
+  output$resFitlrucbPlot <- renderPlotly({
+    req(modelsList(), datalrucb())
+    models <- req(modelsList())
+    
+    # Use the first model for the plot as an example
+    if (length(models) >= 1 && !is.null(models[[1]]$model)) {
+      fitted_model <- models[[1]]$model
+      p <- ggplot(fitted_model, aes(.fitted, .resid)) +
+        geom_point(color = "darkorange") +
+        geom_smooth(method = "lm", se = FALSE, color = "dodgerblue") +
+        labs(title = "Residuals vs Fitted", x = "Fitted Values", y = "Residuals")
+      
+      ggplotly(p)
+    } else {
+      return(NULL)  # No models to plot
+    }
+  })
+  
+  
+  output$qqPlotlrucb <- renderPlotly({
+    req(modelsList(), datalrucb())
+    models <- req(modelsList())
+    
+    # Use the first model for the plot as an example
+    if (length(models) >= 1 && !is.null(models[[1]]$model)) {
+      fitted_model <- models[[1]]$model
+      p <- ggplot(fitted_model, aes(sample = .stdresid)) +
+        stat_qq(color = "darkorange") +
+        stat_qq_line(color = "dodgerblue") +
+        labs(title = "Normal Q-Q")
+      
+      ggplotly(p)
+    } else {
+      return(NULL)  # No models to plot
+    }
+  })
+  
+  output$scaleLoclrucbPlot <- renderPlotly({
+    req(modelsList(), datalrucb())
+    models <- req(modelsList())
+    
+    # Use the first model for the plot as an example
+    if (length(models) >= 1 && !is.null(models[[1]]$model)) {
+      fitted_model <- models[[1]]$model
+      p <- ggplot(fitted_model, aes(.fitted, sqrt(abs(.resid)))) +
+        geom_point(color = "darkorange") +
+        geom_smooth(method = "lm", se = FALSE, color = "dodgerblue") +
+        labs(title = "Scale-Location", x = "Fitted Values", y = "Sqrt(|Residuals|)")
+      
+      ggplotly(p)
+    } else {
+      return(NULL)  # No models to plot
+    }
+  })
+  
+  output$resLevlrucbPlot <- renderPlotly({
+    req(modelsList(), datalrucb())
+    models <- req(modelsList())
+    
+    # Use the first model for the plot as an example
+    if (length(models) >= 1 && !is.null(models[[1]]$model)) {
+      fitted_model <- models[[1]]$model
+      p <- ggplot(fitted_model, aes(.hat, .stdresid)) +
+        geom_point(aes(size = .cooksd), shape = 1, color = "darkorange") +
+        geom_smooth(method = "lm", se = FALSE, color = "dodgerblue") +
+        labs(title = "Residuals vs Leverage", x = "Leverage", y = "Standardized Residuals")
+      
+      ggplotly(p)
+    } else {
+      return(NULL)  # No models to plot
+    }
+  })
+  
+  output$regressionPlot <- renderPlotly({
+    req(modelsList(), datalrucb())
+    fitted_model <- modelsList()
+    data_for_plot <- datalrucb()
+    
+    # Ensure the target and independent variables are provided
+    target_col <- input$targetlrucb
+    independent_var <- input$independentVarlrucb
+    if (is.null(data_for_plot[[target_col]]) || is.null(data_for_plot[[independent_var]])) {
+      return("Target or independent variable not found in the data.")
+    }
+    
+    # Creating the plot with added color
+    p <- ggplot(data_for_plot, aes_string(x = independent_var, y = target_col)) +
+      geom_point(color = "darkorange") +  # Change color of points
+      geom_smooth(method = "lm", se = FALSE, color = "dodgerblue") +  # Change color of regression line
+      ggtitle("Regression Line Plot") +
+      xlab(independent_var) +
+      ylab(target_col) +
+      theme_minimal() +  # Adding a minimal theme for a cleaner look
+      theme(legend.position = "none")  # Remove legend if not needed
+    
+    # Convert ggplot object to Plotly for an interactive plot
+    ggplotly(p)
+  }) 
+
+}
+
+shinyApp(ui, server)