Upload app.R

app.R

@@ -0,0 +1,1275 @@
+library(shiny)
+library(shinyjs)
+library(bslib)
+library(dplyr)
+library(ggplot2)
+library(tm)
+library(SnowballC)
+library(plotly)
+library(dplyr)
+library(tidyr)
+library(igraph)
+library(ggraph)
+library(reshape2)
+library(SnowballC)
+library(RColorBrewer)
+library(syuzhet)
+library(cluster)
+library(Rtsne)
+library(umap)
+library(MASS)
+library(koRpus)
+library(openxlsx)
+library(tools)
+library(shinyWidgets)
+library(readxl)
+library(scales)
+library(caret)
+library(BBmisc)
+library(glmnet)
+library(pROC)
+library(ROCR)
+library(car)
+library(ResourceSelection)
+library(tree)
+library(ggplotify)
+library(lmtest)
+library(gridExtra)
+library(patchwork)
+library(caret)
+library(randomForest)
+library(gbm)
+library(earth)
+library(broom)
+library(rlang)
+library(ggdendro)
+library(pastecs)
+library(forecast)
+library(scales)
+library(caret)
+library(BBmisc)
+library(glmnet)
+library(pROC)
+library(ROCR)
+library(car)
+library(ResourceSelection)
+library(tree)
+library(ggplotify)
+library(lmtest)
+library(gridExtra)
+library(patchwork)
+library(caret)
+library(randomForest)
+library(gbm)
+library(earth)
+library(broom)
+library(rlang)
+library(ggdendro)
+library(pastecs)
+library(dbscan)
+library(fpc)
+library(factoextra)
+library(scales)
+library(openxlsx)
+library(arules)
+library(arulesViz)
+library(viridis)
+library(kohonen)
+library(purrr)
+library(rvest)
+library(Rtsne)
+library(shinydashboard)
+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 metin analizi başlığı altındaki veri bilimi fonksiyonlarına erişebilirsiniz."),
+  #Unupervised Learning
+        h2("Unsupervised Learning Section"),
+        tabsetPanel(
+          tabPanel("Principal Component Analysis",
+                   sidebarLayout(
+                     sidebarPanel(
+                       fileInput("pcainput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
+                       # Conditional panel for group selection
+                       uiOutput("groupSelectUI"),
+                       actionButton("loadpca", "Load Data"),
+                       selectInput("independentVarpca", "Select Columns", choices = NULL, multiple = T),
+                       actionButton("runpca", "Run PCA"),
+                       HTML("<div>
+  <h2>Ana Bileşen Analizi (PCA) Paneli</h2>
+  
+  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
+  <p>Ana Bileşen Analizi (PCA), veri setlerindeki boyutluluğu azaltmak ve en önemli özellikleri belirlemek için kullanılan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki ana bileşenleri analiz etmelerine, önemli özellikleri keşfetmelerine ve veri setlerinin görselleştirilmesine olanak tanır.</p>
+  
+  <h3>Kullanım Adımları:</h3>
+  <ol>
+    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
+    <li><strong>Bağımsız Değişkenlerin Seçimi:</strong> Analizde kullanılacak bağımsız değişkenleri seçin.</li>
+    <li><strong>PCA Çalıştırma:</strong> Ana bileşen analizini çalıştırın ve sonuçları inceleyin.</li>
+  </ol>
+  
+  <h3>Kullanıcı Etkileşimi:</h3>
+  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir ve PCA sonuçlarını detaylı bir şekilde inceleyebilir. Panel, boyut indirgeme ve özellik seçimi konularında kullanıcıya rehberlik eder.</p>
+  
+  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
+  <p>PCA, yüksek boyutlu veri setlerinin anlaşılmasını ve yorumlanmasını kolaylaştırır. Özellikle, çok sayıda değişken içeren veri setlerinde, önemli özellikleri belirlemek ve veri setlerini daha basit hale getirmek için kullanılır.</p>
+  
+  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
+  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
+  
+  <h3>Sonuçların Yorumlanması:</h3>
+  <p>PCA sonuçları, veri setindeki değişkenler arasındaki ilişkileri ve veri setinin ana bileşenlerini ortaya koyar. Bu, veri setinin daha basit bir şekilde anlaşılmasını ve analiz edilmesini sağlar.</p>
+  
+  <ul>
+    <li><strong>Model Özeti:</strong> PCA modelinin temel özellikleri ve bileşenlerinin açıkladığı varyans miktarı hakkında bilgiler sunar.</li>
+    <li><strong>Bi Plot:</strong> Ana bileşenlerin ve değişkenlerin birbirleriyle olan ilişkisini görsel olarak gösterir. Bu, hangi değişkenlerin PCA sonuçlarını en çok etkilediğini anlamada yardımcı olur.</li>
+  </ul>
+  
+  <p>PCA paneli, kullanıcıların veri setlerindeki temel yapıyı keşfetmelerine ve önemli özellikleri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
+</div>")
+                     ),
+                     mainPanel(
+                       tabsetPanel(
+                         tabPanel("Data Summary", verbatimTextOutput("dataSummarypca")),
+                         tabPanel("PCA Output",
+                                  tabsetPanel(
+                                    tabPanel("Run PCA", verbatimTextOutput("runpca")),
+                                    tabPanel("Bi Plot Columns", plotlyOutput("biPlotpca", width = "100%", height = "625px")),
+                                  )
+                         )
+                       )
+                     )
+                   )
+          ),
+          tabPanel("K-Means Clustering",
+                   sidebarLayout(
+                     sidebarPanel(
+                       fileInput("kmcinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
+                       actionButton("loadkmc", "Load Data"),
+                       selectInput("targetkmc", "Select First Column", choices = NULL),
+                       selectInput("independentVarkmc", "Select Second Column", choices = NULL),
+                       numericInput("numCenterskmc", "Number of Clusters:", value = 3, min = 2),
+                       actionButton("runkmc", "Run K-Means"),
+                       HTML("<div>
+  <h2>K-Ortalama Kümeleme Paneli</h2>
+  
+  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
+  <p>K-Ortalama Kümeleme, veri setlerini benzer özelliklere göre gruplara ayırmak için kullanılan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki kümeleri analiz etmelerine, farklı grupları keşfetmelerine ve veri setlerinin kümeleme sonuçlarını görselleştirmelerine olanak tanır.</p>
+  
+  <h3>Kullanım Adımları:</h3>
+  <ol>
+    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
+    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
+    <li><strong>Küme Sayısı Belirleme:</strong> Oluşturulacak kümelerin sayısını belirleyin.</li>
+    <li><strong>K-Ortalama Kümeleme Çalıştırma:</strong> K-Ortalama Kümeleme algoritmasını çalıştırın ve sonuçları inceleyin.</li>
+  </ol>
+  
+  <h3>Kullanıcı Etkileşimi:</h3>
+  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri ve küme sayısını belirleyebilir ve K-Ortalama Kümeleme sonuçlarını detaylı bir şekilde inceleyebilir. Panel, kümeleme ve gruplandırma konularında kullanıcıya rehberlik eder.</p>
+  
+  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
+  <p>K-Ortalama Kümeleme, veri setlerindeki doğal gruplandırmaları keşfetmek ve veri içgörülerini artırmak için yaygın olarak kullanılır. Özellikle, müşteri segmentasyonu, hedefleme ve benzer gruplar içindeki eğilimleri anlama gibi alanlarda tercih edilir.</p>
+  
+  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
+  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
+  
+  <h3>Sonuçların Yorumlanması:</h3>
+  <p>K-Ortalama Kümeleme sonuçları, veri setindeki grupların merkezlerini, her bir kümenin içerdiği gözlem sayısını ve kümeler arasındaki benzerlik/dissimilarity ölçülerini içerir. Bu, veri setinin daha derin bir şekilde anlaşılmasını ve stratejik kararlar alınmasını sağlar.</p>
+  
+  <ul>
+    <li><strong>Model Özeti:</strong> K-Ortalama Kümeleme modelinin temel özellikleri ve kümelerin özellikleri hakkında bilgiler sunar.</li>
+    <li><strong>Kümeleme Grafiği:</strong> Oluşturulan kümelerin ve merkezlerinin görsel bir temsilidir. Bu, hangi gözlemlerin hangi kümeye ait olduğunu anlamada yardımcı olur.</li>
+    <li><strong>Silüet Sonuçları:</strong> Kümeleme kalitesinin bir göstergesi olan silüet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
+  </ul>
+  
+  <p>K-Ortalama Kümeleme paneli, kullanıcıların veri setlerindeki doğal gruplandırmaları keşfetmeler
+
+ine ve önemli özellikleri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
+</div>")
+                     ),
+                     mainPanel(
+                       tabsetPanel(
+                         tabPanel("Data Summary", verbatimTextOutput("dataSummarykmc")),
+                         tabPanel("K-Means Output",
+                                  tabsetPanel(
+                                    tabPanel("Run K-Means", verbatimTextOutput("runkmc")),
+                                    tabPanel("Clustering Plot", plotlyOutput("clusteringPlotkmc", width = "100%", height = "625px")),
+                                    tabPanel("Silhouttte Results", plotlyOutput("silhouettePlotkmc", width = "100%", height = "625px"))
+                                  )
+                         )
+                       )
+                     )
+                   )
+          ),
+          tabPanel("Hierarchical Clustering",
+                   sidebarLayout(
+                     sidebarPanel(
+                       fileInput("hcinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
+                       actionButton("loadhc", "Load Data"),
+                       selectInput("independentVarhc", "Select the Columns", choices = NULL, multiple = TRUE),
+                       numericInput("numCentershc", "Number of Clusters:", value = 2, min = 2, max = 8),
+                       actionButton("runavehc", "Run Average Linkage"),
+                       actionButton("runcenhc", "Run Centroid Linkage"),
+                       actionButton("runwddhc", "Run Ward D2 Linkage"),
+                       actionButton("runmchc", "Run Mcquity Linkage"),
+                       HTML("<div>
+  <h2>Hiyerarşik Kümeleme Paneli</h2>
+  
+  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
+  <p>Hiyerarşik Kümeleme, veri noktalarını adım adım birleştirerek veya bölererek hiyerarşik bir kümeler dizisi oluşturan bir yöntemdir. Bu panel, kullanıcıların veri setlerindeki doğal gruplamaları keşfetmelerine, farklı kümeleme yöntemlerini denemelerine ve sonuçları görselleştirmelerine olanak tanır.</p>
+  
+  <h3>Kullanım Adımları:</h3>
+  <ol>
+    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
+    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
+    <li><strong>Küme Sayısı Belirleme:</strong> Oluşturulacak kümelerin sayısını belirleyin.</li>
+    <li><strong>Kümeleme Yöntemlerini Çalıştırma:</strong> Ortalama, merkez, Ward D2 veya Mcquity bağlantı yöntemlerinden birini seçerek çalıştırın.</li>
+  </ol>
+  
+  <h3>Kullanıcı Etkileşimi:</h3>
+  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri ve küme sayısını belirleyebilir, farklı hiyerarşik kümeleme yöntemlerini deneyebilir ve sonuçları detaylı bir şekilde inceleyebilir.</p>
+  
+  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
+  <p>Hiyerarşik Kümeleme, özellikle müşteri segmentasyonu, gen ifadesi analizi ve sosyal ağ analizi gibi alanlarda kullanılır. Bu yöntem, veri setlerindeki doğal gruplamaları ve ilişkileri keşfetmek için önemli bir araçtır.</p>
+  
+  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
+  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
+  
+  <h3>Sonuçların Yorumlanması:</h3>
+  <p>Hiyerarşik Kümeleme sonuçları, dendrogramlar ve siluet analizleri aracılığıyla sunulur. Dendrogramlar, veri noktaları arasındaki ilişkilerin ve gruplamaların hiyerarşik yapısını gösterirken, siluet analizleri, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını değerlendirir.</p>
+  
+  <ul>
+    <li><strong>Model Özeti:</strong> Seçilen kümeleme yönteminin temel özellikleri ve kümelerin özellikleri hakkında bilgiler sunar.</li>
+    <li><strong>Dendrogram:</strong> Veri noktaları arasındaki ilişkilerin ve gruplamaların hiyerarşik yapısını gösterir. Her bir kümeleme yöntemi için ayrı dendrogramlar sunulur.</li>
+    <li><strong>Siluet Sonuçları:</strong> Kümeleme kalitesinin bir göstergesi olan siluet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
+  </ul>
+  
+  <p>Hiyerarşik Kümeleme paneli, kullanıcıların veri setlerindeki doğal gruplamaları keşfetmelerine ve önemli özellik
+
+leri belirlemelerine yardımcı olan kapsamlı bir araçtır.</p>
+</div>")
+                     ),
+                     mainPanel(
+                       tabsetPanel(
+                         tabPanel("Data Summary", verbatimTextOutput("dataSummaryhc")),
+                         tabPanel("Hierarchical Clustering",
+                                  tabsetPanel(
+                                    tabPanel("Average Linkage",plotlyOutput("averageDendrogram", width = "100%", height = "825px")),
+                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCave", width = "100%", height = "625px")),
+                                    tabPanel("Centroid Linkage",plotlyOutput("centroidDendrogram", width = "100%", height = "825px")),
+                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCcen", width = "100%", height = "625px")),
+                                    tabPanel("Ward D2 Linkage", plotlyOutput("wdd2Dendrogram", width = "100%", height = "825px")),
+                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCwdd2", width = "100%", height = "625px")),
+                                    tabPanel("Mcquity Linkage", plotlyOutput("mcquDendrogram", width = "100%", height = "825px")),
+                                    tabPanel("Silhoutte Results", plotlyOutput("silhouettePlotHCmc", width = "100%", height = "625px"))
+                                  )
+                         )
+                       )
+                     )
+                   )
+          ),
+          tabPanel("DBSCAN Clustering",
+                   sidebarLayout(
+                     sidebarPanel(
+                       fileInput("dbscaninput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
+                       actionButton("loaddbscan", "Load Data"),
+                       selectInput("independentVardbscan", "Select Columns", choices = NULL, multiple = T),
+                       actionButton("rundbscandist", "Run kNN"),
+                       actionButton("rundbscan", "Run DBSCAN"),
+                       numericInput("numepsdbscan", "Type Optimum Epsilon:", value = 0),
+                       HTML("<div>
+  <h2>DBSCAN Kümeleme Paneli</h2>
+  
+  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
+  <p>DBSCAN (Yoğunluk Tabanlı Mekansal Kümeleme Uygulamaları ile Gürültü), veri noktalarını yoğunluk temelinde kümeler halinde gruplandıran bir kümeleme algoritmasıdır. Bu panel, kullanıcıların yoğunluk tabanlı kümeleri keşfetmelerine ve gürültülü veri noktalarını ayırt etmelerine olanak tanır.</p>
+  
+  <h3>Kullanım Adımları:</h3>
+  <ol>
+    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
+    <li><strong>Değişkenlerin Seçimi:</strong> Kümelemede kullanılacak değişkenleri seçin.</li>
+    <li><strong>kNN Mesafesinin Çalıştırılması:</strong> Optimum epsilon değerini belirlemek için kNN mesafesini çalıştırın.</li>
+    <li><strong>DBSCAN Kümelemesini Çalıştırma:</strong> Belirlenen epsilon değeriyle DBSCAN kümelemesini çalıştırın.</li>
+  </ol>
+  
+  <h3>Kullanıcı Etkileşimi:</h3>
+  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir, optimum epsilon değerini belirleyebilir ve DBSCAN algoritmasını kullanarak kümeleme yapabilir.</p>
+  
+  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
+  <p>DBSCAN, özellikle düzensiz şekillerdeki kümeleri tanıyabilme ve aykırı değerleri (gürültüyü) dışlayabilme yeteneği nedeniyle, veri madenciliği, görüntü analizi ve biyoinformatik gibi alanlarda kullanılır.</p>
+  
+  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
+  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
+  
+  <h3>Sonuçların Yorumlanması:</h3>
+  <p>DBSCAN Kümeleme sonuçları, kNN mesafe grafiği, kümeleme özeti, kümeleme görselleştirmesi ve siluet analizi aracılığıyla sunulur. kNN mesafe grafiği, optimum epsilon değerinin belirlenmesine yardımcı olur. Kümeleme özeti, oluşturulan kümeler ve her birindeki veri noktası sayısını içerir. Kümeleme görselleştirmesi, oluşturulan kümelerin dağılımını gösterir. Siluet analizi, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını değerlendirir.</p>
+  
+  <ul>
+    <li><strong>kNN Mesafe Grafiği:</strong> Optimum epsilon değerinin belirlenmesine yardımcı olan bir grafiği içerir.</li>
+    <li><strong>Kümeleme Özeti:</strong> Oluşturulan kümelerin sayısını ve her birindeki veri noktası sayısını gösterir.</li>
+    <li><strong>Kümeleme Görselleştirmesi:</strong> Oluşturulan kümelerin mekansal dağılımını gösterir.</li>
+    <li><strong>Siluet Analizi:</strong> Kümeleme kalitesinin bir göstergesi olan siluet skorlarını içerir. Bu skorlar, kümelerin ne kadar iyi tanımlandığını ve ayrıldığını gösterir.</li>
+  </ul>
+  
+  <p>DBSCAN Kümeleme Paneli, veri setlerindeki doğal kümeleri keşfetmek ve veri içgörülerini elde etmek için güçlü bir araçtır.</p>
+</div>")
+                     ),
+                     mainPanel(
+                       tabsetPanel(
+                         tabPanel("Data Summary", verbatimTextOutput("dataSummarydbscan")),
+                         tabPanel("DBSCAN Output",
+                                  tabsetPanel(
+                                    tabPanel("kNN Plot", plotOutput("rundbscandist", width = "100%", height = "625px")),
+                                    tabPanel("Run DBSCAN", verbatimTextOutput("rundbscan")),
+                                    tabPanel("Clustering Plot", plotlyOutput("clusteringPlotdbscan", width = "100%", height = "625px")),
+                                    tabPanel("Silhoutte Result", plotlyOutput("silhouettePlotdbscan", width = "100%", height = "625px"))
+                                  )
+                         )
+                       )
+                     )
+                   )
+          ),
+          tabPanel("Associated Rule Learning",
+                   sidebarLayout(
+                     sidebarPanel(
+                       fileInput("arlinput", "Choose a CSV or XLSX file", accept = c(".csv", ".xlsx")),
+                       actionButton("loadarl", "Load Data"),
+                       selectInput("targetarl", "Select ID Column", choices = NULL),
+                       selectInput("itemsColumn", "Select Basket Column", choices = NULL),
+                       actionButton("runarl", "Run ARL"),
+                       HTML("<div>
+  <h2>İlişkisel Kural Öğrenimi Paneli</h2>
+  
+  <h3>Çıktı Nedir ve Neden Kullanılır?</h3>
+  <p>İlişkisel Kural Öğrenimi (ARL), veri setlerindeki öğeler arasındaki ilişkileri ve sıklıkla birlikte gerçekleşen öğe setlerini keşfetmek için kullanılan bir veri madenciliği tekniğidir. Bu panel, Apriori algoritmasını kullanarak ilişkisel kuralları belirlemeye ve bu kuralların önemini değerlendirmeye yardımcı olur.</p>
+  
+  <h3>Kullanım Adımları:</h3>
+  <ol>
+    <li><strong>Veri Dosyası Yükleme:</strong> Analize başlamak için bir CSV veya XLSX dosyası yükleyin.</li>
+    <li><strong>Değişkenlerin Seçimi:</strong> Analiz için ID ve sepet sütunlarını seçin.</li>
+    <li><strong>ARL Çalıştırma:</strong> İlişkisel kural öğrenimini başlatmak için 'Run ARL' düğmesine tıklayın.</li>
+  </ol>
+  
+  <h3>Kullanıcı Etkileşimi:</h3>
+  <p>Kullanıcılar, veri setlerini yükleyebilir, analiz için değişkenleri seçebilir ve ARL algoritmasını çalıştırabilir. Elde edilen kurallar, önem sırasına göre sıralanır ve kullanıcıya sunulur.</p>
+  
+  <h3>Veri Bilimi ve Makine Öğrenmesindeki Uygulamaları:</h3>
+  <p>ARL, perakende satış analizleri, ürün öneri sistemleri ve müşteri satın alma davranışlarının incelenmesi gibi alanlarda kullanılır. Bu yöntem, veri setlerindeki gizli ilişkileri ortaya çıkararak iş kararları için değerli içgörüler sağlar.</p>
+  
+  <h3>Desteklenen Dosya Tipleri ve Seçenekler:</h3>
+  <p>Panel, CSV (.csv) ve Excel (.xlsx) formatlarını destekler, bu da kullanıcıların farklı veri kaynaklarından kolaylıkla veri yüklemesine olanak tanır.</p>
+  
+  <h3>Sonuçların Yorumlanması:</h3>
+  <p>İlişkisel kural öğrenim sonuçları, madde frekans grafiği, Apriori algoritması çıktısı ve sıralı ARL çıktısı aracılığıyla sunulur. Madde frekans grafiği, veri setindeki öğelerin sıklığını gösterir. Apriori algoritması çıktısı, elde edilen kuralları ve bu kuralların destek, güven ve kaldıraç değerlerini içerir. Sıralı ARL çıktısı, kuralların önem sırasına göre sıralanmasını sağlar, bu da kullanıcıların en önemli kuralları kolaylıkla belirlemesine yardımcı olur.</p>
+  
+  <ul>
+    <li><strong>Madde Frekans Grafiği:</strong> Veri setindeki öğelerin sıklığını gösterir.</li>
+    <li><strong>Apriori Algoritması Çıktısı:</strong> Elde edilen kuralları ve bu kuralların destek, güven ve kaldıraç değerlerini içerir.</li>
+    <li><strong>Sıralı ARL Çıktısı:</strong> Kuralların önem sırasına göre sıralanmasını sağlar.</li>
+  </ul>
+  
+  <p>İlişkisel Kural Öğrenimi Paneli, veri setlerindeki ilişkisel kuralları keşfetmek ve veri içgörülerini elde etmek için güçlü bir araçtır
+
+.</p>
+</div>")
+                     ),
+                     mainPanel(
+                       tabsetPanel(
+                         tabPanel("ARL Plot", plotlyOutput("itemFreqPlot", width = "100%", height = "625px")),
+                         tabPanel("Run Appriori", verbatimTextOutput("runarlapp")),
+                         tabPanel("Sorted ARL Output", verbatimTextOutput("sortedARLOutput"))
+                       )
+                     )
+                   )
+          ),
+
+          
+        )
+
+)
+
+server <- function(input, output, session) {
+
+  ##Unsupervised Learning
+  ###Principal Component Analysis
+  datapca <- reactiveVal(NULL)
+  pca_model_reactive <- reactiveVal()
+  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)
+  }
+  # Load and clean data
+  observeEvent(input$loadpca, {
+    req(input$pcainput)
+    file <- input$pcainput
+    if (!is.null(file)) {
+      # Reading and cleaning data
+      data_df <- read_data(file$datapath)
+      data_df <- clean_column_names(data_df)
+      # Setting the reactive value
+      datapca(data_df)
+      # Updating UI elements
+      updateSelectInput(session, "independentVarpca", choices = colnames(data_df))
+    }
+  })
+  
+  output$dataSummarypca <- renderPrint({
+    req(datapca())
+    summary(datapca())
+  }) 
+  
+  pca_reactive <- eventReactive(input$runpca, {
+    req(datapca(), input$independentVarpca)
+    if (length(input$independentVarpca) == 0) {
+      return(NULL)
+    }
+    data_pca <- datapca() %>%
+      dplyr::select(all_of(input$independentVarpca)) %>%
+      na.omit()
+    if (nrow(data_pca) < 10) {
+      return(NULL)
+    }
+    pca_model <- prcomp(data_pca, scale = TRUE)
+    pca_model_reactive(pca_model)
+    pca_model
+  })
+  
+  observeEvent(input$runpca, { 
+    req(pca_reactive())
+    output$runpca <- renderPrint({
+      pca_result <- pca_reactive()
+      
+      print(pca_result)
+      
+      # Print the summary of PCA results
+      pca_summary <- summary(pca_result)
+      print(pca_summary)
+      
+      # Interpretation for the users
+      cat("Principal Component Analysis (PCA) Summary:\n")
+      cat("The 'Proportion of Variance' indicates how much information (variance) is captured by each principal component.\n")
+      cat("The 'Cumulative Proportion' indicates the total variance captured by all the components up to that point.\n")
+      cat("\nFor example, if the first two principal components capture 70% of the variance, it means that these two components together represent most of the variability in the data.\n")
+      cat("This can be used to reduce the dimensionality of the data, by considering only the first few principal components that capture most of the variance.\n")
+      
+      # Holland's criteria for deciding how many PCs to retain
+      cat("\nHolland's Criteria for Retaining Principal Components:\n")
+      cat("1) Ignore components where the next PC offers little increase in total variance explained.\n")
+      cat("2) Include PCs up to a predetermined total percent variance explained, such as 90%.\n")
+      cat("3) Ignore components whose variance explained is less than 1 with a correlation matrix, or less than average variance explained with a covariance matrix.\n")
+      cat("4) Ignore the last PCs whose variance explained is all roughly equal.\n")
+      
+      # Holland's Criteria Implementation
+      cat("\nHolland's Criteria for Retaining Principal Components:\n")
+      
+      # Criterion 1: Ignore PCs with little increase in total variance explained
+      variance_increases <- diff(pca_summary$importance["Proportion of Variance", ])
+      significant_increase_index <- which(variance_increases > 0.01)  # Adjust the threshold as needed
+      if (length(significant_increase_index) > 0) {
+        cat("Criterion 1: Consider PCs up to index ", max(significant_increase_index), "\n")
+      }
+      
+      # Criterion 2: Total percent variance explained, such as 90%
+      cumulative_variance <- pca_summary$importance["Cumulative Proportion", ]
+      sufficient_variance_index <- which(cumulative_variance >= 0.9)[1]
+      if (!is.na(sufficient_variance_index)) {
+        cat("Criterion 2: Consider PCs up to index ", sufficient_variance_index, " to explain 90% of variance.\n")
+      }
+      
+      # Criterion 3: Ignore components with variance explained less than average
+      average_variance <- mean(pca_summary$importance["Proportion of Variance", ])
+      sufficient_variance_index <- which(pca_summary$importance["Proportion of Variance", ] >= average_variance)
+      if (length(sufficient_variance_index) > 0) {
+        cat("Criterion 3: Consider PCs with variance greater than the average ", round(average_variance, 2), "\n")
+      }
+      
+      # Criterion 4: Ignore last PCs with roughly equal variance explained
+      # Implementation can be subjective and depends on the context. Typically involves looking at a scree plot.
+      cat("Criterion 4: This part is subjective and depends on how you want to prioritize or combine the criteria.\n")
+      # Final recommendation based on Holland's Criteria
+      cat("\nFinal Recommendation based on Holland's Criteria:\n")
+      # Combine and interpret the criteria here. 
+      cat("Final: This part is subjective and depends on how you want to prioritize or combine the criteria.\n")
+    })
+  })
+  
+  
+  observeEvent(input$runpca, { 
+    req(datapca(), input$independentVarpca)
+    # Get the data
+    data_for_pca <- datapca()
+    
+    # Run PCA only on complete cases to avoid NAs
+    complete_data <- data_for_pca[complete.cases(data_for_pca[input$independentVarpca]), input$independentVarpca]
+    pca_result <- prcomp(complete_data, scale = TRUE)
+    
+    # Generate the biplot
+    output$biPlotpca <- renderPlotly({
+      fviz_pca_biplot(pca_result, label = "var",
+                      addEllipses=TRUE, ellipse.level=0.95,
+                      ggtheme = theme_minimal()) %>%
+        ggplotly() %>% layout(dragmode = "select")  # Enable selection mode in plotly
+    })
+  })
+  
+  
+  
+  
+  
+  ###K-Means Clustering
+  datakmc <- reactiveVal(NULL)
+  kmc_model_reactive <- reactiveVal()
+  # Load and clean data
+  observeEvent(input$loadkmc, {
+    req(input$kmcinput)
+    file <- input$kmcinput
+    if (!is.null(file)) {
+      # Reading and cleaning data
+      data_df <- read_data(file$datapath)
+      data_df <- clean_column_names(data_df)
+      
+      # Setting the reactive value
+      datakmc(data_df)
+      
+      # Updating UI elements
+      updateSelectInput(session, "targetkmc", choices = colnames(data_df))
+      updateSelectInput(session, "independentVarkmc", choices = colnames(data_df))
+    }
+  })
+  
+  
+  output$dataSummarykmc <- renderPrint({
+    req(datakmc())
+    summary(datakmc())
+  }) 
+  
+  observeEvent(input$runkmc, {
+    req(datakmc(), input$targetkmc, input$independentVarkmc)
+    
+    withProgress(message = 'Model is being trained...', value = 0, {
+      # Increment progress
+      incProgress(0.1)  # Initial progress
+      data_kmc <- datakmc() %>%
+        dplyr::select(input$targetkmc, input$independentVarkmc) %>%
+        na.omit()
+      
+      # Early return if conditions are not met
+      if (length(input$targetkmc) == 0) {
+        output$modelOutputkmc <- renderPrint({ "Please select the first variable." })
+        return()
+      }
+      
+      if (length(input$independentVarkmc) == 0) {
+        output$modelOutputkmc <- renderPrint({ "Please select the second variable." })
+        return()
+      }
+      
+      incProgress(0.3)  # Increment progress
+      if (nrow(data_kmc) < 10) {
+        output$modelOutputkmc <- renderPrint({ "Dataset is too small after removing NA values." })
+        return()
+      }
+      incProgress(0.6)  # Increment progress
+      # Partition the data
+      
+      
+      # Fit the Random Forest model
+      x <- data_kmc %>% dplyr::select(input$targetkmc, input$independentVarkmc)
+      z <- scale(x)
+      num_clusters <- input$numCenterskmc
+      kmc_model <- kmeans(z, num_clusters, nstart = 20)
+      kmc_model_reactive(kmc_model)
+      
+      # Augment data with cluster assignments
+      data_kmc$cluster <- kmc_model$cluster
+      
+      # Model summary
+      output$runkmc <- renderPrint({
+        print(kmc_model)
+        
+      })
+      
+      # Finalize progress
+      incProgress(1.0)  # Complete the progress
+    })
+  }) 
+  
+  output$clusteringPlotkmc <- renderPlotly({
+    req(kmc_model_reactive(), input$targetkmc, input$independentVarkmc)
+    
+    # Get the k-means model
+    kmc_model <- kmc_model_reactive()
+    
+    # Get the data and add cluster assignments
+    data_kmc <- datakmc() %>%
+      dplyr::select(input$targetkmc, input$independentVarkmc) %>%
+      na.omit()
+    
+    # Ensure the k-means model is valid
+    if (is.null(kmc_model)) {
+      print("K-means model is not available.")
+      return()
+    }
+    
+    # Prepare data for fviz_cluster
+    # fviz_cluster requires a kmeans object and data used for clustering
+    # Make sure data_kmc and kmc_model correspond to each other
+    fviz_cluster(kmc_model, data = data_kmc, stand = FALSE, geom = "point", 
+                 ellipse.type = "convex", 
+                 palette = "jco", 
+                 ggtheme = theme_minimal())
+  })
+  
+  output$silhouettePlotkmc <- renderPlotly({
+    req(kmc_model_reactive(), input$targetkmc, input$independentVarkmc)
+    
+    # Retrieve the k-means model
+    kmc_model <- kmc_model_reactive()
+    
+    # Retrieve the data
+    data_kmc <- datakmc() %>%
+      dplyr::select(input$targetkmc, input$independentVarkmc) %>%
+      na.omit()
+    
+    # Create the silhouette object
+    silhouette_info <- silhouette(kmc_model$cluster, dist(data_kmc))
+    
+    # Visualize the silhouette plot
+    fviz_silhouette(silhouette_info) + 
+      labs(title = "Silhouette Plot for K-Means Clustering")
+  })
+  
+  ###Hierarchical Clustering
+  datahc <- reactiveVal(NULL)
+  # Load and clean data
+  observeEvent(input$loadhc, {
+    req(input$hcinput)
+    file <- input$hcinput
+    if (!is.null(file)) {
+      # Reading and cleaning data
+      data_df <- read_data(file$datapath)
+      data_df <- clean_column_names(data_df)
+      
+      # Setting the reactive value
+      datahc(data_df)
+      
+      # Updating UI elements
+      updateSelectInput(session, "independentVarhc", choices = colnames(data_df))
+    }
+  })
+  
+  
+  output$dataSummaryhc <- renderPrint({
+    req(datahc())
+    summary(datahc())
+  })  
+  
+  # Create reactive expressions for each method that trigger only when the corresponding button is clicked
+  average_hc_reactive <- eventReactive(input$runavehc, {
+    req(datahc(), input$independentVarhc)
+    # Early return if conditions are not met
+    if (length(input$independentVarhc) == 0) {
+      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
+      return()
+    }
+    data_hc <- datahc() %>%
+      dplyr::select(input$independentVarhc) %>%
+      na.omit()
+    if (nrow(data_hc) < 10) {
+      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
+      return()
+    }
+    # Partition the data
+    hc_average <- hclust(dist(scale(data_hc)), method = "average")
+    return(hc_average)
+  })
+  
+  centroid_hc_reactive <- eventReactive(input$runcenhc, {  # Please make sure you have a separate button ID for centroid linkage
+    req(datahc(), input$independentVarhc)
+    # Early return if conditions are not met
+    if (length(input$independentVarhc) == 0) {
+      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
+      return()
+    }
+    data_hc <- datahc() %>%
+      dplyr::select(input$independentVarhc) %>%
+      na.omit()
+    if (nrow(data_hc) < 10) {
+      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
+      return()
+    }
+    hc_centroid <- hclust(dist(scale(data_hc)), method = "centroid")
+    return(hc_centroid)
+  })
+  
+  
+  #Average Dendogram
+  output$averageDendrogram <- renderPlotly({
+    hc_average <- average_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    hc_average <- hclust(dist(datahc()), method = "average")
+    # Directly cut the dendrogram
+    clusters <- cutree(hc_average, k = input$numCentershc)
+    # Plot the dendrogram
+    ggdendrogram(hc_average, rotate = FALSE) + 
+      labs(title = "Average Linkage with Scaled Features") +
+      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
+  })
+  
+  output$silhouettePlotHCave <- renderPlotly({
+    hc_average <- average_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    # Compute hierarchical clustering with average linkage
+    hc_average <- hclust(dist(datahc()), method = "average")
+    # Cut the dendrogram to create cluster assignments
+    clusters <- cutree(hc_average, k = input$numCentershc)
+    # Compute the silhouette information
+    silhouette_info <- silhouette(clusters, dist(datahc()))
+    # Visualize the silhouette plot
+    fviz_silhouette(silhouette_info) + 
+      labs(title = "Silhouette Plot for Hierarchical Clustering (Average Linkage)")
+  })
+  
+  #Centroid Dendogram
+  output$centroidDendrogram <- renderPlotly({
+    hc_centroid <- centroid_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    hc_centroid <- hclust(dist(datahc()), method = "centroid")
+    # Directly cut the dendrogram
+    clusters <- cutree(hc_centroid, k = input$numCentershc)
+    # Plot the dendrogram
+    ggdendrogram(hc_centroid, rotate = FALSE) + 
+      labs(title = "Centroid Linkage with Scaled Features") +
+      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
+  })
+  
+  output$silhouettePlotHCcen <- renderPlotly({
+    hc_centroid <- centroid_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    # Compute hierarchical clustering with centroid linkage
+    hc_centroid <- hclust(dist(datahc()), method = "centroid")
+    # Cut the dendrogram to create cluster assignments
+    clusters <- cutree(hc_centroid, k = input$numCentershc)
+    # Compute the silhouette information
+    silhouette_info <- silhouette(clusters, dist(datahc()))
+    # Visualize the silhouette plot
+    fviz_silhouette(silhouette_info) + 
+      labs(title = "Silhouette Plot for Hierarchical Clustering (Centroid Linkage)")
+  })
+  
+  #ward.D2  Dendogram
+  wardd2_hc_reactive <- eventReactive(input$runwddhc, {  # Please make sure you have a separate button ID for ward.D2 linkage
+    req(datahc(), input$independentVarhc)
+    # Early return if conditions are not met
+    if (length(input$independentVarhc) == 0) {
+      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
+      return()
+    }
+    data_hc <- datahc() %>%
+      dplyr::select(input$independentVarhc) %>%
+      na.omit()
+    if (nrow(data_hc) < 10) {
+      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
+      return()
+    }
+    hc_wardd2 <- hclust(dist(scale(data_hc)), method = "ward.D2")
+    return(hc_wardd2)
+  })
+  
+  
+  output$wdd2Dendrogram <- renderPlotly({
+    hc_wardd2 <- wardd2_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    hc_wardd2 <- hclust(dist(datahc()), method = "ward.D2")
+    # Directly cut the dendrogram
+    clusters <- cutree(hc_wardd2, k = input$numCentershc)
+    # Plot the dendrogram
+    ggdendrogram(hc_wardd2, rotate = FALSE) + 
+      labs(title = "Ward D2 Linkage with Scaled Features") +
+      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
+  })
+  
+  output$silhouettePlotHCwdd2 <- renderPlotly({
+    hc_wardd2 <- wardd2_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    # Compute hierarchical clustering with ward.D2 linkage
+    hc_wardd2 <- hclust(dist(datahc()), method = "ward.D2")
+    # Cut the dendrogram to create cluster assignments
+    clusters <- cutree(hc_wardd2, k = input$numCentershc)
+    # Compute the silhouette information
+    silhouette_info <- silhouette(clusters, dist(datahc()))
+    # Visualize the silhouette plot
+    fviz_silhouette(silhouette_info) + 
+      labs(title = "Silhouette Plot for Hierarchical Clustering (Ward D2 Linkage)")
+  })
+  
+  #WPGMA  Dendogram
+  mcqu_hc_reactive <- eventReactive(input$runmchc, {  # Please make sure you have a separate button ID for mcquitty linkage
+    req(datahc(), input$independentVarhc)
+    # Early return if conditions are not met
+    if (length(input$independentVarhc) == 0) {
+      output$modelOutputhc <- renderPrint({ "Please select the second variable." })
+      return()
+    }
+    data_hc <- datahc() %>%
+      dplyr::select(input$independentVarhc) %>%
+      na.omit()
+    if (nrow(data_hc) < 10) {
+      output$modelOutputhc <- renderPrint({ "Dataset is too small after removing NA values." })
+      return()
+    }
+    hc_mcqu <- hclust(dist(scale(data_hc)), method = "mcquitty")
+    return(hc_mcqu)
+  })
+  
+  
+  output$mcquDendrogram <- renderPlotly({
+    hc_mcqu <- mcqu_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    hc_mcqu <- hclust(dist(datahc()), method = "mcquitty")
+    # Directly cut the dendrogram
+    clusters <- cutree(hc_mcqu, k = input$numCentershc)
+    # Plot the dendrogram
+    ggdendrogram(hc_mcqu, rotate = FALSE) + 
+      labs(title = "Mcquity Linkage with Scaled Features") +
+      geom_hline(yintercept = which.max(table(clusters)), linetype = "dashed")
+  })
+  
+  output$silhouettePlotHCmc <- renderPlotly({
+    hc_mcqu <- mcqu_hc_reactive()
+    req(datahc(), input$numCentershc)  # Ensure the scaled data and number of clusters are available
+    # Compute hierarchical clustering with mcquitty linkage
+    hc_mcqu <- hclust(dist(datahc()), method = "mcquitty")
+    # Cut the dendrogram to create cluster assignments
+    clusters <- cutree(hc_mcqu, k = input$numCentershc)
+    # Compute the silhouette information
+    silhouette_info <- silhouette(clusters, dist(datahc()))
+    # Visualize the silhouette plot
+    fviz_silhouette(silhouette_info) + 
+      labs(title = "Silhouette Plot for Hierarchical Clustering (Mcquity Linkage)")
+  })
+  
+  ###Density-based spatial clustering of applications - DBSCAN
+  datadbscan <- reactiveVal(NULL)
+  dbscan_model_reactive <- reactiveVal()
+  # Load and clean data
+  observeEvent(input$loaddbscan, {
+    req(input$dbscaninput)
+    file <- input$dbscaninput
+    if (!is.null(file)) {
+      # Reading and cleaning data
+      data_df <- read_data(file$datapath)
+      data_df <- clean_column_names(data_df)
+      
+      # Setting the reactive value
+      datadbscan(data_df)
+      
+      # Updating UI elements
+      updateSelectInput(session, "independentVardbscan", choices = colnames(data_df))
+    }
+  })
+  
+  
+  output$dataSummarydbscan <- renderPrint({
+    req(datadbscan())
+    summary(datadbscan())
+  }) 
+  
+  #kNN Neighboring
+  kNN_dbscan_reactive <- eventReactive(input$rundbscandist, {  # Please make sure you have a separate button ID for mcquitty linkage
+    req(datadbscan(), input$independentVardbscan)
+    # Early return if conditions are not met
+    if (length(input$independentVardbscan) == 0) {
+      output$modelOutputdbscan <- renderPrint({ "Please select the second variable." })
+      return()
+    }
+    data_dbscan <- datadbscan() %>%
+      dplyr::select(input$independentVardbscan) %>%
+      na.omit()
+    if (nrow(data_dbscan) < 10) {
+      output$modelOutputdbscan <- renderPrint({ "Dataset is too small after removing NA values." })
+      return()
+    }
+    dbscan_model <- scale(data_dbscan)
+    return(dbscan_model)
+  })
+  
+  output$rundbscandist <- renderPlot({
+    dbscan_model <- kNN_dbscan_reactive()
+    req(dbscan_model)
+    
+    # Assuming dbscan_model is scaled appropriately
+    dists <- kNNdist(dbscan_model, k = 10)
+    plot(dists, type='l', main="kNN distance")
+    abline(h = 0.5, col = 'red', lty = 2)  # Example line, adjust based on elbow
+    
+    # Heuristic to find the elbow point
+    diff_dists <- diff(dists)
+    optimal_eps <- which.max(diff_dists)
+    
+    # Add a vertical line at the optimal eps value
+    abline(v = optimal_eps, col = 'blue', lwd = 2)
+    
+    # Annotate the optimal eps value on the plot
+    text(x = optimal_eps, y = dists[optimal_eps], labels = paste("Eps:", round(dists[optimal_eps], 2)), pos = 4, col = 'blue')
+  })
+  
+  
+  observeEvent(input$rundbscan, {
+    req(datadbscan(), input$independentVardbscan)
+    
+    withProgress(message = 'Model is being trained...', value = 0, {
+      incProgress(0.1)
+      data_dbscan <- datadbscan() %>%
+        dplyr::select(input$independentVardbscan) %>%
+        na.omit()
+      
+      # Check for variable selection and data size
+      if (length(input$independentVardbscan) == 0 || nrow(data_dbscan) < 10) {
+        output$modelOutputdbscan <- renderPrint({ "Please check your variable selection and ensure the dataset is not too small." })
+        incProgress(1.0)
+        return()
+      }
+      incProgress(0.3)
+      # Fit the DBSCAN model
+      dbscan_model <- dbscan(data_dbscan, eps = input$numepsdbscan)
+      
+      # Combine data with cluster labels
+      clustering_results <- cbind(data_dbscan, cluster = dbscan_model$cluster)
+      incProgress(0.7)
+      # Save the clustering results in a reactive value
+      dbscan_model_reactive(clustering_results)
+      
+      # Model summary
+      output$rundbscan <- renderPrint({ print(dbscan_model) })
+      
+      incProgress(1.0)
+    })
+  })
+  
+  
+  # Use the clustering results for plotting
+  output$clusteringPlotdbscan <- renderPlotly({
+    clustering_results <- dbscan_model_reactive()
+    
+    if (is.null(clustering_results) || nrow(clustering_results) == 0) {
+      print("No data available for plotting.")
+      return()
+    }
+    
+    selected_columns <- input$independentVardbscan
+    
+    if (!"cluster" %in% names(clustering_results) || any(is.na(clustering_results$cluster))) {
+      print("Cluster assignments are missing or contain NA values.")
+      return()
+    }
+    
+    data_for_plot <- clustering_results[, selected_columns]
+    
+    # Create a pseudo clustering object for fviz_cluster
+    pseudo_cluster_obj <- list(
+      data = data_for_plot,
+      cluster = clustering_results$cluster
+    )
+    
+    # Visualization using fviz_cluster
+    fviz_cluster(pseudo_cluster_obj, geom = "point", stand = FALSE)
+    
+  })
+  
+  output$silhouettePlotdbscan <- renderPlotly({
+    clustering_results <- dbscan_model_reactive()
+    
+    if (is.null(clustering_results) || nrow(clustering_results) == 0) {
+      print("No data available for silhouette analysis.")
+      return()
+    }
+    
+    selected_columns <- input$independentVardbscan
+    
+    if (!"cluster" %in% names(clustering_results) || any(is.na(clustering_results$cluster))) {
+      print("Cluster assignments are missing or contain NA values.")
+      return()
+    }
+    
+    data_for_plot <- clustering_results[, selected_columns]
+    clusters <- clustering_results$cluster
+    
+    # Compute distance matrix if not already computed
+    dist_matrix <- dist(data_for_plot)
+    
+    # Compute silhouette values
+    sil_values <- silhouette(clusters, dist_matrix)
+    
+    # Visualization using fviz_silhouette
+    fviz_silhouette(sil_values)
+  })
+  
+  ###Associated Rule Learning
+  dataarl <- reactiveVal(NULL)  # Will hold the transactions object
+  buttonClicked <- reactiveVal(FALSE)
+  # Reactive value for storing the raw data
+  rawData <- reactiveVal(NULL)
+  
+  observeEvent(input$loadarl, {
+    req(input$arlinput)
+    # After reading the file
+    if (tools::file_ext(input$arlinput$datapath) == "csv") {
+      df <- read.csv(input$arlinput$datapath, stringsAsFactors = FALSE)
+    } else if (tools::file_ext(input$arlinput$datapath) == "xlsx") {
+      df <- readxl::read_excel(input$arlinput$datapath)
+    }
+    # Make sure df is a data frame and then store it
+    rawData(df)  # Assuming rawData is meant to store the raw data frame
+    
+    # Update UI for column selection
+    updateSelectInput(session, "targetarl", "Select ID Column", choices = colnames(df))
+    updateSelectInput(session, "itemsColumn", "Select Transaction Column", choices = colnames(df))
+    
+    buttonClicked(FALSE)  # Reset the button click status
+  })
+  
+  # Create a separate event for when the user confirms the column selection and clicks another action button to run ARL
+  observeEvent(input$runarl, {
+    req(rawData(), input$targetarl, input$itemsColumn)
+    print(str(dataarl()))  # Debug: Check the structure of dataarl()
+    df <- rawData()
+    # Directly read the uploaded file again for this action, for debugging
+    if (tools::file_ext(input$arlinput$datapath) == "csv") {
+      df <- read.csv(input$arlinput$datapath, stringsAsFactors = FALSE)
+    } else if (tools::file_ext(input$arlinput$datapath) == "xlsx") {
+      df <- readxl::read_excel(input$arlinput$datapath)
+    } else {
+      stop("Unsupported file type")
+    }
+    
+    # Now df is guaranteed to be a data frame here
+    selected_data <- df %>%
+      dplyr::select(dplyr::all_of(input$targetarl), dplyr::all_of(input$itemsColumn)) %>%
+      dplyr::arrange(dplyr::all_of(input$targetarl))
+    
+    # Assuming each row is a transaction with a single item
+    # Create a unique identifier for each transaction
+    selected_data <- selected_data %>%
+      group_by(!!sym(input$targetarl)) %>%
+      summarise(Items = paste(!!sym(input$itemsColumn), collapse = ", ")) %>%
+      ungroup()
+    
+    # Write the preprocessed data to a temporary file for read.transactions
+    temp_file <- tempfile(fileext = ".csv")
+    write.table(selected_data, temp_file, row.names = FALSE, quote = FALSE, sep = ",")
+    
+    # Now read the transactions from the temporary file
+    trans <- read.transactions(temp_file, format = "basket", sep = ",", rm.duplicates = TRUE)
+    
+    # Update the reactive value holding the transactions
+    dataarl(trans)
+    
+    buttonClicked(TRUE)
+    # Cleanup: Remove the temporary file
+    unlink(temp_file)
+  })
+  
+  
+  # Assuming 'data' is your data frame and 'itemDescription' is your items column
+  preprocess_data <- function(data, itemsColumn) {
+    req(rawData(), dataarl(), input$targetarl, input$itemsColumn)
+    df <- rawData()
+    # Ensure the column is a character to avoid issues with factors
+    data[[itemsColumn]] <- as.character(data[[itemsColumn]])
+    
+    # Remove unwanted characters such as new line characters and extra spaces
+    data[[itemsColumn]] <- gsub("\n", "", data[[itemsColumn]])
+    data[[itemsColumn]] <- gsub("\"", "", data[[itemsColumn]])
+    data[[itemsColumn]] <- trimws(data[[itemsColumn]]) # Trim white spaces
+    
+    return(data)
+  }
+  
+  # Render Item Frequency Plot
+  createItemFreqPlot <- function(transactions, topN = 35) {
+    freq <- itemFrequency(transactions, type = "absolute")
+    freq_df <- data.frame(items = names(freq), frequency = freq)
+    
+    freq_df <- freq_df[order(-freq_df$frequency), ][1:topN, ]
+    
+    # Generate a palette with as many colors as bars
+    colors <- scales::hue_pal()(topN)
+    
+    ggplot(freq_df, aes(x = reorder(items, -frequency), y = frequency, fill = items)) +
+      geom_bar(stat = "identity") +
+      scale_fill_manual(values = colors) +
+      xlab("Items") +
+      ylab("Frequency") +
+      coord_flip() +
+      theme(legend.position = "none")  # Optionally hide the legend
+  }
+  
+  
+  # Use preprocess_data in the eventReactive for plotData
+  plotData <- eventReactive(input$runarl, {
+    buttonClicked(TRUE)  # Set to true when button is clicked
+    req(rawData(), dataarl(), input$targetarl, input$itemsColumn)
+    df <- rawData()
+    
+    # Debug: Print the structure of the data
+    print(str(dataarl()))
+    cleaned_data <- preprocess_data(df, input$itemsColumn)
+    
+    # Assuming that items are separated by a comma, adjust if necessary
+    items_list <- strsplit(as.character(cleaned_data[[input$itemsColumn]]), split = ",")
+    
+    # Convert the list of items into transactions
+    transactions <- as(items_list, "transactions")
+    
+    # Create the item frequency plot
+    createItemFreqPlot(transactions, topN = 20)
+  }, ignoreNULL = FALSE)
+  
+  
+  # Render plot using Plotly
+  output$itemFreqPlot <- renderPlotly({
+    req(buttonClicked(), plotData())  # Check if button has been clicked
+    ggplotly(plotData())
+  })
+  
+  #Appriori Function
+  arl_model_reactive <- eventReactive(input$runarl, {
+    req(rawData(), input$targetarl, input$itemsColumn)
+    df <- rawData()
+    
+    # Preprocess and clean the data
+    cleaned_data <- preprocess_data(df, input$itemsColumn)
+    
+    # Aggregate items by transaction ID into a single string per transaction
+    aggregated_data <- cleaned_data %>%
+      group_by(!!sym(input$targetarl)) %>%
+      summarise(Items = paste(!!sym(input$itemsColumn), collapse = ", ")) %>%
+      ungroup()
+    
+    # Convert the aggregated item strings into a list of transactions
+    transactions_list <- split(aggregated_data$Items, aggregated_data[[input$targetarl]])
+    transactions_list <- lapply(transactions_list, function(items) {
+      unlist(strsplit(items, ",\\s*"))
+    })
+    
+    # Create a transactions object
+    transactions <- arules::transactions(transactions_list)
+    
+    # Run the Apriori algorithm
+    arl_rules <- apriori(transactions, parameter = list(supp = 0.001, conf = 0.37))
+    
+    # Return the rules so they're stored in arl_model_reactive
+    return(arl_rules)
+  }, ignoreNULL = FALSE)
+  
+  # Reactive expression for sorted rules
+  sorted_rules_reactive <- reactive({
+    # Make sure to call arl_model_reactive() to get its value
+    req(arl_model_reactive())
+    
+    # Sort the rules by lift
+    sorted_rules <- sort(arl_model_reactive(), by = "lift")
+    
+    # Return the sorted rules so they can be used in the output
+    return(sorted_rules)
+  })
+  
+  # Render the sorted rules
+  output$sortedARLOutput <- renderPrint({
+    req(sorted_rules_reactive())
+    
+    # Use inspect to print the sorted rules
+    inspect(sorted_rules_reactive())
+  })
+
+}
+
+shinyApp(ui, server)