conda & miniconda added. Vars removed

Dockerfile

@@ -15,25 +15,25 @@ FROM rocker/ml:4.2
 SHELL [ "/bin/bash", "--login", "-c" ]
 
 ###############
-# Ensure vars #
+# Ensure vars # (Only for local test - DON'T USE IT IN HUGGINGFACE. ENSURE .env IS NOT ACCESIBLE IN THE WEB, USE THEIR SECRET MANAGEMENT)
 ###############
-ARG USER_NAME
-ARG USER_ID
-ARG GROUP_ID
-ARG WANDB_API_KEY
-ARG WANDB_ENTITY
-ARG WANDB_PROJECT
-ARG GH_TOKEN
-
-
-ENV USER_NAME=$USER_NAME
-ENV USER_ID=$USER_ID
-ENV GROUP_ID=$GROUP_ID
-ENV WANDB_ENTITY=$WANDB_ENTITY
-ENV WANDB_API_KEY=$WANDB_API_KEY
+#ARG USER_NAME
+#ARG USER_ID
+#ARG GROUP_ID
+#ARG WANDB_API_KEY
+#ARG WANDB_ENTITY
+#ARG WANDB_PROJECT
+#ARG GH_TOKEN
+
+
+#ENV USER_NAME=$USER_NAME
+#ENV USER_ID=$USER_ID
+#ENV GROUP_ID=$GROUP_ID
+#ENV WANDB_ENTITY=$WANDB_ENTITY
+#ENV WANDB_API_KEY=$WANDB_API_KEY
 ENV RETICULATE_PYTHON_ENV=/home/${USER_NAME}/env
 ENV RETICULATE_MINICONDA_PATH=/home/${USER_NAME}/miniconda
-ENV WANDB_PROJECT=$WANDB_PROJECT
+#ENV WANDB_PROJECT=$WANDB_PROJECT
 ENV ROOT=TRUE
 ENV CUDA_VISIBLE_DEVICES=0,1,2
 ENV GH_TOKEN=$ghtoken
@@ -51,10 +51,6 @@ RUN echo ${USER_NAME}"|"${USER_ID}"|"${GROUP_ID}
 COPY --chown=${USER_ID}:${GROUP_ID} ../r_shiny_app /$HOME/app
 COPY --chown=${USER_ID}:${GROUP_ID} ${LOCAL_DATA_PATH} /$HOME/data/
 COPY --chown=${USER_ID}:${GROUP_ID} ../dvats ${HOME}/dvats
-COPY --chown=${USER_ID}:${GROUP_ID} ../lib /${HOME}/lib
-
-
-
 
 RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys A4B469963BF863CC 
 RUN apt-get update
@@ -101,7 +97,64 @@ ARG WANDB_API_KEY
 RUN echo "WANDB_API_KEY=${WANDB_API_KEY}" >> /${HOME}/.Renviron
 
 
-RUN echo "--> rewruie miniconda path"
+ENV MINICONDA_VERSION=4.10.3 \ 
+#ENV MINICONDA_VERSION=23.9.0 \ 
+    CONDA_DIR=$HOME/miniconda3 \
+    # Make non-activate conda commands available
+    PATH=$CONDA_DIR/bin:$PATH \
+    PROJECT_DIR=$HOME 
+
+RUN echo "HOME: ${HOME} | CONDA_DIR = ${CONDA_DIR}" \
+    #-- Install MINICONDA
+    && wget --quiet https://repo.anaconda.com/miniconda/Miniconda3-py38_$MINICONDA_VERSION-Linux-x86_64.sh -O ~/miniconda.sh  \
+    && chmod +x ~/miniconda.sh  \
+    && ~/miniconda.sh -b -p $CONDA_DIR  \
+    && rm ~/miniconda.sh 
+
+    # Make conda activate command available from /bin/bash --login shells
+RUN echo ". $CONDA_DIR/etc/profile.d/conda.sh" >> ~/.profile 
+    # make conda activate command available from /bin/bash --interative shells
+RUN  conda init bash \
+    # create a project directory inside user home
+    && mkdir -p $PROJECT_DIR
+
+WORKDIR $PROJECT_DIR
+##########################
+# Install & update MAMBA #
+########################## 
+ENV ENV_PREFIX $PROJECT_DIR/env
+RUN conda install --name base --channel conda-forge mamba \
+    && mamba update --name base --channel defaults conda 
+#-- Build the mamba environment
+RUN mamba install conda-lock -c conda-forge
+COPY --chown=$UID:$GID docker/environment.yml docker/requirements.txt /tmp/
+#RUN mamba lock -f /tmp/environment.yml --lockfile /tmp/environment.lock
+#RUN mamba create --prefix ${ENV_PREFIX} --file /tmp/environment.lock
+RUN mamba env create --prefix ${ENV_PREFIX} --file /tmp/environment.yml
+RUN conda clean --all --yes
+
+# run the postBuild script to install the JupyterLab extensions
+COPY --chown=$UID:$GID docker/postBuild /usr/local/bin
+RUN chmod u+x /usr/local/bin/postBuild \
+    && conda activate $ENV_PREFIX  \
+    && /usr/local/bin/postBuild  \
+    && conda deactivate \
+    # Make bash automatically activate the conda environment
+    && echo "conda activate $ENV_PREFIX" >> ~/.bashrc
+RUN chmod u+x /usr/local/bin/postBuild \
+    && conda activate $ENV_PREFIX  \
+    && /usr/local/bin/postBuild  \
+    && conda deactivate \
+    # Make bash automatically activate the conda environment
+    && echo "conda activate $ENV_PREFIX" >> ~/.bashrc
+
+RUN conda list --prefix ${ENV_PREFIX}
+
+
+
+
+
+RUN echo "--> rewrrite miniconda path"
 # Rewrite the miniconda path environment in case it has been redefined in the compose file
 RUN echo "RETICULATE_MINICONDA_PATH=${RETICULATE_MINICONDA_PATH}" >> ${HOME}/.Renviron
 
@@ -112,7 +165,7 @@ RUN echo "--> Permissions"
 
 RUN echo "$(id )"
 
-RUN echo "--> Setup miniconda3"
+RUN echo "--> Setup miniconda & Mamba"
 
 RUN echo ". ${HOME}miniconda3/etc/profile.d/conda.sh" >> ${HOME}/rstudio/.bashrc
 

docker/environment.yml

@@ -0,0 +1,72 @@
+name: dvats_env
+channels:
+  #--- Torch & Cuda
+  - pytorch
+  #- nvidia/label/cuda-12.2.0
+  - nvidia
+  #--- Generic
+  - conda-forge
+  - defaults
+  #--- AI
+  - fastai
+  - rapidsai
+  - defaults  
+  - conda-forge
+
+  - timeseriesai
+dependencies:
+  ##########################
+  # Generic configurations #
+  ##########################
+  - nano=7.2=h8228510_0
+  - git=2.42.0=pl5321h86e50cf_0
+  #--- github
+  - gh=2.37.0=ha8f183a_0
+  #--- Python
+  - python=3.10.13=hd12c33a_0_cpython
+  #WANDB <= 0.15.12 needs this version. See https://github.com/wandb/wandb/issues/6546
+  - ipython=8.16.1=pyh0d859eb_0
+  - pip=23.3.1=pyhd8ed1ab_0
+  - conda-forge::twine=4.0.2=pyhd8ed1ab_0
+  - conda-forge::xeus-python=0.15.10=py310hd41b1e2_1
+  #--- NodeJS
+  - conda-forge::nodejs=20.8.1=h1990674_0
+  #---Jupyter
+  - conda-forge::ipywidgets=8.1.1=pyhd8ed1ab_0
+  - conda-forge::jupyterlab=4.0.7=pyhd8ed1ab_0
+  - conda-forge::jupyterlab-git=0.41.0=pyhd8ed1ab_1
+  - conda-forge::nbclassic=1.0.0=pyhb4ecaf3_1
+  - conda-forge::nbdev=2.2.10=pyhd8ed1ab_0
+  - nbformat>=5.1.3
+  #--- passwords & files
+  - keyrings.alt
+  - platformdirs=2.5.2
+  - conda-forge::keyrings.alt=4.2.0=pyhd8ed1ab_0
+  - psutil>=5.4.8 
+  ##############
+  # CUDA & GPU #
+  ##############
+  - nvidia::cuda-toolkit=11.6=0
+  - rapidsai::cudf=23.02=cuda_11_py310_g5ad4a85b9d_0
+  - rapidsai::cuml=23.02=cuda11_py310_g3356f05bd_0
+  - conda-forge::genv=1.2.0=pyhd8ed1ab_0
+  ############
+  # Specific #
+  ############
+  #--- Torch
+  - pytorch=1.13=py3.10_cuda11.7_cudnn8.5.0_0
+  #---Graphs & imgs
+  - conda-forge::plotly=5.18.0=pyhd8ed1ab_0
+  - conda-forge::jpeg=9e=h166bdaf_2
+  - conda-forge::seaborn=0.13.0=hd8ed1ab_0
+  - conda-forge::matplotlib=3.8.1=py310hff52083_0
+  #--- IA
+  - conda-forge::hdbscan=0.8.33=py310h1f7b6fc_4
+  - conda-forge::imbalanced-learn>= 0.8.0
+  - conda-forge::pyts >= 0.12.0
+  - conda-forge::umap-learn=0.5.4=py310hff52083_0
+  - conda-forge::scikit-learn=1.2.2=py310hf7d194e_2
+  - conda-forge::wandb=0.14.2=pyhd8ed1ab_0
+  - fastai::fastai>=2.7.9
+  - timeseriesai::tsai
+  - conda-forge::feather-format

docker/postBuild

@@ -0,0 +1 @@
+#jupyter lab build --dev-build=False --minimize=False

r_shiny_app/global.R

@@ -0,0 +1,160 @@
+# R dependencies
+library(shiny)
+library(shinyjs)
+library(reticulate)
+library(purrr)
+library(jsonlite)
+library(tibble)
+library(ggplot2)
+library(glue)
+library(shinycssloaders)
+library(tidyr)
+library(data.table)
+library(dplyr)
+library(dygraphs)
+library(shinyWidgets)
+library(RColorBrewer)
+library(pals)
+library(stringr)
+##################QUITAR CUANDO YA TIRE
+library(reactlog)
+library(feather)
+library(arrow)
+library(fasttime)
+library(parallel)
+#library(shinythemes)
+library(xts)
+
+reactlog::reactlog_enable()
+#options(shiny.trace = TRUE, shiny.loglevel = "DEBUG", shiny.app_log_path = "app/shiny_logs_internal")
+
+torch <- reticulate::import("torch")
+#options(shiny.trace = TRUE)
+if(torch$cuda$is_available()){
+  print(paste0("CUDA AVAILABLE. Num devices: ", torch$cuda$device_count()))
+  torch$cuda$set_device(as.integer(1))
+  #torch$cuda$set_device(as.integer(1))
+  #torch$cuda$set_device(as.integer(2))
+  #print(torch$cuda$memory_summary())
+  print(Sys.getenv("PYTORCH_CUDA_ALLOC_CONF"))
+} else {
+  print("CUDA NOT AVAILABLE")
+}
+#################QUITAR CUANDO YA TIRE
+
+# Python dependencies
+#tsai_data = import("tsai.data.all")
+#wandb = import("wandb")
+#pd = import("pandas")
+#hdbscan = import("hdbscan")
+#dvats = import_from_path("dvats.all", path=paste0(Sys.getenv("HOME")))
+############Just in case. Trying to get why get_enc_embs gets freezed
+# Python dependencies
+tsai_data = reticulate::import("tsai.data.all")
+wandb = reticulate::import("wandb")
+pd = reticulate::import("pandas")
+hdbscan = reticulate::import("hdbscan")
+dvats = reticulate::import_from_path("dvats.all", path=paste0(Sys.getenv("HOME")))
+
+
+print("--> py_config ")
+print(reticulate::py_config())
+print("py_config -->")
+
+#############
+# CONFIG #
+#############
+
+QUERY_RUNS_LIMIT = 1
+DEFAULT_PATH_WANDB_ARTIFACTS = paste0(Sys.getenv("HOME"), "/data/wandb_artifacts")
+hdbscan_metrics <- hdbscan$dist_metrics$METRIC_MAPPING
+#hdbscan_metrics <- c('euclidean', 'l2', 'l1', 'manhattan', 'cityblock', 'braycurtis', 'canberra', 'chebyshev', 'correlation', 'cosine', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule', 'wminkowski', 'nan_euclidean', 'haversine')
+Sys.setenv("TZ"="UTC")
+DEFAULT_VALUES = list(metric_hdbscan = "euclidean",
+                      min_cluster_size_hdbscan = 100,
+                      min_samples_hdbscan = 15,
+                      cluster_selection_epsilon_hdbscan = 0.08,
+                      path_line_size = 0.08,
+                      path_alpha = 5/10,
+                      point_alpha = 1/10,
+                      point_size = 1)
+WANDB_ENTITY = Sys.getenv("WANDB_ENTITY")
+WANDB_PROJECT = Sys.getenv("WANDB_PROJECT")
+
+
+####################
+# HELPER FUNCTIONS #
+####################
+
+get_window_indices = function(idxs, w, s) {
+  idxs %>% map(function (i) {
+    start_index = ((i-1)*s + 1)
+    return(start_index:(start_index+w-1))
+  })
+}
+
+dyUnzoom <-function(dygraph) {
+  dyPlugin(
+    dygraph = dygraph,
+    name = "Unzoom",
+    path = system.file("plugins/unzoom.js", package = "dygraphs")
+  )
+}
+
+vec_dyShading <- function(dyg, from, to, color, data_rownames) {
+  
+  # assuming that from, to, and color have all same length
+  n <- length(from)
+  if (n == 0) return(dyg)
+  
+  new_shades <- vector(mode = "list", length = n)
+  for (i in 1:n) {
+    new_shades[[i]] <- list(from = data_rownames[from[[i]]],
+                            to = data_rownames[to[[i]]],
+                            color = color,
+                            axis = "x")
+  }
+  dyg$x$shadings <- c(dyg$x$shadings, new_shades)
+  dyg
+}
+
+# Not used yet (it is likely to be used in the future)
+make_individual_dygraph <- function(i){
+  plt <- dygraph(tsdf()[i],height= "170",group = "timeseries", ylab = names(tsdf())[i],width="100%") %>%
+    dySeries(color=color_scale_dygraph[i]) %>%
+    dyHighlight(hideOnMouseOut = TRUE) %>%
+    dyOptions(labelsUTC = TRUE) %>%
+    dyLegend(show = "follow", hideOnMouseOut = TRUE) %>%
+    dyUnzoom() %>%
+    dyHighlight(highlightSeriesOpts = list(strokeWidth = 3)) %>%
+    dyCSS(
+      textConnection(
+        "
+                        .dygraph-ylabel {font-size: 9px; width: 80%;text-align: center;float: right} 
+                        .dygraph-legend > span { display: none; }
+                        .dygraph-legend > span.highlight { display: inline; }"
+      )
+    )
+  if(i==1){
+    plt <-plt %>%
+      dyRangeSelector(height = 20, strokeColor = "")
+  }
+  plt
+}
+
+
+##############################################
+# RETRIEVE WANDB RUNS & ARTIFACTS #
+##############################################
+
+api <- wandb$Api()
+
+print("Querying encoders")
+encs_l <- dvats$get_wandb_artifacts(project_path = glue(WANDB_ENTITY, "/", WANDB_PROJECT), 
+                                    type = "learner", 
+                                    last_version=F) %>% 
+  discard(~ is_empty(.$aliases) | is_empty(.$metadata$train_artifact))
+encs_l <- encs_l %>% set_names(encs_l %>% map(~ glue(WANDB_ENTITY, "/", WANDB_PROJECT, "/", .$name)))
+  #discard(~ str_detect(.$name, "dcae"))
+
+print("Done!")

r_shiny_app/server-helper.R

@@ -0,0 +1,60 @@
+# Function for parallel timeindex conversion
+parallel_posfix <- function(df) {
+    chunk_size = 100000
+    num_chunks = ceiling(nrow(df)/chunk_size)
+    chunks=split(df$timeindex, ceiling(seq_along(df$timeindex)/chunk_size))
+            
+    print(paste0("Parallel posfix | Chunks: ", num_chunks))
+    cl = parallel::makeCluster(4)
+    parallel::clusterEvalQ(cl, library(fasttime))
+            
+    print(paste0("Parallel posfix | Cluster ", cl, " of ", detectCores()))
+    flush.console()
+    
+    result <- parallel::clusterApply(cl, chunks, function(chunk) {
+        cat("Processing chunk\n")
+        flush.console()
+        #fasttime::fastPOSIXct(chunk, format = "%Y-%m-%d %H:%M:%S")
+        as.POSIXct(chunk)
+    })
+    stopCluster(cl)
+    print(" Reactive tsdf | Make conversion -->")
+    print(" Reactive tsdf | Make conversion ")
+    flush.console()
+    return(unlist(result))
+}
+
+# Get next index for the projection plot
+set_plot_id <- function(prj_plot_id)({
+    prj_plot_id(prj_plot_id()+1)
+})
+
+# Get projection plot name
+get_prjs_plot_name <- function(dataset_name, encoder_name, selected, cluster, prj_plot_id, input){
+    set_plot_id()
+    plt_name <- paste0(
+        execution_id, "_",
+        prj_plot_id(), "_",
+        dataset_name, "_", 
+        encoder_name, "_", 
+        input$cpu_flag, "_", 
+        input$dr_method, "_",  
+        input$clustering_options, "_", 
+        "zoom", "_", 
+        input$zoom_btn, "_", 
+        "point_alpha_",
+        input$point_alpha, "_",
+        "show_lines_",
+        input$show_lines, "_",
+        "prjs.png"
+    )
+    print(paste0("embeddings plot name", plt_name))
+    plt_name
+}
+
+get_ts_plot_name <- function(dataset_name, encoder_name, prj_plot_id, input){
+    print("Getting timeserie plot name")
+    plt_name <- paste0(dataset_name,  "_", encoder_name, input$dr_method, "_ts.html")
+    print(paste0("ts plot name: ", plt_name))
+    plt_name
+}

r_shiny_app/server.R

@@ -0,0 +1,1087 @@
+#
+# This is the server logic of a Shiny web application. You can run the
+# application by clicking 'Run App' above.
+#
+# Find out more about building applications with Shiny here:
+#
+#    http://shiny.rstudio.com/
+#
+###########3 devtools::install_github("apache/arrow/r", ref = "tags/apache-arrow-14.0.0", subdir = "arrow/r")
+
+
+source("./server-helper.R")
+
+shinyServer(function(input, output, session) {
+    options(shiny.verbose = TRUE)
+    #options(shiny.error = function() {
+    #    traceback()
+    #    stopApp()
+    #})
+  
+    ######################
+    #  REACTIVES VALUES  #
+    ######################
+    
+    # Reactive values created to update the current range of the main slider input
+    #slider_range <- reactiveValues(min_value = 1, max_value = 2)
+    
+    # Reactive value created to keep updated the selected precomputed clusters_labels artifact
+    precomputed_clusters <- reactiveValues(selected = NULL)
+    
+    
+    # Reactive value created to keep updated the selected clustering option
+    clustering_options <- reactiveValues(selected = "no_clusters")
+    
+    
+    # Reactive value created to configure the graph brush
+    ranges <- reactiveValues(x = NULL, y = NULL)
+    
+    
+    # Reactive value created to configure clusters options
+    clusters_config <- reactiveValues(
+        metric_hdbscan = DEFAULT_VALUES$metric_hdbscan,
+        min_cluster_size_hdbscan = DEFAULT_VALUES$min_cluster_size_hdbscan,
+        min_samples_hdbscan = DEFAULT_VALUES$min_samples_hdbscan,
+        cluster_selection_epsilon_hdbscan = DEFAULT_VALUES$cluster_selection_epsilon_hdbscan
+    )
+    
+    # Reactive values created to configure the appearance of the projections graph.
+    config_style <- reactiveValues(
+        path_line_size = DEFAULT_VALUES$path_line_size,
+        path_alpha = DEFAULT_VALUES$path_alpha,
+        point_alpha = DEFAULT_VALUES$point_alpha,
+        point_size = DEFAULT_VALUES$point_size
+    )
+    
+    # Reactive value created to store time series selected variables
+    ts_variables <- reactiveValues(selected = NULL)
+    
+    # Reactive value created to store the encoder_input
+    X <- reactiveVal()
+
+    # Reactive value created to store encoder artifact stride
+    enc_ar_stride <- eventReactive(enc_ar(), {
+        stride = ceiling(enc_ar()$metadata$stride/2)
+    })
+
+    # Time series artifact
+    ts_ar <- eventReactive(
+        input$dataset, 
+        {
+        req(input$dataset)
+        ar <- api$artifact(input$dataset, type='dataset')
+        on.exit({print("eventReactive ts_ar -->"); flush.console()})
+        ar
+    }, label = "ts_ar")
+
+
+    # Reactive value for indexing saved projections plot
+    prj_plot_id <- reactiveVal(0)
+    
+    #################################
+    #  OBSERVERS & OBSERVERS EVENTS #
+    #################################
+    observeEvent(
+        req(exists("encs_l")), 
+        {
+            freezeReactiveValue(input, "dataset")
+            print("observeEvent encoders list enc_l | update dataset list | after freeze")
+            updateSelectizeInput(
+                session = session,
+                inputId = "dataset",
+                choices = encs_l %>% 
+                map(~.$metadata$train_artifact) %>% 
+                set_names()
+            )
+            on.exit({print("observeEvent encoders list encs_l | update dataset list -->"); flush.console()})
+        }, 
+        label = "input_dataset"
+    )
+    
+    observeEvent(input$dataset, {
+        #req(encs_l)
+        print("--> observeEvent input_dataset | update encoder list")
+        print(input$dataset)
+        freezeReactiveValue(input, "encoder")
+        print(paste0("observeEvent input_dataset | update encoders for dataset ", input$dataset))
+        updateSelectizeInput(
+            session = session,
+            inputId = "encoder",
+            choices = encs_l %>% 
+            keep(~ .$metadata$train_artifact == input$dataset) %>% 
+            #map(~ .$metadata$enc_artifact) %>% 
+            names
+        )
+        ### TODO: Ver cómo poner bien esta ñapa para que no se actualizen los gráficos antes que el stride
+        updateSliderInput(session, "stride", value = 0)
+        ################
+        on.exit(
+            {print("observeEvent input_dataset | update encoder list -->"); flush.console()}
+        )
+    }, label = "input_encoder")
+        
+    observeEvent(
+        input$encoder, 
+        {
+            #req(input$dataset, encs_l)
+            #enc_ar = req(enc_ar())
+            print("--> observeEvent input_encoder | update wlen")
+            freezeReactiveValue(input, "wlen")
+            print("observeEvent input_encoder | update wlen | Before enc_ar")
+            enc_ar = enc_ar()
+            print(paste0("observeEvent input_encoder | update wlen | enc_ar: ", enc_ar))
+            print("observeEvent input_encoder | update wlen | Set wlen slider values")
+            if (is.null(enc_ar$metadata$mvp_ws)) {
+                print("observeEvent input_encoder | update wlen | Set wlen slider values from w | ")
+                enc_ar$metadata$mvp_ws = c(enc_ar$metadata$w, enc_ar$metadata$w)
+            }
+            print(paste0("observeEvent input_encoder | update wlen | enc_ar$metadata$mvp_ws ", enc_ar$metadata$mvp_ws ))
+            wmin <- enc_ar$metadata$mvp_ws[1]
+            wmax <- enc_ar$metadata$mvp_ws[2]
+            wlen <- enc_ar$metadata$w
+            print(paste0("observeEvent input_encoder | update wlen | Update slider input (", wmin, ", ", wmax, " ) -> ", wlen ))
+            updateSliderInput(session = session, inputId = "wlen",
+                min = wmin,
+                max = wmax,
+                value = wlen
+            )
+            updateSliderInput(
+                session = session, inputId = "stride", 
+                min = 1, max = input$wlen, 
+                value = enc_ar_stride()
+            )
+            on.exit({print("observeEvent input_encoder | update wlen -->"); flush.console()})
+        }
+    )
+
+    # Obtener el valor de stride
+    enc_ar_stride = reactive({
+        print("--> reactive enc_ar_stride")
+        stride = ceiling(enc_ar()$metadata$mvp_ws[2]/2)  #<- enc_ar()$metadata$stride
+        on.exit({print(paste0("reactive_enc_ar_stride | --> ", stride)); flush.console()})
+        stride
+    })
+        
+    observeEvent(input$wlen, {
+        req(input$wlen)
+        print(paste0("--> observeEvent input_wlen | update slide stride value | wlen ",  input$wlen))
+        tryCatch({
+            old_value = input$stride
+            if (input$stride == 0 | input$stride == 1){
+                old_value = enc_ar_stride()
+                print(paste0("enc_ar_stride: ", old_value))
+            }
+            freezeReactiveValue(input, "stride")
+            print(paste0("oserveEvent input_wlen | update slide stride value | Update stride to ", old_value))
+            updateSliderInput(
+                session = session, inputId = "stride", 
+                min = 1, max = input$wlen, 
+                value = ifelse(old_value <= input$wlen, old_value, 1)
+            )
+            }, 
+            error = function(e){
+                print(paste0("observeEvent input_wlen | update slide stride value | Error | ", e$message))
+            }, 
+            warning = function(w) {
+                message(paste0("observeEvent input_wlen | update slide stride value | Warning | ", w$message))
+            }
+        )
+        on.exit({print(paste0( 
+            "observeEvent input_wlen | update slide stride value | Finally |  wlen min ",  
+            1, " max ", input$wlen, " current value ", input$stride, " -->")); flush.console()})
+    })
+
+    # Update "metric_hdbscan" selectInput when the app is loaded
+    observe({
+        updateSelectInput(
+            session = session,
+            inputId = "metric_hdbscan",
+            choices = names(req(hdbscan_metrics))
+        )
+    })
+    # Update the range of point selection when there is new data
+    # observeEvent(X(), {
+    #   #max_ = ts_ar()$metadata$TS$n_samples
+    #   max_ = dim(X())[[1]]
+    #   freezeReactiveValue(input, "points_emb")
+    #   updateSliderInput(session = session, inputId = "points_emb",
+    #                     min = 1, max = max_, value = c(1, max_))
+    # })
+
+    # Update selected time series variables and update interface config
+    observeEvent(tsdf(), {
+        print("--> observeEvent tsdf | update select variables")
+        on.exit({print("--> observeEvent tsdf | update select variables -->"); flush.console()})
+        freezeReactiveValue(input, "select_variables")
+        #ts_variables$selected = names(tsdf())[names(tsdf()) != "timeindex"]
+        ts_variables$selected = names(isolate(tsdf()))
+        print(paste0("observeEvent tsdf | select variables ", ts_variables$selected))
+        updateCheckboxGroupInput(
+            session = session,
+            inputId = "select_variables",
+            choices = ts_variables$selected,
+            selected = ts_variables$selected
+        )
+    }, label = "select_variables")
+        
+    # Update precomputed_clusters reactive value when the input changes
+    observeEvent(input$clusters_labels_name, {
+        print("--> observe | precomputed_cluster selected ")
+        precomputed_clusters$selected <- req(input$clusters_labels_name)
+        print(paste0("observe | precomputed_cluster selected --> | ", precomputed_cluster$selected))
+    })
+    
+    
+    # Update clustering_options reactive value when the input changes
+    observe({
+        print("--> Observe clustering options")
+        clustering_options$selected <- req(input$clustering_options)
+        print("Observe clustering options -->")
+    })
+    
+    # Update clusters_config reactive values when user clicks on "calculate_clusters" button
+    observeEvent(input$calculate_clusters, {
+        print("--> observe event calculate_clusters | update clusters_config")
+        clusters_config$metric_hdbscan <- req(input$metric_hdbscan)
+        clusters_config$min_cluster_size_hdbscan <- req(input$min_cluster_size_hdbscan)
+        clusters_config$min_samples_hdbscan <- req(input$min_samples_hdbscan)
+        clusters_config$cluster_selection_epsilon_hdbscan <- req(input$cluster_selection_epsilon_hdbscan)
+        #on.exit({print("observe event calculate_clusters | update clusters_config -->"))
+    })
+    
+    
+    # Observe the events related to zoom the projections graph
+    observeEvent(input$zoom_btn, {
+        
+        print("--> observeEvent zoom_btn")
+        brush <- input$projections_brush
+        if (!is.null(brush)) {
+            if(isTRUE(input$zoom_btn)){
+                ranges$x <- c(brush$xmin, brush$xmax)
+                ranges$y <- c(brush$ymin, brush$ymax)
+            }else {
+                ranges$x <- NULL
+                ranges$y <- NULL
+            }
+            
+        } else {
+            ranges$x <- NULL
+            ranges$y <- NULL
+        }
+    })
+    
+    
+    # Observe the events related to change the appearance of the projections graph
+    observeEvent(input$update_prj_graph,{
+        style_values <- list(path_line_size = input$path_line_size ,
+                             path_alpha = input$path_alpha,
+                             point_alpha = input$point_alpha,
+                             point_size = input$point_size)
+        
+        if (!is.null(style_values)) {
+            config_style$path_line_size <- style_values$path_line_size
+            config_style$path_alpha <- style_values$path_alpha
+            config_style$point_alpha <- style_values$point_alpha
+            config_style$point_size <- style_values$point_size
+        } else {
+            config_style$path_line_size <- NULL
+            config_style$path_alpha <- NULL
+            config_style$point_alpha <- NULL
+            config_style$point_size <- NULL
+        }
+    })
+    
+    
+    # Update ts_variables reactive value when time series variable selection changes
+    observeEvent(input$select_variables, {
+        ts_variables$selected <- input$select_variables
+    })
+    
+    
+    # Observe to check/uncheck all variables
+    observeEvent(input$selectall,{
+        req(tsdf)
+        ts_variables$selected <- names(isolate(tsdf()))
+        if(input$selectall %%2 == 0){
+            updateCheckboxGroupInput(session = session, 
+                                     inputId = "select_variables",
+                                     choices = ts_variables$selected, 
+                                     selected = ts_variables$selected)
+        } else {
+            updateCheckboxGroupInput(session = session, 
+                                     inputId = "select_variables",
+                                     choices = ts_variables$selected, 
+                                     selected = NULL)
+        }
+    })
+    # Observe to update encoder input (enc_input = X())
+    observe({ #Event(input$dataset, input$encoder, input$wlen, input$stride, {
+    req(input$wlen != 0, input$stride != 0, input$stride != 1)
+    print(paste0("Check reactiveness | X |  wlen, stride |"))
+        if (
+            is.null(X()) ||
+            !identical(
+                input$dataset, isolate(input$dataset)) || 
+                !identical(input$encoder, isolate(input$encoder)) || 
+                input$wlen != isolate(input$wlen) || 
+                input$stride != isolate(input$stride)
+        ) {
+            print("--> ReactiveVal X | Update Sliding Window")
+            print(paste0("reactive X | wlen ", input$wlen, " | stride ", input$stride, " | Let's prepare data"))
+            print("reactive X | SWV")
+            
+            t_x_0 <- Sys.time()
+        
+            enc_input = dvats$exec_with_feather_k_output(
+                function_name = "prepare_forecasting_data",
+                module_name   = "tsai.data.preparation",
+                path = file.path(DEFAULT_PATH_WANDB_ARTIFACTS, ts_ar()$metadata$TS$hash),
+                k_output = as.integer(0),
+                print_flag = TRUE,
+                time_flag = TRUE,
+                fcst_history = input$wlen
+            )
+
+            t_x_1 <- Sys.time()
+            t_sliding_window_view = t_x_1 - t_x_0
+            print(paste0("reactive X | SWV: ", t_sliding_window_view, " secs "))
+            
+            print(paste0("reactive X | Update sliding window | Apply stride ", input$stride," | enc_input ~ ", dim(enc_input), "-->"))
+            print("| Update | X" )
+            on.exit({print("| Outside| X"); flush.console()})
+            X(enc_input)
+        }
+        X()
+    })
+        
+    ###############
+    #  REACTIVES  #
+    ###############
+    
+    # Get timeseries artifact metadata
+    ts_ar_config = reactive({
+        print("--> reactive ts_ar_config | List used artifacts")
+        ts_ar = req(ts_ar())
+        print(paste0("reactive ts_ar_config | List used artifacts | hash", ts_ar$hash))
+        list_used_arts = ts_ar$metadata$TS
+        list_used_arts$vars = ts_ar$metadata$TS$vars %>% stringr::str_c(collapse = "; ")
+        list_used_arts$name = ts_ar$name
+        list_used_arts$aliases = ts_ar$aliases
+        list_used_arts$artifact_name = ts_ar$name
+        list_used_arts$id = ts_ar$id
+        list_used_arts$created_at = ts_ar$created_at
+        list_used_arts
+        on.exit({print("reactive ts_ar_config -->"); flush.console()})
+    })
+        
+    # Get encoder artifact
+    enc_ar <- eventReactive (
+        input$encoder, 
+        {
+            print(paste0("eventReactive enc_ar | Enc. Artifact: ", input$encoder))
+            result <- tryCatch({
+                api$artifact(input$encoder, type = 'learner')
+            }, error = function(e){
+                print(paste0("eventReactive enc_ar | Error: ", e$message))
+                NULL
+            })
+            on.exit({print("envent reactive enc_ar -->"); flush.console()})
+            result
+        }, 
+        ignoreInit = T
+    )
+   
+   # Encoder
+    enc <- eventReactive(
+        enc_ar(), 
+    {
+        req(input$dataset, input$encoder)
+        print("--> eventReactive enc | load encoder ")
+        encoder_artifact <- enc_ar()
+        enc <- py_load_object(
+            file.path(
+                DEFAULT_PATH_WANDB_ARTIFACTS, 
+                encoder_artifact$metadata$ref$hash
+            )
+        )
+        on.exit({print("eventReactive enc | load encoder -->"); flush.console()})
+        enc
+    })
+
+    
+    
+    embs <- reactive({
+        req(X(), enc_l <- enc())
+        print("--> reactive embs | get embeddings")
+        if (torch$cuda$is_available()){
+            print(paste0("CUDA devices: ", torch$cuda$device_count()))
+          } else {
+            print("CUDA NOT AVAILABLE")
+        }
+        t_embs_0 <- Sys.time()
+        print(
+            paste0(
+                "reactive embs | get embeddings | Just about to get embedings. Device number: ", 
+                torch$cuda$current_device() 
+            )
+        )
+        
+        print("reactive embs | get embeddings | Get batch size and dataset")
+
+        dataset_logged_by <- enc_ar()$logged_by()
+        bs = dataset_logged_by$config$batch_size
+        stride = input$stride 
+        
+        print(paste0("reactive embs | get embeddings (set stride set batch size) | Stride ", input$stride, " | batch size: ", bs ))
+        enc_input = X()
+        #chunk_max = 10000000
+        #shape <- dim(enc_input)
+        #print(paste0("reactive embs | get embeddings (set stride set batch size) | enc_input shape: ", shape ))
+        #chunk_size_ = min(shape[1]*shape[2],chunk_max/(shape[1]*shape[2]))
+        #N = max(3200,floor(chunk_size_/32))
+        chunk_size = 10000000 #N*32
+        #print(paste0("reactive embs | get embeddings (set stride set batch size) | Chunk_size ", chunk_size, " | shape[1]*shape[2]: ", shape[1]*shape[2] ))
+        print(paste0("reactive embs | get embeddings (set stride set batch size) | Chunk_size ", chunk_size))
+        #        python_string = paste0("
+        #import dvats.all   
+        cpu_flag = ifelse(input$cpu_flag == "CPU", TRUE, FALSE)
+        result = dvats$get_enc_embs_set_stride_set_batch_size(
+            X = X(),
+            print_flag = TRUE,
+            enc_learn = enc_l,
+            stride =  input$stride,  
+            batch_size = bs, 
+            cpu = cpu_flag, 
+            print_flag = FALSE, 
+            time_flag = TRUE, 
+            chunk_size = chunk_size,
+            check_memory_usage = TRUE
+        )
+       
+        #result <- system(python_string)
+        t_embs_1 <- Sys.time()
+        diff <- t_embs_1 - t_embs_0
+        diff_secs <- as.numeric(diff, units = "secs")
+        diff_mins <- as.numeric(diff, units = "mins")
+        print(paste0("get_enc_embs total time: ", diff_secs, " secs thus ", diff_mins, " mins"))
+        X <- NULL
+        gc(verbose=TRUE)
+        on.exit({print("reactive embs | get embeddings -->"); flush.console()})
+        result
+    })
+
+ prj_object_cpu <- reactive({
+        embs = req(embs(), input$dr_method)
+        embs = embs[complete.cases(embs),]
+        print("--> prj_object")
+        #print(embs) #--
+        #print(paste0("--> prj_object | UMAP params ", str(umap_params_)))
+        print("--> prj_object | UMAP params ")
+        
+        res = switch( input$dr_method,
+            #### Comprobando parametros para saber por qué salen diferentes los embeddings
+            ######### Comprobando los parámetros
+            #UMAP = dvats$get_UMAP_prjs(input_data = embs, cpu=F, n_neighbors = 15, min_dist = 0.1, random_state=as.integer(1234)),
+            UMAP = dvats$get_UMAP_prjs(
+                input_data  = embs, 
+                cpu         = TRUE, 
+                print_flag  = TRUE,
+                n_neighbors = input$prj_n_neighbors, 
+                min_dist    = input$prj_min_dist, 
+                random_state= as.integer(input$prj_random_state)
+            ),
+            TSNE = dvats$get_TSNE_prjs(
+                X = embs, 
+                cpu = TRUE, 
+                random_state=as.integer(input$prj_random_state)
+            ),
+            PCA = dvats$get_PCA_prjs(
+                X = embs, 
+                cpu = TRUE, 
+                random_state=as.integer(input$prj_random_state)
+            )
+        )
+      res = res %>% as.data.frame # TODO: This should be a matrix for improved efficiency
+      colnames(res) = c("xcoord", "ycoord")
+      on.exit({print(" prj_object -->"); flush.console()})
+      flush.console()
+      #browser()
+      res
+    })
+
+    prj_object <- reactive({
+        req(embs(), input$dr_method)
+        print("--> prj_object")
+        t_prj_0 = Sys.time()
+        embs = req(embs())
+        print("prj_object | Before complete cases ")
+        embs = embs[complete.cases(embs),]
+        #print(embs) #--
+        #print(paste0("--> prj_object | UMAP params ", str(umap_params_)))
+        print("prj_object | Before switch ")
+        
+        cpu_flag = ifelse(input$cpu_flag == "CPU", TRUE, FALSE)
+
+        res = switch( input$dr_method,
+            #### Comprobando parametros para saber por qué salen diferentes los embeddings
+            ######### Comprobando los parámetros
+            #UMAP = dvats$get_UMAP_prjs(input_data = embs, cpu=F, n_neighbors = 15, min_dist = 0.1, random_state=as.integer(1234)),
+            UMAP = dvats$get_UMAP_prjs(
+                input_data  = embs, 
+                cpu         = cpu_flag, 
+                print_flag  = TRUE,
+                n_neighbors = input$prj_n_neighbors, 
+                min_dist    = input$prj_min_dist, 
+                random_state= as.integer(input$prj_random_state)
+            ),
+            TSNE = dvats$get_TSNE_prjs(
+                X = embs, 
+                cpu=FALSE, 
+                random_state=as.integer(input$prj_random_state)
+            ),
+            PCA = dvats$get_PCA_prjs(
+                X = embs, 
+                cpu=FALSE, 
+                random_state=as.integer(input$prj_random_state)
+            )
+        )
+      res = res %>% as.data.frame # TODO: This should be a matrix for improved efficiency
+      colnames(res) = c("xcoord", "ycoord")
+      t_prj_1 = Sys.time()
+      on.exit({print(paste0(" prj_object | ", t_prj_1-t_prj_0, " seconds -->")); flush.console()})
+      flush.console()
+      res
+    })
+    
+
+    
+    # Load and filter TimeSeries object from wandb
+    tsdf <- reactive(
+        {    
+            req(input$encoder, ts_ar())
+            ts_ar <- req(ts_ar())
+            print(paste0("--> Reactive tsdf | ts artifact ", ts_ar))
+            flush.console()
+                        
+            t_init <- Sys.time()
+            path = file.path(DEFAULT_PATH_WANDB_ARTIFACTS, ts_ar$metadata$TS$hash)
+            print(paste0("Reactive tsdf | Read feather ", path ))
+            flush.console()
+            df <- read_feather(path, as_data_frame = TRUE, mmap = TRUE) %>% rename('timeindex' = `__index_level_0__`) 
+            t_end = Sys.time()
+            print(paste0("Reactive tsdf | Read feather | Execution time: ", t_end - t_init, " seconds"))
+            flush.console()
+
+            t_end = Sys.time()
+            on.exit({print(paste0("Reactive tsdf | Column to index | Execution time: ", t_end - t_init, " seconds"));flush.console()})
+            df
+        })
+    
+    # Auxiliary object for the interaction ts->projections
+    tsidxs_per_embedding_idx <- reactive({
+      req(input$wlen != 0, input$stride != 0)
+      get_window_indices(1:nrow(isolate(projections())), w = input$wlen, s = input$stride)
+    })
+    
+    # Filter the embedding points and calculate/show the clusters if conditions are met.
+    projections <- reactive({
+        print("--> Projections")
+        req(prj_object(), input$dr_method)
+        #prjs <- req(prj_object()) %>% slice(input$points_emb[[1]]:input$points_emb[[2]])
+        print("Projections | before prjs")
+        prjs <- prj_object()
+        req(input$dataset, input$encoder, input$wlen, input$stride)
+        print("Projections | before switch")
+        switch(clustering_options$selected,
+            precomputed_clusters = {
+               filename <- req(selected_clusters_labels_ar())$metadata$ref$hash
+               clusters_labels <- py_load_object(filename = file.path(DEFAULT_PATH_WANDB_ARTIFACTS, filename))
+               #prjs$cluster <- clusters_labels[input$points_emb[[1]]:input$points_emb[[2]]]
+               prjs$cluster <- clusters_labels
+            },
+            calculate_clusters = {
+                clusters = hdbscan$HDBSCAN(
+                    min_cluster_size = as.integer(clusters_config$min_cluster_size_hdbscan),
+                    min_samples = as.integer(clusters_config$min_samples_hdbscan),
+                    cluster_selection_epsilon = clusters_config$cluster_selection_epsilon_hdbscan,
+                    metric = clusters_config$metric_hdbscan
+                )$fit(prjs)
+                score = 0
+                unique_labels <- unique(clusters$labels_)
+                total_unique_labels <- length(unique_labels)
+                if(total_unique_labels > 1){
+                score = dvats$cluster_score(prjs, clusters$labels_, TRUE)
+                }
+                print(paste0("Projections | Score ", score))
+                if (score <= 0) {
+                    print(paste0("Projections | Repeat projections with CPU because of low quality clusters | score ", score))
+                    prjs <- prj_object_cpu()
+                    clusters = hdbscan$HDBSCAN(
+                        min_cluster_size = as.integer(clusters_config$min_cluster_size_hdbscan),
+                        min_samples = as.integer(clusters_config$min_samples_hdbscan),
+                        cluster_selection_epsilon = clusters_config$cluster_selection_epsilon_hdbscan,
+                        metric = clusters_config$metric_hdbscan
+                    )$fit(prjs)
+                    score = 0
+                    unique_labels <- unique(clusters$labels_)
+                    total_unique_labels <- length(unique_labels)
+                    if(total_unique_labels > 1){
+                    score = dvats$cluster_score(prjs, clusters$labels_, TRUE)
+                    }
+                    print(paste0("Projections | Repeat projections with CPU because of low quality clusters | score ", score))
+                }
+                prjs$cluster <- clusters$labels_
+
+
+             })
+        
+        on.exit({print("Projections -->"); flush.console()})
+      prjs
+    })
+    
+    # Update the colour palette for the clusters
+    update_palette <- reactive({
+        prjs <- req(projections())
+        if ("cluster" %in% names(prjs)) {
+            unique_labels <- unique(prjs$cluster)
+            print(unique_labels)
+            ## IF the value "-1" exists, assign the first element of mycolors to #000000, if not, assign the normal colorRampPalette
+            if (as.integer(-1) %in% unique_labels) 
+                colour_palette <- append("#000000", colorRampPalette(brewer.pal(12,"Paired"))(length(unique_labels)-1))
+            else 
+                colour_palette <- colorRampPalette(brewer.pal(12,"Paired"))(length(unique_labels))
+        }
+        else
+            colour_palette <- "red"
+        
+        colour_palette
+    })
+    
+    color_palete_window_plot <- colorRampPalette(
+        colors = c("blue", "green"),
+        space = "Lab" # Option used when colors do not represent a quantitative scale
+    )
+
+    start_date <- reactive({
+        isolate(tsdf())$timeindex[1]
+    })
+
+    end_date <- reactive({
+        end_date_id = 100000
+        end_date_id = min(end_date_id, nrow(isolate(tsdf())))
+        isolate(tsdf())$timeindex[end_date_id]
+    })
+
+    ts_plot_base <- reactive({
+        print("--> ts_plot_base")
+        on.exit({print("ts_plot_base -->"); flush.console()})
+        start_date =isolate(start_date())
+        end_date = isolate(end_date())
+        print(paste0("ts_plot_base | start_date: ", start_date, " end_date: ", end_date))
+        t_init <- Sys.time()
+        tsdf_ <- isolate(tsdf()) %>% select(ts_variables$selected, - "timeindex")
+        tsdf_xts <- xts(tsdf_, order.by = tsdf()$timeindex)
+        t_end <- Sys.time()
+        print(paste0("ts_plot_base | tsdf_xts time", t_end-t_init)) 
+        print(head(tsdf_xts))
+        print(tail(tsdf_xts))
+        ts_plt = dygraph(
+            tsdf_xts,
+            width="100%", height = "400px"
+        ) %>% 
+        dyRangeSelector(c(start_date, end_date)) %>% 
+        dyHighlight(hideOnMouseOut = TRUE) %>%
+        dyOptions(labelsUTC = FALSE  ) %>%
+        dyCrosshair(direction = "vertical")%>%
+        dyLegend(show = "follow", hideOnMouseOut = TRUE) %>%
+        dyUnzoom() %>%
+        dyHighlight(highlightSeriesOpts = list(strokeWidth = 3)) %>%
+        dyCSS(
+            textConnection(
+                ".dygraph-legend > span { display: none; }
+                .dygraph-legend > span.highlight { display: inline; }"
+            )
+        ) 
+
+    })
+
+    embedding_ids <- reactive({
+        print("--> embedding idx")
+        on.exit(print("embedding idx -->"))
+        bp = brushedPoints(prj_object(), input$projections_brush, allRows = TRUE) #%>% debounce(miliseconds) #Wait 1 seconds: 1000
+        bp %>% rownames_to_column("index") %>% dplyr::filter(selected_ == TRUE) %>% pull(index) %>% as.integer
+    })
+
+    window_list <- reactive({
+        print("--> window_list")
+        on.exit(print("window_list -->"))
+        # Get the window indices
+        req(length(embedding_ids() > 0))
+        embedding_idxs = embedding_ids()
+        window_indices = get_window_indices(embedding_idxs, input$wlen, input$stride)
+        # Put all the indices in one list and remove duplicates
+        unlist_window_indices = unique(unlist(window_indices))
+        # Calculate a vector of differences to detect idx where a new window should be created 
+        diff_vector <- diff(unlist_window_indices,1)
+        # Take indexes where the difference is greater than one (that represent a change of window)
+        idx_window_limits <- which(diff_vector!=1)
+        # Include the first and last index to have a whole set of indexes.
+        idx_window_limits <- c(1, idx_window_limits, length(unlist_window_indices))
+        # Create a reduced window list
+        reduced_window_list <-  vector(mode = "list", length = length(idx_window_limits)-1)
+        # Populate the first element of the list with the idx of the first window.
+        reduced_window_list[[1]] <- c(unlist_window_indices[idx_window_limits[1]],
+                            unlist_window_indices[idx_window_limits[1+1]])
+        # Populate the rest of the list
+        for (i in 2:(length(idx_window_limits)-1)){
+            reduced_window_list[[i]]<- c(
+                #unlist_window_indices[idx_window_limits[i]+1],
+                #unlist_window_indices[idx_window_limits[i+1]]
+                            as.Date(isolate(tsdf())$timeindex[unlist_window_indices[idx_window_limits[i]+1]]),
+                            as.Date(isolate(tsdf())$timeindex[unlist_window_indices[idx_window_limits[i+1]]])
+                               )
+        }
+        reduced_window_list
+    })
+    
+
+    # Generate timeseries data for dygraph dygraph
+    ts_plot <- reactive({
+        print("--> ts_plot | Before req 1")
+        on.exit({print("ts_plot -->"); flush.console()})
+
+        req(tsdf(), ts_variables, input$wlen != 0, input$stride)
+
+        ts_plt = ts_plot_base()   
+
+        print("ts_plot | bp")
+        #miliseconds <-  ifelse(nrow(tsdf()) > 1000000, 2000, 1000)
+        
+        #if (!is.data.frame(bp)) {bp = bp_}
+        print("ts_plot | embedings idxs ")
+        embedding_idxs = embedding_ids()
+        # Calculate windows if conditions are met (if embedding_idxs is !=0, that means at least 1 point is selected)
+        print("ts_plot | Before if")
+        if ((length(embedding_idxs)!=0) & isTRUE(input$plot_windows)) {
+            reduced_window_list = req(window_list())
+            print(paste0("ts_plot | reduced_window_list[1] = ", reduced_window_list[1]))
+            start_indices = min(sapply(reduced_window_list, function(x) x[1]))
+            end_indices = max(sapply(reduced_window_list, function(x) x[2]))
+
+            view_size = end_indices-start_indices+1
+            max_size = 10000
+
+            start_date = isolate(tsdf())$timeindex[start_indices]
+            end_date = isolate(tsdf())$timeindex[end_indices]
+
+            print(paste0("ts_plot | reuced_window_list (", start_date, end_date, ")", "view size ", view_size, "max size ", max_size))
+            
+            if (view_size > max_size) {
+                end_date = isolate(tsdf())$timeindex[start_indices + max_size - 1]
+                #range_color = "#FF0000" # Red
+            } 
+            
+            range_color = "#CCEBD6" # Original
+            
+
+            # # Plot the windows
+            count = 0
+            for(ts_idxs in reduced_window_list) {
+                count = count + 1
+                start_event_date = isolate(tsdf())$timeindex[head(ts_idxs, 1)]
+                end_event_date = isolate(tsdf())$timeindex[tail(ts_idxs, 1)]
+                ts_plt <- ts_plt %>% dyShading(
+                    from = start_event_date,
+                    to = end_event_date,
+                    color = range_color
+                ) 
+            ts_plt <- ts_plt %>% dyRangeSelector(c(start_date, end_date))
+                #%>% dyEvent(
+                #    start_event_date, 
+                #    label = paste0("SW-", count), 
+                #    labelLoc="bottom" ,
+                #    strokePattern = "solid",
+                #    color = range_color 
+                #    ) %>% dyEvent(
+                #    end_event_date, 
+                #    label = paste0("SW-",paste0("SW-", count), 
+                #    labelLoc="bottom",
+                #    strokePattern = "solid"),
+                #    color = range_color
+                #    )
+
+            }   
+            
+            ts_plt <- ts_plt
+            # NOTE: This code block allows you to plot shadyng at once. 
+            #       The traditional method has to plot the dygraph n times 
+            #       (n being the number of rectangles to plot). With the adjacent
+            #       code it is possible to plot the dygraph only once. Currently
+            #       it does not work well because there are inconsistencies in the
+            #       timezones of the time series and shiny (there is a two-hour shift[the current plot method works well]),
+            #       which does not allow this method to be used correctly. If that
+            #       were fixed in the future everything would work fine.
+            # num_rects <- length(reduced_window_list)
+            # rects_ini <- vector(mode = "list", length = num_rects)
+            # rects_fin <- vector(mode = "list", length = num_rects)
+            # for(i in 1:num_rects) {
+            #     rects_ini[[i]] <- head(reduced_window_list[[i]],1)
+            #     rects_fin[[i]] <- tail(reduced_window_list[[i]],1)
+            # }
+            # ts_plt <- vec_dyShading(ts_plt,rects_ini, rects_fin,"red", rownames(tsdf()))
+        }
+        
+        ts_plt
+    })
+    
+    # Get projections plot name for saving
+    prjs_plot_name <- reactive({
+        dataset_name <- basename(input$dataset)
+        encoder_name <- basename(input$encoder)
+        get_prjs_plot_name(dataset_name, encoder_name, clustering_options$selected, prjs_$cluster, prj_plot_id, input)
+    })
+    
+    # Get timeserie plot name for saving
+    ts_plot_name <- reactive({
+        dataset_name <- basename(input$dataset)
+        encoder_name <- basename(input$encoder)
+        get_ts_plot_name(dataset_name, encoder_name, prj_plot_id, input)
+    })
+
+    #############
+    #  OUTPUTS  #
+    #############
+
+        output$windows_plot <- renderPlot({
+        req(length(embedding_ids()) > 0)
+        reduced_window_list = req(window_list())
+
+        # Convertir a fechas POSIXct
+        reduced_window_df <- do.call(rbind, lapply(reduced_window_list, function(x) {
+            data.frame(
+                start = as.POSIXct(isolate(tsdf())$timeindex[x[1]], origin = "1970-01-01"),
+                end = as.POSIXct(isolate(tsdf())$timeindex[x[2]], origin = "1970-01-01")
+            )
+        }))
+
+        # Establecer límites basados en los datos
+        first_date = min(reduced_window_df$start)
+        last_date = max(reduced_window_df$end)
+    
+        left = as.POSIXct(isolate(tsdf())$timeindex[1],  origin = "1970-01-01")
+        right = as.POSIXct(isolate(tsdf())$timeindex[nrow(isolate(tsdf()))], origin = "1970-01-01")
+
+        # Configuración del gráfico base
+        par(mar = c(5, 4, 4, 0) + 0.1)  #Down Up Left Right
+        plt <- plot(
+            NA, 
+            xlim = c(left, right), 
+            ylim = c(0, 1), 
+            type = "n", 
+            xaxt = "n", yaxt = "n", 
+            xlab = "", ylab = "", 
+            bty = "n")
+            f = "%F %H:%M:%S"
+            axis(1, at = as.numeric(c(left, right)), labels = c(format(first_date, f), format(last_date, f)), cex.axis = 0.7)
+
+            # Añadir líneas verticales
+            colors = color_palete_window_plot(2)
+            abline(
+                v = as.numeric(reduced_window_df$start), 
+                col =  rep(colors, length.out = nrow(reduced_window_df)),
+                lwd = 1
+            )
+            abline(
+                v = as.numeric(reduced_window_df$end), 
+                col =  rep(colors, length.out = nrow(reduced_window_df)),
+                lwd = 1
+            )
+            segments(
+                x0 = as.numeric(reduced_window_df$start),
+                x1 = as.numeric(reduced_window_df$end),
+                y0 = 0,
+                y1 = 0,
+                col =  rep(colors, length.out = nrow(reduced_window_df)),
+                lwd = 1
+            )
+            text(
+                x = as.numeric(reduced_window_df$start),
+                y = 0,
+                srt = 90,
+                adj = c(1,0.5),
+                labels =  paste0("SW-", seq_len(nrow(reduced_window_df)), format(reduced_window_df$start, f)), 
+                cex = 1,
+                xpd = TRUE,
+                col = rep(colors, length.out = nrow(reduced_window_df))
+            )
+
+            points(x = as.numeric(left),y = 0, col = "black", pch = 20, cex = 1)
+            points(x = as.numeric(right),y = 0, col = "black", pch = 20, cex = 1)
+            plt
+        }, 
+        height=200
+    )  
+
+    output$windows_text <- renderUI({
+        req(length(embedding_ids()) > 0)
+        reduced_window_list = req(window_list())
+
+        # Crear un conjunto de etiquetas de texto con información de las ventanas
+        window_info <- lapply(1:length(reduced_window_list), function(i) {
+            window <- reduced_window_list[[i]]
+            start <- format(as.POSIXct(isolate(tsdf())$timeindex[window[1]], origin = "1970-01-01"), "%b %d")
+            end <- format(as.POSIXct(isolate(tsdf())$timeindex[window[2]], origin = "1970-01-01"), "%b %d")
+            color <- ifelse(i %% 2 == 0, "green", "blue")
+            HTML(paste0("<div style='color: ", color, "'>Window ", i, ": ", start, " - ", end, "</div>"))
+        })
+
+        # Devuelve todos los elementos de texto como una lista de HTML
+        do.call(tagList, window_info)
+    })
+    
+    # Generate encoder info table
+    output$enc_info = renderDataTable({
+        selected_encoder_name <- req(input$encoder)
+        on.exit({print("Encoder artiffact -->"); flush.console()})
+        print(paste0("--> Encoder artiffact", selected_encoder_name))
+        selected_encoder <- encs_l[[selected_encoder_name]]
+        encoder_metadata <- req(selected_encoder$metadata)
+        print(paste0("Encoder artiffact | encoder metadata ", selected_encoder_name))
+        encoder_metadata %>%enframe()
+            })
+    
+    # Generate time series info table
+    output$ts_ar_info = renderDataTable({
+        ts_ar_config() %>% enframe()
+    })
+
+
+
+    
+       
+    # Generate projections plot
+    output$projections_plot <- renderPlot({
+        req(input$dataset, input$encoder, input$wlen != 0, input$stride != 0)
+        print("--> Projections_plot")
+        prjs_ <- req(projections())
+        print("projections_plot | Prepare column highlights")
+        # Prepare the column highlight to color data
+        if (!is.null(input$ts_plot_dygraph_click)) {
+            selected_ts_idx = which(ts_plot()$x$data[[1]] == input$ts_plot_dygraph_click$x_closest_point)
+            projections_idxs = tsidxs_per_embedding_idx() %>% map_lgl(~ selected_ts_idx %in% .)
+            prjs_$highlight = projections_idxs
+        } else {
+            prjs_$highlight = FALSE
+        }
+        # Prepare the column highlight to color data. If input$generate_cluster has not been clicked
+        # the column cluster will not exist in the dataframe, so we create with the value FALSE
+        if(!("cluster" %in% names(prjs_)))
+            prjs_$cluster = FALSE
+        print("projections_plot | GoGo Plot!")
+        plt <- ggplot(data = prjs_) + 
+            aes(x = xcoord, y = ycoord, fill = highlight, color = as.factor(cluster)) + 
+            scale_colour_manual(name = "clusters", values = req(update_palette())) +
+            geom_point(shape = 21,alpha = config_style$point_alpha, size = config_style$point_size) + 
+            scale_shape(solid = FALSE) +
+            #geom_path(size=config_style$path_line_size, colour = "#2F3B65",alpha = config_style$path_alpha) + 
+            guides() + 
+            scale_fill_manual(values = c("TRUE" = "green", "FALSE" = "NA"))+
+            coord_cartesian(xlim = ranges$x, ylim = ranges$y, expand = TRUE)+
+            theme_void() + 
+            theme(legend.position = "none")
+        
+        if (input$show_lines){
+            #plt <- plt + geom_path(size=config_style$path_line_size, colour = "#2F3B65",alpha = config_style$path_alpha)
+            plt <- plt + geom_path(linewidth=config_style$path_line_size, colour = "#2F3B65",alpha = config_style$path_alpha)
+        }
+
+        observeEvent(input$savePlot, {
+            plt <- plt + theme(plot.background = element_rect(fill = "white"))
+            ggsave(filename = prjs_plot_name(), plot = plt, path = "../data/plots/")
+        })
+        #observeEvent(c(input$dataset, input$encoder, clustering_options$selected), {   
+            #req(input$dataset, input$encoder)
+            #print("!-- CUDA?: ", torch$cuda$is_available())
+            #prjs_ <- req(projections())
+            #filename <- prjs_plot_name()
+            #print(paste("saving embedding plot to ",filename))
+            #ggsave(filename = filename, plot = plt, path="../data/plots/") 
+            #print("Embeding plot saved")
+        #})
+        
+        plt
+    })
+    
+    
+    # Render projections plot
+    output$projections_plot_ui <- renderUI(
+        {
+            plotOutput(
+                "projections_plot", 
+                click = "projections_click",
+                brush = "projections_brush",
+                height = input$embedding_plot_height
+            ) %>% withSpinner()
+        }
+    )
+        
+    # Render information about the selected point in the time series graph
+    output$point <- renderText({
+        req(input$ts_plot_dygraph_click$x_closest_point)
+        ts_idx = which(ts_plot()$ts$x$data[[1]] == input$ts_plot_dygraph_click$x_closest_point)
+        paste0('X = ', strftime(req(input$ts_plot_dygraph_click$x_closest_point), "%F %H:%M:%S"), 
+               '; Y = ', req(input$ts_plot_dygraph_click$y_closest_point),
+               '; X (raw) = ', req(input$ts_plot_dygraph_click$x_closest_point))
+    })
+    
+    # Render information about the selected point and brush in the projections graph
+    output$projections_plot_interaction_info <- renderText({
+        xy_str <- function(e) {
+            if(is.null(e)) return("NULL\n")
+            paste0("x=", round(e$x, 1), " y=", round(e$y, 1), "\n")
+        }
+        xy_range_str <- function(e) {
+            if(is.null(e)) return("NULL\n")
+            paste0("xmin=", round(e$xmin, 1), " xmax=", round(e$xmax, 1), 
+                   " ymin=", round(e$ymin, 1), " ymax=", round(e$ymax, 1))
+        }
+        paste0(
+            "click: ", xy_str(input$projections_click),
+            "brush: ", xy_range_str(input$projections_brush)
+        )
+    })
+        
+    # Generate time series plot
+    output$ts_plot_dygraph <- renderDygraph(
+        {
+            req (
+                input$dataset, 
+                input$encoder,
+                input$wlen != 0, 
+                input$stride != 0
+            )
+            #print("Saving time series plot")
+            ts_plot <- req(ts_plot())
+            #save_path <- file.path("..", "data", "plots", ts_plot_name())
+            #htmlwidgets::saveWidget(ts_plot, file = save_path, selfcontained=TRUE)
+            #print(paste0("Time series plot saved to", save_path))
+            ts_plot
+            #req(ts_plot())
+        }   
+    )
+
+
+    prjs_plot_name <- reactive({
+        dataset_name <- basename(input$dataset)
+        encoder_name <- basename(input$encoder)
+        get_prjs_plot_name(dataset_name, encoder_name, clustering_options$selected, prjs_$cluster)
+    })
+    
+    ts_plot_name <- reactive({
+        dataset_name <- basename(input$dataset)
+        encoder_name <- basename(input$encoder)
+        get_ts_plot_name(dataset_name, encoder_name)
+    })
+    
+})
+

r_shiny_app/ui.R

@@ -0,0 +1,179 @@
+#
+# This is the user-interface definition of a Shiny web application. You can
+# run the application by clicking 'Run App' above.
+#
+# Find out more about building applications with Shiny here:
+#
+#    http://shiny.rstudio.com/
+#
+
+shinyUI(fluidPage(
+  #theme = shinythemes::shinytheme("cerulean"),
+  # Application title
+  titlePanel("DeepVATS"),
+  
+  # Load Shinyjs
+  shinyjs::useShinyjs(),
+  
+  # Sidebar with a slider input for number of bins
+  sidebarLayout(
+    sidebarPanel(
+      fluidRow(
+        shiny::actionButton("load_dataset", label = "Load dataset", icon = icon("database")),
+        shiny::actionButton("load_embs", label = "Load embeddings", icon = icon("project-diagram"))
+      ),
+      hr(),
+      selectizeInput("dataset", label = "Dataset", choices = NULL),
+      selectizeInput("encoder", label = "Encoder", choices = NULL),
+      #selectizeInput("embs_ar", label = "Select embeddings", choices = names(embs_l)),
+      br(),
+      sliderInput("wlen", "Select window size", min = 0, max = 0, value =0 , step = 1),
+      sliderInput("stride", "Select stride", min = 0, max = 0, value = 0, step = 1),
+      # sliderInput("points_emb", "Select range of points to plot in the projections", 
+      #             min = 0, max = 0, value = 0, step = 1, ticks = FALSE),
+      #uiOutput("points_prj_controls"),
+      #### TODO: Check. Added for debugging solar 4_secs
+      sliderInput("prj_n_neighbors", "Projections n_neighbors:", min = 1, max = 50, value = 15),
+      sliderInput("prj_min_dist", "Projections min_dist:", min = 0.0001, max = 1, value = 0.1),
+      #sliderInput("prj_random_state", "Projections random_state:", min = 0, max = 2^32-1, value = 1234),
+      sliderInput("prj_random_state", "Projections random_state:", min = 0, max = 2000, value = 1234),
+      ################
+      radioButtons("cpu_flag", "Use: ", c("GPU", "CPU"), selected = "GPU", inline = T),
+      radioButtons("dr_method", "Projection method:", c("UMAP", "TSNE", "PCA"), selected="UMAP", inline=T),
+      br(),
+      radioButtons("clustering_options", label = "Select a clustering option", selected = "no_clusters",
+                   choices = c("No clusters" = "no_clusters",
+                               #"Show precomputed clusters" = "precomputed_clusters",
+                               "Calculate and show clusters" = "calculate_clusters")),
+      # conditionalPanel(
+      #     condition = "input.clustering_options == 'precomputed_clusters'",
+      #     selectInput("clusters_labels_name", label = "Select a clusters_labels artifact", choices = NULL),
+      #     tags$b("Selected 'clusters_labels' artifact description:"),
+      #     textOutput("clusters_labels_ar_desc")
+      # ),
+      conditionalPanel(
+          condition = "input.clustering_options == 'calculate_clusters'",
+        selectInput("metric_hdbscan", label = "Metric", choices = DEFAULT_VALUES$metric_hdbscan),
+        sliderInput("min_cluster_size_hdbscan", label = "min_cluster_size_hdbscan", 
+                    value = DEFAULT_VALUES$min_cluster_size_hdbscan, min=0, max=200, step = 1),
+        sliderInput("min_samples_hdbscan", label = "min_samples_hdbscan", 
+                    value = DEFAULT_VALUES$min_samples_hdbscan, min=0, max=50, step = 1),
+        sliderInput("cluster_selection_epsilon_hdbscan", label = "cluster_selection_epsilon", 
+                    value = DEFAULT_VALUES$cluster_selection_epsilon_hdbscan, min=0, max=5, step = 0.01),
+        actionBttn(inputId = "calculate_clusters", label = "Calculate and show clusters", style = "bordered",
+                   color = "primary", size = "sm", block = TRUE)
+      ),
+    ),
+    # Show a plot of the generated distribution
+    mainPanel(
+      tabsetPanel(
+        id = "tabs",
+        tabPanel(
+          "Projections",
+          fluidRow(
+            h3("Embedding projections"),
+            fluidRow(
+              column(1,
+                     dropdownButton(
+                       tags$b("Set height of the projections plot (px):"),
+                       numericInput("embedding_plot_height", label = "Height",value =400),
+                       hr(),
+                       tags$b("Configure aestethics"),
+                       sliderInput("path_line_size", label = "path_line_size", 
+                                   value = DEFAULT_VALUES$path_line_size, min=0, max=5, step = 0.01),
+                       sliderInput("path_alpha", label = "path_alpha",
+                                   value = DEFAULT_VALUES$path_alpha, min=0, max=1, step = 0.01),
+                       sliderInput("point_alpha", label = "point_alpha",
+                                   value = DEFAULT_VALUES$point_alpha, min=0, max=1, step = 0.01),
+                       sliderInput("point_size", label = "point_size",
+                                   value = DEFAULT_VALUES$point_size, min=0, max=10, step = 0.5),
+                       checkboxInput("show_lines", "Show lines", value = TRUE),
+                       actionButton('savePlot', 'Save embedding projections plot'),
+
+                       actionBttn(inputId = "update_prj_graph",label = "Update aestethics",style = "simple",
+                                  color = "primary",icon = icon("bar-chart"),size = "xs", block = TRUE),
+                       circle = FALSE, status = "primary",
+                       icon = icon("gear"), width = "300px",size = "xs",
+                       tooltip = tooltipOptions(title = "Configure the embedding appearance"),
+                       inputId = "projections_config"
+                     )
+              ),
+              column(8,
+                     prettyToggle(
+                       inputId = "zoom_btn",
+                       label_on = "Zoom out",
+                       label_off = "Zoom in",
+                       shape = "square",
+                       outline = TRUE,
+                       plain = TRUE,
+                       inline = TRUE,
+                       icon_on = icon("search-minus"), 
+                       icon_off = icon("search-plus"),
+                       status_on = "danger",
+                       status_off = "primary"
+                     ),
+                     materialSwitch(
+                       inputId = "plot_windows",
+                       label = "Plot windows",
+                       status = "info",
+                       value = TRUE,
+                       inline = TRUE
+                     )
+              ),
+              column(3)
+            ),
+            fluidRow(
+              uiOutput("projections_plot_ui")
+            )
+          ),
+          fluidRow(h3("Original data")),
+          fluidRow(
+            dropdownButton(
+              tags$b("Select/deselect variables"),
+              tags$div(style= 'height:200px; overflow-y: scroll', 
+                       checkboxGroupInput(inputId = "select_variables",
+                                          label=NULL, choices = NULL, selected = NULL)
+              ),
+              actionBttn(inputId = "selectall",label = "Select/Deselect all",style = "simple",
+                         color = "primary",icon = icon("check-double"),size = "xs", block = TRUE),
+              hr(),
+              prettySwitch(inputId = "dygraph_sel",label = "Show stacked graphs (Not available yet)",
+                           status = "success",fill = TRUE),
+              circle = FALSE, status = "primary", size = "xs",
+              icon = icon("gear"), width = "300px",
+              tooltip = tooltipOptions(title = "Configure the TS appearance"),
+              inputId = "ts_config"
+            )
+          ),
+          fluidRow(
+            column(12,
+              #sliderInput(
+                #"nrows", "Select initial data range:", 
+                #min = 0, max = 10000, 
+                #value = c(0,0),
+                #step = 1000000
+              #),
+              dygraphOutput("ts_plot_dygraph") %>% withSpinner(),
+              plotOutput("windows_plot"),
+              uiOutput("windows_text")
+            )
+          )
+          #verbatimTextOutput("projections_plot_interaction_info"),
+          #verbatimTextOutput("point")
+          
+        ),
+        tabPanel(
+          "Information",
+          fluidRow(
+            h3("Time series"),
+            dataTableOutput("ts_ar_info"),
+            h3("Configuration of the associated encoder"),
+            dataTableOutput("enc_info")
+          )
+        ),
+      )
+    )
+  )
+
+  
+))