EVIDENCIA NOVEM

1 LIBRERÍAS

# Librerías necesarias
library(tidyverse)

## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ dplyr     1.1.4     ✔ readr     2.1.5
## ✔ forcats   1.0.0     ✔ stringr   1.5.1
## ✔ ggplot2   3.5.1     ✔ tibble    3.2.1
## ✔ lubridate 1.9.4     ✔ tidyr     1.3.1
## ✔ purrr     1.0.4     
## ── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ dplyr::filter() masks stats::filter()
## ✖ dplyr::lag()    masks stats::lag()
## ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors

library(readxl)
library(purrr)
library(knitr)
#install.packages("kableExtra")
library(kableExtra)

## 
## Attaching package: 'kableExtra'
## 
## The following object is masked from 'package:dplyr':
## 
##     group_rows

library(ggplot2)
#install.packages("igraph")
library(igraph)

## 
## Attaching package: 'igraph'
## 
## The following objects are masked from 'package:lubridate':
## 
##     %--%, union
## 
## The following objects are masked from 'package:dplyr':
## 
##     as_data_frame, groups, union
## 
## The following objects are masked from 'package:purrr':
## 
##     compose, simplify
## 
## The following object is masked from 'package:tidyr':
## 
##     crossing
## 
## The following object is masked from 'package:tibble':
## 
##     as_data_frame
## 
## The following objects are masked from 'package:stats':
## 
##     decompose, spectrum
## 
## The following object is masked from 'package:base':
## 
##     union

#install.packages("forecast")
#install.packages("lubridate")
library(forecast)

## Registered S3 method overwritten by 'quantmod':
##   method            from
##   as.zoo.data.frame zoo

library(lubridate)
library(corrplot)

## corrplot 0.95 loaded

library(RColorBrewer)
#install.packages("ggcorrplot")
library(ggcorrplot)
library(caret)

## Loading required package: lattice
## 
## Attaching package: 'caret'
## 
## The following object is masked from 'package:purrr':
## 
##     lift

library(car)

## Loading required package: carData
## 
## Attaching package: 'car'
## 
## The following object is masked from 'package:dplyr':
## 
##     recode
## 
## The following object is masked from 'package:purrr':
## 
##     some

library(randomForest)

## randomForest 4.7-1.2
## Type rfNews() to see new features/changes/bug fixes.
## 
## Attaching package: 'randomForest'
## 
## The following object is masked from 'package:dplyr':
## 
##     combine
## 
## The following object is masked from 'package:ggplot2':
## 
##     margin

#install.packages("xgboost")
library(xgboost)

## 
## Attaching package: 'xgboost'
## 
## The following object is masked from 'package:dplyr':
## 
##     slice

#install.packages("patchwork")
library(patchwork)
library(dplyr)
#install.packages("scales")
library (ggplot2)

2 CARGA DE DATOS

# Leer datos
datos <- read_excel("/Users/mariadelbosque/Downloads/Novem_final.xlsx") %>%
  mutate(Trx_Fecha = as.Date(Trx_Fecha))

# Partición temporal
train <- datos %>% filter(Trx_Fecha >= as.Date("2023-01-01") & Trx_Fecha < as.Date("2024-10-01"))
test  <- datos %>% filter(Trx_Fecha >= as.Date("2024-10-01") & Trx_Fecha <= as.Date("2024-12-31"))

# Validación rápida
summary(train$Trx_Fecha)

##         Min.      1st Qu.       Median         Mean      3rd Qu.         Max. 
## "2023-01-02" "2023-06-10" "2023-11-16" "2023-11-16" "2024-04-23" "2024-09-30"

summary(test$Trx_Fecha)

##         Min.      1st Qu.       Median         Mean      3rd Qu.         Max. 
## "2024-10-07" "2024-10-28" "2024-11-18" "2024-11-18" "2024-12-09" "2024-12-30"

# Ver todos los productos ordenados por ventas totales
top_ids <- datos %>%
  group_by(ID_Inventario) %>%
  summarise(Ventas_Totales = sum(Venta, na.rm = TRUE)) %>%
  arrange(desc(Ventas_Totales))

print("Productos ordenados por ventas totales:")

## [1] "Productos ordenados por ventas totales:"

print(top_ids)

## # A tibble: 5 × 2
##   ID_Inventario Ventas_Totales
##           <dbl>          <dbl>
## 1        155001      25110107.
## 2       3929788      22771766.
## 3       3904152      19156601.
## 4        155002      16699118.
## 5       3678055      16686238.

datos_filtrados <- train  # usamos todo el train
# Contar observaciones por producto
conteo <- datos_filtrados %>%
  count(ID_Inventario, sort = TRUE)
print("Número de registros por producto en datos_filtrados:")

## [1] "Número de registros por producto en datos_filtrados:"

print(conteo)

## # A tibble: 5 × 2
##   ID_Inventario     n
##           <dbl> <int>
## 1        155001    92
## 2        155002    92
## 3       3678055    92
## 4       3904152    92
## 5       3929788    92

# Validación de que haya datos
if (nrow(datos_filtrados) == 0) {
  stop("No hay datos suficientes en el conjunto de entrenamiento.")}

3 ESTACIONALIDAD SEMANAL

3.1 TEST DE ESTACIONALIDAD

# Asegúrate de tener Año y Semana en tu base
datos$Trx_Fecha <- as.Date(datos$Trx_Fecha)

datos <- datos %>%
  mutate(
    Anio = isoyear(Trx_Fecha),
    Semana = isoweek(Trx_Fecha)
  )

# Agregamos ventas por producto, semana y año
ventas_semanales <- datos %>%
  group_by(ID_Inventario, Semana, Anio) %>%
  summarise(Venta_Semanal = sum(Venta, na.rm = TRUE), .groups = "drop")

# Calculamos CV por producto y semana
cv_por_semana <- ventas_semanales %>%
  group_by(ID_Inventario, Semana) %>%
  summarise(
    media = mean(Venta_Semanal, na.rm = TRUE),
    sd = sd(Venta_Semanal, na.rm = TRUE),
    .groups = 'drop'
  ) %>%
  mutate(CV = sd / media)

# Promedio del CV semanal por producto + clasificación de estacionalidad
estacionalidad_semanal <- cv_por_semana %>%
  group_by(ID_Inventario) %>%
  summarise(CV_Promedio_Semanal = mean(CV, na.rm = TRUE)) %>%
  mutate(
    Hay_Estacionalidad = ifelse(CV_Promedio_Semanal >= 0.3, "Sí", "No")
  ) %>%
  arrange(desc(CV_Promedio_Semanal))

print(estacionalidad_semanal)

## # A tibble: 5 × 3
##   ID_Inventario CV_Promedio_Semanal Hay_Estacionalidad
##           <dbl>               <dbl> <chr>             
## 1       3678055               0.369 Sí                
## 2        155002               0.298 No                
## 3        155001               0.281 No                
## 4       3904152               0.248 No                
## 5       3929788               0.228 No

3.2 VISUALIZACIÓN DE ESTACIONALIDAD

# Paso 1: Asegurar formato de fecha
datos$Trx_Fecha <- as.Date(datos$Trx_Fecha)

# Paso 2: Crear columnas de Año y Mes
datos <- datos %>%
  mutate(
    Anio = isoyear(Trx_Fecha),
    Semana = isoweek(Trx_Fecha)
  )

# Paso 3: Agregar ventas por producto, año y mes
datos_agregados <- datos %>%
  group_by(ID_Inventario, Anio, Semana) %>%
  summarise(Venta_Semanal = sum(Venta, na.rm = TRUE), .groups = 'drop')

# Paso 4: Generar gráficas por producto con colores personalizados
graficas <- datos_agregados %>%
  group_split(ID_Inventario) %>%
  lapply(function(df_prod) {
    ggplot(df_prod, aes(x = Semana, y = Venta_Semanal, color = as.factor(Anio))) +
      geom_line(size = 1.2) +
      scale_color_manual(
        values = c(
          "2023" = "#68838B",  # Azul grisáceo
          "2024" = "#FF69B4"   # Rosa fuerte
        )
      ) +
      labs(
        title = paste("Estacionalidad Semanal - Producto", unique(df_prod$ID_Inventario)),
        x = "Semana",
        y = "Venta Semanal",
        color = "Año"
      ) +
      theme_minimal(base_size = 13) +
      theme(
        plot.title = element_text(face = "bold"),
        legend.position = "bottom"
      )
  })

## Warning: Using `size` aesthetic for lines was deprecated in ggplot2 3.4.0.
## ℹ Please use `linewidth` instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.

# Paso 5: Mostrar una gráfica como prueba
print(graficas[[1]])

print(graficas[[2]])

print(graficas[[3]])

print(graficas[[4]])

print(graficas[[5]])

4 ESTACIONALIDAD MENSUAL

4.1 TEST DE ESTACIONALIDAD

# Asegúrate de tener Año y Semana en tu base
datos$Trx_Fecha <- as.Date(datos$Trx_Fecha)

datos <- datos %>%
  mutate(
    Anio = isoyear(Trx_Fecha),
    Mes = month(Trx_Fecha)
  )

# Agregamos ventas por producto, semana y año
ventas_mensual <- datos %>%
  group_by(ID_Inventario, Mes, Anio) %>%
  summarise(Venta_Mensual = sum(Venta, na.rm = TRUE), .groups = "drop")

# Calculamos CV por producto y semana
cv_por_mes <- ventas_mensual %>%
  group_by(ID_Inventario, Mes) %>%
  summarise(
    media = mean(Venta_Mensual, na.rm = TRUE),
    sd = sd(Venta_Mensual, na.rm = TRUE),
    .groups = 'drop'
  ) %>%
  mutate(CV = sd / media)

# Promedio del CV semanal por producto + clasificación de estacionalidad
estacionalidad_mensual <- cv_por_mes %>%
  group_by(ID_Inventario) %>%
  summarise(CV_Promedio_Mensual = mean(CV, na.rm = TRUE)) %>%
  mutate(
    Hay_Estacionalidad = ifelse(CV_Promedio_Mensual >= 0.3, "Sí", "No")
  ) %>%
  arrange(desc(CV_Promedio_Mensual))

print(estacionalidad_mensual)

## # A tibble: 5 × 3
##   ID_Inventario CV_Promedio_Mensual Hay_Estacionalidad
##           <dbl>               <dbl> <chr>             
## 1       3678055               0.260 No                
## 2        155002               0.249 No                
## 3       3929788               0.205 No                
## 4       3904152               0.181 No                
## 5        155001               0.172 No

4.2 VISUALIZACIÓN DE ESTACIONALIDAD

# Paso 1: Asegurar formato de fecha
datos$Trx_Fecha <- as.Date(datos$Trx_Fecha)

# Paso 2: Crear columnas de Año y Mes
datos <- datos %>%
  mutate(
    Anio = isoyear(Trx_Fecha),
    Mes = month(Trx_Fecha)
  )

# Paso 3: Agregar ventas por producto, año y mes
datos_agregados <- datos %>%
  group_by(ID_Inventario, Anio, Mes) %>%
  summarise(Venta_Mensual = sum(Venta, na.rm = TRUE), .groups = 'drop')

# Paso 4: Generar gráficas por producto con colores personalizados
graficas <- datos_agregados %>%
  group_split(ID_Inventario) %>%
  lapply(function(df_prod) {
    ggplot(df_prod, aes(x = Mes, y = Venta_Mensual, color = as.factor(Anio))) +
      geom_line(size = 1.2) +
      scale_color_manual(
        values = c(
          "2023" = "#68838B",  # Azul grisáceo
          "2024" = "#FF69B4"   # Rosa fuerte
        )
      ) +
      labs(
        title = paste("Estacionalidad Mensual - Producto", unique(df_prod$ID_Inventario)),
        x = "Mes",
        y = "Venta Mensual",
        color = "Año"
      ) +
      theme_minimal(base_size = 13) +
      theme(
        plot.title = element_text(face = "bold"),
        legend.position = "bottom"
      )
  })

# Paso 5: Mostrar una gráfica como prueba
print(graficas[[1]])

print(graficas[[2]])

print(graficas[[3]])

print(graficas[[4]])

print(graficas[[5]])

5 PREDICCIONES DE VENTAS

6 ARMA

6.1 PRODUCTO 155001

6.1.1 TRAIN

# Producto 155001
id_prod <- 155001

# Asegurarse de que metricas_comparativas esté inicializada
if (!exists("metricas_comparativas")) {
  metricas_comparativas <- data.frame(
    Producto = character(),
    Modelo = character(),
    MAPE = numeric(),
    RMSE = numeric(),
    stringsAsFactors = FALSE
  )
}

# Filtrar datos del producto (ya están agregados por semana)
ventas_semanales <- datos_filtrados %>%
  filter(ID_Inventario == id_prod) %>%
  arrange(Trx_Fecha) %>%
  select(Trx_Fecha, Venta)

# Crear serie temporal semanal
serie_ts <- ts(ventas_semanales$Venta, frequency = 52,
               start = c(year(min(ventas_semanales$Trx_Fecha)),
                         isoweek(min(ventas_semanales$Trx_Fecha))))

# Ajustar modelo ARMA
modelo_arma_155001 <- auto.arima(serie_ts, seasonal = FALSE, stepwise = FALSE, approximation = FALSE)
forecast_modelo_arma_155001 <- forecast(modelo_arma_155001, h = 4)

# Gráfico del pronóstico
autoplot(forecast_modelo_arma_155001) +
  labs(title = paste("Pronóstico semanal de ventas - ARMA (Producto", id_prod, ")"),
       x = "Semana", y = "Ventas ($)") +
  theme_minimal()

# Calcular métricas de desempeño
fitted_arma_155001 <- fitted(modelo_arma_155001)
mape_arma_155001 <- mean(abs((serie_ts - fitted_arma_155001) / pmax(serie_ts, 0.01))) * 100
rmse_arma_155001 <- sqrt(mean((serie_ts - fitted_arma_155001)^2))

# Registrar en tabla general de métricas
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = id_prod,
  Modelo = "ARMA",
  MAPE = mape_arma_155001,
  RMSE = rmse_arma_155001
))

6.1.2 TEST

# Crear conjunto de prueba para producto 155001 (solo columnas necesarias para ARMA)
test_155001 <- test %>%
  filter(ID_Inventario == 155001) %>%
  select(Semana, Venta) %>%
  arrange(Semana) %>%
  na.omit()

# Evaluar ARMA contra datos reales del test (primeras 4 semanas del test)
ventas_reales_test_155001 <- test_155001 %>%
  slice_head(n = 4) %>%
  pull(Venta)

ventas_predichas_arma_155001 <- as.numeric(forecast_modelo_arma_155001$mean)

# Comparar solo si hay 4 semanas disponibles
if (length(ventas_reales_test_155001) == length(ventas_predichas_arma_155001)) {
  
  mape_arma_test_155001 <- mean(abs((ventas_reales_test_155001 - ventas_predichas_arma_155001) /
                                      pmax(ventas_reales_test_155001, 0.01))) * 100
  
  rmse_arma_test_155001 <- sqrt(mean((ventas_reales_test_155001 - ventas_predichas_arma_155001)^2))
  
  cat("MAPE ARMA (test - producto 155001):", round(mape_arma_test_155001, 2), "\n")
  cat("RMSE ARMA (test - producto 155001):", round(rmse_arma_test_155001, 2), "\n")
  
  # Guardar en tabla de métricas
  metricas_comparativas <- rbind(metricas_comparativas, data.frame(
    Producto = id_prod,
    Modelo = "ARMA (Test)",
    MAPE = mape_arma_test_155001,
    RMSE = rmse_arma_test_155001
  ))
  
} else {
  warning("No hay suficientes semanas en el test para comparar con el forecast de ARMA.")
}

## MAPE ARMA (test - producto 155001): 25.14 
## RMSE ARMA (test - producto 155001): 67277.26

6.2 PRODUCTO 3929788

6.2.1 TRAIN

# Producto 3929788
id_prod <- 3929788

# Filtrar datos del producto
ventas_semanales <- datos_filtrados %>%
  filter(ID_Inventario == id_prod) %>%
  arrange(Trx_Fecha) %>%
  select(Trx_Fecha, Venta)

# Crear serie temporal semanal
serie_ts <- ts(ventas_semanales$Venta, frequency = 52,
               start = c(year(min(ventas_semanales$Trx_Fecha)),
                         isoweek(min(ventas_semanales$Trx_Fecha))))

# Ajustar modelo ARMA
modelo_arma_3929788 <- auto.arima(serie_ts, seasonal = FALSE, stepwise = FALSE, approximation = FALSE)
forecast_modelo_arma_3929788 <- forecast(modelo_arma_3929788, h = 4)

# Gráfico del pronóstico
autoplot(forecast_modelo_arma_3929788) +
  labs(title = paste("Pronóstico semanal de ventas - ARMA (Producto", id_prod, ")"),
       x = "Semana", y = "Ventas ($)") +
  theme_minimal()

# Calcular métricas
fitted_arma_3929788 <- fitted(modelo_arma_3929788)
mape_arma_3929788 <- mean(abs((serie_ts - fitted_arma_3929788) / pmax(serie_ts, 0.01))) * 100
rmse_arma_3929788 <- sqrt(mean((serie_ts - fitted_arma_3929788)^2))

# Registrar métricas en la tabla general
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = id_prod,
  Modelo = "ARMA",
  MAPE = mape_arma_3929788,
  RMSE = rmse_arma_3929788
))

6.2.2 TEST

# Crear conjunto de prueba para producto 155001 (solo columnas necesarias para ARMA)
test_3929788 <- test %>%
  filter(ID_Inventario == 3929788) %>%
  select(Semana, Venta) %>%
  arrange(Semana) %>%
  na.omit()

# Evaluar ARMA contra datos reales del test (primeras 4 semanas del test)
ventas_reales_test_3929788 <- test_3929788 %>%
  slice_head(n = 4) %>%
  pull(Venta)

ventas_predichas_arma_3929788 <- as.numeric(forecast_modelo_arma_3929788$mean)

# Comparar solo si hay 4 semanas disponibles
if (length(ventas_reales_test_3929788) == length(ventas_predichas_arma_3929788)) {
  
  mape_arma_test_3929788 <- mean(abs((ventas_reales_test_3929788 - ventas_predichas_arma_3929788) /
                                      pmax(ventas_reales_test_3929788, 0.01))) * 100
  
  rmse_arma_test_3929788 <- sqrt(mean((ventas_reales_test_3929788 - ventas_predichas_arma_3929788)^2))
  
  cat("MAPE ARMA (test - producto 3929788):", round(mape_arma_test_3929788, 2), "\n")
  cat("RMSE ARMA (test - producto 3929788):", round(rmse_arma_test_3929788, 2), "\n")
  
  # Guardar en tabla de métricas
  metricas_comparativas <- rbind(metricas_comparativas, data.frame(
    Producto = id_prod,
    Modelo = "ARMA (Test)",
    MAPE = mape_arma_test_3929788,
    RMSE = rmse_arma_test_3929788
  ))
  
} else {
  warning("No hay suficientes semanas en el test para comparar con el forecast de ARMA.")
}

## MAPE ARMA (test - producto 3929788): 26.26 
## RMSE ARMA (test - producto 3929788): 60053.08

6.3 PRODUCTO 3904152

6.3.1 TRAIN

# Producto 3904152
id_prod <- 3904152

# Filtrar datos del producto
ventas_semanales <- datos_filtrados %>%
  filter(ID_Inventario == id_prod) %>%
  arrange(Trx_Fecha) %>%
  select(Trx_Fecha, Venta)

# Crear serie temporal semanal
serie_ts <- ts(ventas_semanales$Venta, frequency = 52,
               start = c(year(min(ventas_semanales$Trx_Fecha)),
                         isoweek(min(ventas_semanales$Trx_Fecha))))

# Ajustar modelo ARMA
modelo_arma_3904152 <- auto.arima(serie_ts, seasonal = FALSE, stepwise = FALSE, approximation = FALSE)
forecast_modelo_arma_3904152 <- forecast(modelo_arma_3904152, h = 4)

# Gráfico del pronóstico
autoplot(forecast_modelo_arma_3904152) +
  labs(title = paste("Pronóstico semanal de ventas - ARMA (Producto", id_prod, ")"),
       x = "Semana", y = "Ventas ($)") +
  theme_minimal()

# Calcular métricas
fitted_arma_3904152 <- fitted(modelo_arma_3904152)
mape_arma_3904152 <- mean(abs((serie_ts - fitted_arma_3904152) / pmax(serie_ts, 0.01))) * 100
rmse_arma_3904152 <- sqrt(mean((serie_ts - fitted_arma_3904152)^2))

# Registrar métricas en la tabla general
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = id_prod,
  Modelo = "ARMA",
  MAPE = mape_arma_3904152,
  RMSE = rmse_arma_3904152
))

6.3.2 TEST

# Crear conjunto de prueba para producto 155001 (solo columnas necesarias para ARMA)
test_3904152 <- test %>%
  filter(ID_Inventario == 3904152) %>%
  select(Semana, Venta) %>%
  arrange(Semana) %>%
  na.omit()

# Evaluar ARMA contra datos reales del test (primeras 4 semanas del test)
ventas_reales_test_3904152 <- test_3904152 %>%
  slice_head(n = 4) %>%
  pull(Venta)

ventas_predichas_arma_3904152 <- as.numeric(forecast_modelo_arma_3904152$mean)

# Comparar solo si hay 4 semanas disponibles
if (length(ventas_reales_test_3904152) == length(ventas_predichas_arma_3904152)) {
  
  mape_arma_test_3904152 <- mean(abs((ventas_reales_test_3904152 - ventas_predichas_arma_3904152) /
                                      pmax(ventas_reales_test_3904152, 0.01))) * 100
  
  rmse_arma_test_3904152 <- sqrt(mean((ventas_reales_test_3904152 - ventas_predichas_arma_3904152)^2))
  
  cat("MAPE ARMA (test - producto 3904152):", round(mape_arma_test_3904152, 2), "\n")
  cat("RMSE ARMA (test - producto 3904152):", round(rmse_arma_test_3904152, 2), "\n")
  
  # Guardar en tabla de métricas
  metricas_comparativas <- rbind(metricas_comparativas, data.frame(
    Producto = id_prod,
    Modelo = "ARMA (Test)",
    MAPE = mape_arma_test_3904152,
    RMSE = rmse_arma_test_3904152
  ))
  
} else {
  warning("No hay suficientes semanas en el test para comparar con el forecast de ARMA.")
}

## MAPE ARMA (test - producto 3904152): 18.71 
## RMSE ARMA (test - producto 3904152): 50062.24

6.4 PRODUCTO 155002

6.4.1 TRAIN

# Producto 155002
id_prod <- 155002

# Filtrar datos del producto
ventas_semanales <- datos_filtrados %>%
  filter(ID_Inventario == id_prod) %>%
  arrange(Trx_Fecha) %>%
  select(Trx_Fecha, Venta)

# Crear serie temporal semanal
serie_ts <- ts(ventas_semanales$Venta, frequency = 52,
               start = c(year(min(ventas_semanales$Trx_Fecha)),
                         isoweek(min(ventas_semanales$Trx_Fecha))))

# Ajustar modelo ARMA
modelo_arma_155002 <- auto.arima(serie_ts, seasonal = FALSE, stepwise = FALSE, approximation = FALSE)
forecast_modelo_arma_155002 <- forecast(modelo_arma_155002, h = 4)

# Gráfico del pronóstico
autoplot(forecast_modelo_arma_155002) +
  labs(title = paste("Pronóstico semanal de ventas - ARMA (Producto", id_prod, ")"),
       x = "Semana", y = "Ventas ($)") +
  theme_minimal()

# Calcular métricas
fitted_arma_155002 <- fitted(modelo_arma_155002)
mape_arma_155002 <- mean(abs((serie_ts - fitted_arma_155002) / pmax(serie_ts, 0.01))) * 100
rmse_arma_155002 <- sqrt(mean((serie_ts - fitted_arma_155002)^2))

# Registrar métricas en la tabla general
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = id_prod,
  Modelo = "ARMA",
  MAPE = mape_arma_155002,
  RMSE = rmse_arma_155002
))

6.4.2 TEST

# Crear conjunto de prueba para producto 155001 (solo columnas necesarias para ARMA)
test_155002 <- test %>%
  filter(ID_Inventario == 155002) %>%
  select(Semana, Venta) %>%
  arrange(Semana) %>%
  na.omit()

# Evaluar ARMA contra datos reales del test (primeras 4 semanas del test)
ventas_reales_test_155002 <- test_155002 %>%
  slice_head(n = 4) %>%
  pull(Venta)

ventas_predichas_arma_155002 <- as.numeric(forecast_modelo_arma_155002$mean)

# Comparar solo si hay 4 semanas disponibles
if (length(ventas_reales_test_155002) == length(ventas_predichas_arma_155002)) {
  
  mape_arma_test_155002 <- mean(abs((ventas_reales_test_155002 - ventas_predichas_arma_155002) /
                                      pmax(ventas_reales_test_155002, 0.01))) * 100
  
  rmse_arma_test_155002 <- sqrt(mean((ventas_reales_test_155002 - ventas_predichas_arma_155002)^2))
  
  cat("MAPE ARMA (test - producto 155002):", round(mape_arma_test_155002, 2), "\n")
  cat("RMSE ARMA (test - producto 155002):", round(rmse_arma_test_155002, 2), "\n")
  
  # Guardar en tabla de métricas
  metricas_comparativas <- rbind(metricas_comparativas, data.frame(
    Producto = id_prod,
    Modelo = "ARMA (Test)",
    MAPE = mape_arma_test_155002,
    RMSE = rmse_arma_test_155002
  ))
  
} else {
  warning("No hay suficientes semanas en el test para comparar con el forecast de ARMA.")
}

## MAPE ARMA (test - producto 155002): 35.87 
## RMSE ARMA (test - producto 155002): 87005.41

6.5 PRODUCTO 3678055

6.5.1 TRAIN

# Producto 3678055
id_prod <- 3678055

# Filtrar datos del producto
ventas_semanales <- datos_filtrados %>%
  filter(ID_Inventario == id_prod) %>%
  arrange(Trx_Fecha) %>%
  select(Trx_Fecha, Venta)

# Crear serie temporal semanal
serie_ts <- ts(ventas_semanales$Venta, frequency = 52,
               start = c(year(min(ventas_semanales$Trx_Fecha)),
                         isoweek(min(ventas_semanales$Trx_Fecha))))

# Ajustar modelo ARMA
modelo_arma_3678055 <- auto.arima(serie_ts, seasonal = FALSE, stepwise = FALSE, approximation = FALSE)
forecast_modelo_arma_3678055 <- forecast(modelo_arma_3678055, h = 4)

# Gráfico del pronóstico
autoplot(forecast_modelo_arma_3678055) +
  labs(title = paste("Pronóstico semanal de ventas - ARMA (Producto", id_prod, ")"),
       x = "Semana", y = "Ventas ($)") +
  theme_minimal()

# Calcular métricas
fitted_arma_3678055 <- fitted(modelo_arma_3678055)
mape_arma_3678055 <- mean(abs((serie_ts - fitted_arma_3678055) / pmax(serie_ts, 0.01))) * 100
rmse_arma_3678055 <- sqrt(mean((serie_ts - fitted_arma_3678055)^2))

# Registrar métricas en la tabla general
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = id_prod,
  Modelo = "ARMA",
  MAPE = mape_arma_3678055,
  RMSE = rmse_arma_3678055
))

6.5.2 TEST

# Crear conjunto de prueba para producto 155001 (solo columnas necesarias para ARMA)
test_3678055 <- test %>%
  filter(ID_Inventario == 3678055) %>%
  select(Semana, Venta) %>%
  arrange(Semana) %>%
  na.omit()

# Evaluar ARMA contra datos reales del test (primeras 4 semanas del test)
ventas_reales_test_3678055 <- test_3678055 %>%
  slice_head(n = 4) %>%
  pull(Venta)

ventas_predichas_arma_3678055 <- as.numeric(forecast_modelo_arma_3678055$mean)

# Comparar solo si hay 4 semanas disponibles
if (length(ventas_reales_test_3678055) == length(ventas_predichas_arma_3678055)) {
  
  mape_arma_test_3678055 <- mean(abs((ventas_reales_test_3678055 - ventas_predichas_arma_3678055) /
                                      pmax(ventas_reales_test_3678055, 0.01))) * 100
  
  rmse_arma_test_3678055 <- sqrt(mean((ventas_reales_test_3678055 - ventas_predichas_arma_3678055)^2))
  
  cat("MAPE ARMA (test - producto 3678055):", round(mape_arma_test_3678055, 2), "\n")
  cat("RMSE ARMA (test - producto 3678055):", round(rmse_arma_test_3678055, 2), "\n")
  
  # Guardar en tabla de métricas
  metricas_comparativas <- rbind(metricas_comparativas, data.frame(
    Producto = id_prod,
    Modelo = "ARMA (Test)",
    MAPE = mape_arma_test_3678055,
    RMSE = rmse_arma_test_3678055
  ))
  
} else {
  warning("No hay suficientes semanas en el test para comparar con el forecast de ARMA.")
}

## MAPE ARMA (test - producto 3678055): 53.78 
## RMSE ARMA (test - producto 3678055): 105823.1

6.6 MÉTRICAS COMPARATIVAS ARMA

metricas_comparativas %>%
  arrange(Producto) %>%
  knitr::kable(caption = "Métricas ARMA por producto") %>%
  kableExtra::kable_styling(full_width = FALSE)

Métricas ARMA por producto

Producto	Modelo	MAPE	RMSE
155001	ARMA	37.96077	109593.78
155001	ARMA (Test)	25.14259	67277.26
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08

7 REGRESION LINEAL

7.1 MAPA DE CALOR

# Variables numéricas relevantes para el modelo
vars_numericas <- c("Venta", 
                    "Precio_Final_Unitario", 
                    "Venta_Semana_Anterior",
                    "Cant_Semana_Anterior", 
                    "Descuento_Semana_Anterior",
                    "Costo_Unitario_Semana_Anterior")

# Preparación de los datos
datos_cor <- datos_filtrados %>%
  select(all_of(vars_numericas)) %>%
  na.omit()

# Generar la matriz de correlación
matriz_cor <- cor(datos_cor)

# Mapa de calor de correlaciones
ggcorrplot(matriz_cor,
           method = "square",
           type = "upper",
           lab = TRUE,
           lab_size = 2,
           tl.cex = 10,
           tl.srt = 45,
           colors = c("#6D9EC1", "white", "#E46726"),
           title = "Mapa de Correlación - Variables del Modelo",
           ggtheme = theme_minimal(base_size = 14) +
             theme(
               axis.text.x = element_text(angle = 45, hjust = 1),
               axis.text.y = element_text(angle = 0, hjust = 1))
)

7.2 PRODUCTO 155001

7.2.1 DATOS TRAIN 155001

# Datos de entrenamiento
datos_155001 <- datos_filtrados %>%
  filter(ID_Inventario == 155001) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.2.2 DATOS TEST 155001

test_155001 <- test %>%
  filter(ID_Inventario == 155001) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.2.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_155001 <- lm(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_155001
)

# Ver resumen
summary(modelo_regresion_155001)

## 
## Call:
## lm(formula = Venta ~ Precio_Final_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_155001)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -159293  -67596  -17673   54324  500965 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)  
## (Intercept)                     2.560e+06  2.305e+06   1.111    0.270  
## Precio_Final_Unitario           3.382e+02  6.551e+02   0.516    0.607  
## Venta_Semana_Anterior           9.614e-01  8.326e-01   1.155    0.252  
## Cant_Semana_Anterior           -3.751e+02  3.254e+02  -1.153    0.252  
## Descuento_Semana_Anterior      -2.475e+06  2.427e+06  -1.020    0.311  
## Costo_Unitario_Semana_Anterior -9.635e+02  5.250e+02  -1.835    0.070 .
## Semana                          1.870e+03  1.276e+03   1.465    0.147  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 116000 on 84 degrees of freedom
## Multiple R-squared:  0.06998,    Adjusted R-squared:  0.003546 
## F-statistic: 1.053 on 6 and 84 DF,  p-value: 0.3972

# Predicciones
pred_train <- predict(modelo_regresion_155001, newdata = datos_155001)
pred_test  <- predict(modelo_regresion_155001, newdata = test_155001)

# Métricas - entrenamiento
mape_train <- mean(abs((datos_155001$Venta - pred_train) / pmax(datos_155001$Venta, 0.01))) * 100
rmse_train <- sqrt(mean((datos_155001$Venta - pred_train)^2))

# Métricas - prueba
mape_test <- mean(abs((test_155001$Venta - pred_test) / pmax(test_155001$Venta, 0.01))) * 100
rmse_test <- sqrt(mean((test_155001$Venta - pred_test)^2))

# Mostrar resultados
cat("Train - MAPE:", round(mape_train, 2), "| RMSE:", round(rmse_train, 2), "\n")

## Train - MAPE: 39.93 | RMSE: 111408.3

cat("Test  - MAPE:", round(mape_test, 2), "| RMSE:", round(rmse_test, 2), "\n")

## Test  - MAPE: 89.84 | RMSE: 157598.3

7.2.4 TABLA DE MÉTRICAS

# Agregar métricas del entrenamiento
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "Regresión Lineal (Train)",
  MAPE = mape_train,
  RMSE = rmse_train,
  stringsAsFactors = FALSE
))

# Agregar métricas del test
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "Regresión Lineal (Test)",
  MAPE = mape_test,
  RMSE = rmse_test,
  stringsAsFactors = FALSE
))

7.3 PRODUCTO 3929788

7.3.1 DATOS TRAIN

#Datos de entrenamiento
datos_3929788 <- datos_filtrados %>%
  filter(ID_Inventario == 3929788) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.3.2 DATOS TEST

# Datos de prueba
test_3929788 <- test %>%
  filter(ID_Inventario == 3929788) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.3.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3929788 <- lm(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3929788
)

# Ver resumen
summary(modelo_regresion_3929788)

## 
## Call:
## lm(formula = Venta ~ Precio_Final_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3929788)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -103757  -32434   -2506   31479  190600 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)  
## (Intercept)                    -1.151e+06  5.390e+05  -2.136   0.0356 *
## Precio_Final_Unitario           1.167e+04  6.397e+03   1.824   0.0717 .
## Venta_Semana_Anterior          -9.155e-01  1.056e+00  -0.867   0.3886  
## Cant_Semana_Anterior            2.698e+01  3.946e+01   0.684   0.4960  
## Descuento_Semana_Anterior       1.073e+06  7.733e+05   1.387   0.1691  
## Costo_Unitario_Semana_Anterior  9.620e+03  9.973e+03   0.965   0.3375  
## Semana                         -1.191e+01  4.929e+02  -0.024   0.9808  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 56120 on 84 degrees of freedom
## Multiple R-squared:  0.2373, Adjusted R-squared:  0.1828 
## F-statistic: 4.356 on 6 and 84 DF,  p-value: 0.0007082

# Predicciones
pred_train_3929788 <- predict(modelo_regresion_3929788, newdata = datos_3929788)
pred_test_3929788  <- predict(modelo_regresion_3929788, newdata = test_3929788)

# Métricas - entrenamiento
mape_train_3929788 <- mean(abs((datos_3929788$Venta - pred_train_3929788) / pmax(datos_3929788$Venta, 0.01))) * 100
rmse_train_3929788 <- sqrt(mean((datos_3929788$Venta - pred_train_3929788)^2))

# Métricas - prueba
mape_test_3929788 <- mean(abs((test_3929788$Venta - pred_test_3929788) / pmax(test_3929788$Venta, 0.01))) * 100
rmse_test_3929788 <- sqrt(mean((test_3929788$Venta - pred_test_3929788)^2))

# Mostrar resultados
cat("Train - MAPE:", round(mape_train_3929788, 2), "| RMSE:", round(rmse_train_3929788, 2), "\n")

## Train - MAPE: 20.53 | RMSE: 53920.09

cat("Test  - MAPE:", round(mape_test_3929788, 2), "| RMSE:", round(rmse_test_3929788, 2), "\n")

## Test  - MAPE: 34.22 | RMSE: 68189.37

7.3.4 TABLA DE MÉTRICAS

# Agregar métricas del entrenamiento
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "Regresión Lineal (Train)",
  MAPE = mape_train_3929788,
  RMSE = rmse_train_3929788,
  stringsAsFactors = FALSE
))

# Agregar métricas del test
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "Regresión Lineal (Test)",
  MAPE = mape_test_3929788,
  RMSE = rmse_test_3929788,
  stringsAsFactors = FALSE
))

7.4 PRODUCTO 3904152

7.4.1 DATOS TRAIN

# Datos de entrenamiento
datos_3904152 <- datos_filtrados %>%
  filter(ID_Inventario == 3904152) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.4.2 DATOS TEST

# Datos de prueba
test_3904152 <- test %>%
  filter(ID_Inventario == 3904152) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.4.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3904152 <- lm(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3904152
)

# Ver resumen
summary(modelo_regresion_3904152)

## 
## Call:
## lm(formula = Venta ~ Precio_Final_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3904152)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -131990  -54677  -29793   30625  529564 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                    -1.249e+06  2.207e+06  -0.566    0.573
## Precio_Final_Unitario          -3.568e+02  2.237e+02  -1.595    0.114
## Venta_Semana_Anterior           1.096e+00  2.348e+00   0.467    0.642
## Cant_Semana_Anterior           -3.747e+03  7.155e+03  -0.524    0.602
## Descuento_Semana_Anterior       7.452e+05  2.389e+06   0.312    0.756
## Costo_Unitario_Semana_Anterior  8.577e+02  5.544e+02   1.547    0.126
## Semana                          1.395e+03  9.821e+02   1.420    0.159
## 
## Residual standard error: 108400 on 84 degrees of freedom
## Multiple R-squared:  0.06031,    Adjusted R-squared:  -0.006815 
## F-statistic: 0.8985 on 6 and 84 DF,  p-value: 0.5001

# Predicciones
pred_train_3904152 <- predict(modelo_regresion_3904152, newdata = datos_3904152)
pred_test_3904152  <- predict(modelo_regresion_3904152, newdata = test_3904152)

# Métricas - entrenamiento
mape_train_3904152 <- mean(abs((datos_3904152$Venta - pred_train_3904152) / pmax(datos_3904152$Venta, 0.01))) * 100
rmse_train_3904152 <- sqrt(mean((datos_3904152$Venta - pred_train_3904152)^2))

# Métricas - prueba
mape_test_3904152 <- mean(abs((test_3904152$Venta - pred_test_3904152) / pmax(test_3904152$Venta, 0.01))) * 100
rmse_test_3904152 <- sqrt(mean((test_3904152$Venta - pred_test_3904152)^2))

# Mostrar resultados
cat("Train - MAPE:", round(mape_train_3904152, 2), "| RMSE:", round(rmse_train_3904152, 2), "\n")

## Train - MAPE: 38.99 | RMSE: 104128.9

cat("Test  - MAPE:", round(mape_test_3904152, 2), "| RMSE:", round(rmse_test_3904152, 2), "\n")

## Test  - MAPE: 196.4 | RMSE: 209230

7.4.4 TABLA DE MÉTRICAS

# Agregar métricas del entrenamiento
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "Regresión Lineal (Train)",
  MAPE = mape_train_3904152,
  RMSE = rmse_train_3904152,
  stringsAsFactors = FALSE
))

# Agregar métricas del test
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "Regresión Lineal (Test)",
  MAPE = mape_test_3904152,
  RMSE = rmse_test_3904152,
  stringsAsFactors = FALSE
))

7.5 PRODUCTO 155002

7.5.1 DATOS TRAIN

# Datos de entrenamiento
datos_155002 <- datos_filtrados %>%
  filter(ID_Inventario == 155002) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.5.2 DATOS TEST

# Datos de prueba
test_155002 <- test %>%
  filter(ID_Inventario == 155002) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.5.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_155002 <- lm(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_155002
)

# Ver resumen
summary(modelo_regresion_155002)

## 
## Call:
## lm(formula = Venta ~ Precio_Final_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_155002)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -133199  -55557  -19787   38873  301369 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                     1.823e+06  1.367e+06   1.334    0.186
## Precio_Final_Unitario          -3.923e+02  3.849e+02  -1.019    0.311
## Venta_Semana_Anterior           1.082e+00  7.425e-01   1.457    0.149
## Cant_Semana_Anterior           -3.451e+02  3.021e+02  -1.142    0.257
## Descuento_Semana_Anterior      -1.732e+06  1.443e+06  -1.201    0.233
## Costo_Unitario_Semana_Anterior -6.269e+01  1.928e+02  -0.325    0.746
## Semana                          1.019e+03  7.571e+02   1.346    0.182
## 
## Residual standard error: 84990 on 84 degrees of freedom
## Multiple R-squared:  0.09845,    Adjusted R-squared:  0.03405 
## F-statistic: 1.529 on 6 and 84 DF,  p-value: 0.1787

# Predicciones
pred_train_155002 <- predict(modelo_regresion_155002, newdata = datos_155002)
pred_test_155002  <- predict(modelo_regresion_155002, newdata = test_155002)

# Métricas - entrenamiento
mape_train_155002 <- mean(abs((datos_155002$Venta - pred_train_155002) / pmax(datos_155002$Venta, 0.01))) * 100
rmse_train_155002 <- sqrt(mean((datos_155002$Venta - pred_train_155002)^2))

# Métricas - prueba
mape_test_155002 <- mean(abs((test_155002$Venta - pred_test_155002) / pmax(test_155002$Venta, 0.01))) * 100
rmse_test_155002 <- sqrt(mean((test_155002$Venta - pred_test_155002)^2))

# Mostrar resultados
cat("Train - MAPE:", round(mape_train_155002, 2), "| RMSE:", round(rmse_train_155002, 2), "\n")

## Train - MAPE: 53.31 | RMSE: 81659.41

cat("Test  - MAPE:", round(mape_test_155002, 2), "| RMSE:", round(rmse_test_155002, 2), "\n")

## Test  - MAPE: 113.63 | RMSE: 140462

7.5.4 TABLA DE MÉTRICAS

# Agregar métricas del entrenamiento
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "Regresión Lineal (Train)",
  MAPE = mape_train_155002,
  RMSE = rmse_train_155002,
  stringsAsFactors = FALSE
))

# Agregar métricas del test
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "Regresión Lineal (Test)",
  MAPE = mape_test_155002,
  RMSE = rmse_test_155002,
  stringsAsFactors = FALSE
))

7.6 PRODUCTO 3678055

7.6.1 DATOS TRAIN

# Datos de entrenamiento
datos_3678055 <- datos_filtrados %>%
  filter(ID_Inventario == 3678055) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.6.2 DATOS TEST

# Datos de prueba
test_3678055 <- test %>%
  filter(ID_Inventario == 3678055) %>%
  select(Venta, Precio_Final_Unitario, Venta_Semana_Anterior,
         Cant_Semana_Anterior, Descuento_Semana_Anterior,
         Costo_Unitario_Semana_Anterior, Semana) %>%
  na.omit()

7.6.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3678055 <- lm(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3678055
)

# Ver resumen
summary(modelo_regresion_3678055)

## 
## Call:
## lm(formula = Venta ~ Precio_Final_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3678055)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -122909  -51648  -12067   27968  366814 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                     1.226e+06  1.506e+06   0.814    0.418
## Precio_Final_Unitario          -1.974e+01  9.930e+01  -0.199    0.843
## Venta_Semana_Anterior          -7.800e-01  1.962e+00  -0.398    0.692
## Cant_Semana_Anterior            4.280e+03  1.005e+04   0.426    0.671
## Descuento_Semana_Anterior      -1.270e+06  1.616e+06  -0.786    0.434
## Costo_Unitario_Semana_Anterior -3.479e+01  2.174e+02  -0.160    0.873
## Semana                         -2.750e+01  5.980e+02  -0.046    0.963
## 
## Residual standard error: 85860 on 84 degrees of freedom
## Multiple R-squared:  0.01226,    Adjusted R-squared:  -0.0583 
## F-statistic: 0.1737 on 6 and 84 DF,  p-value: 0.9832

# Predicciones
pred_train_3678055 <- predict(modelo_regresion_3678055, newdata = datos_3678055)
pred_test_3678055  <- predict(modelo_regresion_3678055, newdata = test_3678055)

# Métricas - entrenamiento
mape_train_3678055 <- mean(abs((datos_3678055$Venta - pred_train_3678055) / pmax(datos_3678055$Venta, 0.01))) * 100
rmse_train_3678055 <- sqrt(mean((datos_3678055$Venta - pred_train_3678055)^2))

# Métricas - prueba
mape_test_3678055 <- mean(abs((test_3678055$Venta - pred_test_3678055) / pmax(test_3678055$Venta, 0.01))) * 100
rmse_test_3678055 <- sqrt(mean((test_3678055$Venta - pred_test_3678055)^2))

# Mostrar resultados
cat("Train - MAPE:", round(mape_train_3678055, 2), "| RMSE:", round(rmse_train_3678055, 2), "\n")

## Train - MAPE: 54.29 | RMSE: 82493.59

cat("Test  - MAPE:", round(mape_test_3678055, 2), "| RMSE:", round(rmse_test_3678055, 2), "\n")

## Test  - MAPE: 35.23 | RMSE: 125404.3

7.6.4 TABLA DE MÉTRICAS

# Agregar métricas del entrenamiento
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "Regresión Lineal (Train)",
  MAPE = mape_train_3678055,
  RMSE = rmse_train_3678055,
  stringsAsFactors = FALSE
))

# Agregar métricas del test
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "Regresión Lineal (Test)",
  MAPE = mape_test_3678055,
  RMSE = rmse_test_3678055,
  stringsAsFactors = FALSE
))

7.7 MÉTRICAS ARMA Y REG LINEAL

metricas_comparativas %>%
  arrange(Producto) %>%
  knitr::kable(caption = "Métricas ARMA & Regresion Lineal por producto") %>%
  kableExtra::kable_styling(full_width = FALSE)

Métricas ARMA & Regresion Lineal por producto

Producto	Modelo	MAPE	RMSE
155001	ARMA	37.96077	109593.78
155001	ARMA (Test)	25.14259	67277.26
155001	Regresión Lineal (Train)	39.93493	111408.28
155001	Regresión Lineal (Test)	89.83537	157598.32
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
155002	Regresión Lineal (Train)	53.30857	81659.41
155002	Regresión Lineal (Test)	113.63421	140462.00
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3678055	Regresión Lineal (Train)	54.28565	82493.59
3678055	Regresión Lineal (Test)	35.22903	125404.28
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3904152	Regresión Lineal (Train)	38.98555	104128.86
3904152	Regresión Lineal (Test)	196.40268	209230.00
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08
3929788	Regresión Lineal (Train)	20.52872	53920.09
3929788	Regresión Lineal (Test)	34.22277	68189.37

8 RANDOM FOREST

8.1 PRODUCTO 155001

# Entrenamiento
set.seed(123)
modelo_rf_155001 <- randomForest(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_155001,
  ntree = 500,
  mtry = floor(sqrt(6)),  # 6 variables predictoras
  importance = TRUE
)

# Predicciones
pred_train_rf_155001 <- predict(modelo_rf_155001, newdata = datos_155001)
pred_test_rf_155001  <- predict(modelo_rf_155001, newdata = test_155001)

# Métricas
mape_train_rf_155001 <- mean(abs((datos_155001$Venta - pred_train_rf_155001) / pmax(datos_155001$Venta, 0.01))) * 100
rmse_train_rf_155001 <- sqrt(mean((datos_155001$Venta - pred_train_rf_155001)^2))

mape_test_rf_155001 <- mean(abs((test_155001$Venta - pred_test_rf_155001) / pmax(test_155001$Venta, 0.01))) * 100
rmse_test_rf_155001 <- sqrt(mean((test_155001$Venta - pred_test_rf_155001)^2))

# Mostrar resultados
cat("Random Forest - Producto 155001\n")

## Random Forest - Producto 155001

cat("Train - MAPE:", round(mape_train_rf_155001, 2), "| RMSE:", round(rmse_train_rf_155001, 2), "\n")

## Train - MAPE: 18.89 | RMSE: 55005.66

cat("Test  - MAPE:", round(mape_test_rf_155001, 2),  "| RMSE:", round(rmse_test_rf_155001, 2),  "\n")

## Test  - MAPE: 77.18 | RMSE: 138820.6

# Guardar métricas en tabla
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "Random Forest (Train)",
  MAPE = mape_train_rf_155001,
  RMSE = rmse_train_rf_155001
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "Random Forest (Test)",
  MAPE = mape_test_rf_155001,
  RMSE = rmse_test_rf_155001
))

# Importancia de variables
varImpPlot(modelo_rf_155001, main = "Importancia de Variables - Producto 155001")

# Observado vs Predicho (test)
ggplot(data.frame(Observado = test_155001$Venta, Predicho = pred_test_rf_155001),
       aes(x = Observado, y = Predicho)) +
  geom_point(alpha = 0.5) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Observado vs Predicho - Producto 155001 (test data)",
       x = "Venta Observada", y = "Venta Predicha") +
  theme_minimal()

# Análisis de errores (test)
errores_test_155001 <- test_155001$Venta - pred_test_rf_155001
hist(errores_test_155001, main = "Distribución de Errores - Producto 155001 (test data)",
     xlab = "Error (Observado - Predicho)", col = "skyblue", breaks = 30)

cat("Media error:", mean(errores_test_155001), "\n")

## Media error: -69719.5

cat("SD error:", sd(errores_test_155001), "\n")

## SD error: 124944.8

cat("Min error:", min(errores_test_155001), "\n")

## Min error: -207234.7

cat("Max error:", max(errores_test_155001), "\n")

## Max error: 249075.9

cat("Mediana error:", median(errores_test_155001), "\n")

## Mediana error: -108089.3

# Error vs Predicción (test)
ggplot(data.frame(Predicho = pred_test_rf_155001, Error = errores_test_155001),
       aes(x = Predicho, y = Error)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Error vs Predicción - Producto 155001 (test data)",
       x = "Venta Predicha", y = "Error") +
  theme_minimal()

8.2 PRODUCTO 3929788

# Entrenamiento
set.seed(123)
modelo_rf_3929788 <- randomForest(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3929788,
  ntree = 500,
  mtry = floor(sqrt(6)),  # 6 variables predictoras
  importance = TRUE
)

# Predicciones
pred_train_rf_3929788 <- predict(modelo_rf_3929788, newdata = datos_3929788)
pred_test_rf_3929788  <- predict(modelo_rf_3929788, newdata = test_3929788)

# Métricas
mape_train_rf_3929788 <- mean(abs((datos_3929788$Venta - pred_train_rf_3929788) / pmax(datos_3929788$Venta, 0.01))) * 100
rmse_train_rf_3929788 <- sqrt(mean((datos_3929788$Venta - pred_train_rf_3929788)^2))

mape_test_rf_3929788 <- mean(abs((test_3929788$Venta - pred_test_rf_3929788) / pmax(test_3929788$Venta, 0.01))) * 100
rmse_test_rf_3929788 <- sqrt(mean((test_3929788$Venta - pred_test_rf_3929788)^2))

# Mostrar resultados
cat("Random Forest - Producto 3929788\n")

## Random Forest - Producto 3929788

cat("Train - MAPE:", round(mape_train_rf_3929788, 2), "| RMSE:", round(rmse_train_rf_3929788, 2), "\n")

## Train - MAPE: 10.27 | RMSE: 27004.1

cat("Test  - MAPE:", round(mape_test_rf_3929788, 2),  "| RMSE:", round(rmse_test_rf_3929788, 2),  "\n")

## Test  - MAPE: 26.96 | RMSE: 56210.34

# Guardar métricas en tabla
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "Random Forest (Train)",
  MAPE = mape_train_rf_3929788,
  RMSE = rmse_train_rf_3929788
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "Random Forest (Test)",
  MAPE = mape_test_rf_3929788,
  RMSE = rmse_test_rf_3929788
))

# Importancia de variables
varImpPlot(modelo_rf_3929788, main = "Importancia de Variables - Producto 3929788")

# Observado vs Predicho (test)
ggplot(data.frame(Observado = test_3929788$Venta, Predicho = pred_test_rf_3929788),
       aes(x = Observado, y = Predicho)) +
  geom_point(alpha = 0.5) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Observado vs Predicho - Producto 3929788 (test data)",
       x = "Venta Observada", y = "Venta Predicha") +
  theme_minimal()

# Análisis de errores (test)
errores_test_3929788 <- test_3929788$Venta - pred_test_rf_3929788
hist(errores_test_3929788, main = "Distribución de Errores - Producto 3929788 (test data)",
     xlab = "Error (Observado - Predicho)", col = "skyblue", breaks = 30)

cat("Media error:", mean(errores_test_3929788), "\n")

## Media error: -12664.42

cat("SD error:", sd(errores_test_3929788), "\n")

## SD error: 57001.31

cat("Min error:", min(errores_test_3929788), "\n")

## Min error: -96490.54

cat("Max error:", max(errores_test_3929788), "\n")

## Max error: 77535.02

cat("Mediana error:", median(errores_test_3929788), "\n")

## Mediana error: -14091.98

# Error vs Predicción (test)
ggplot(data.frame(Predicho = pred_test_rf_3929788, Error = errores_test_3929788),
       aes(x = Predicho, y = Error)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Error vs Predicción - Producto 3929788 (test data)",
       x = "Venta Predicha", y = "Error") +
  theme_minimal()

8.3 PRODUCTO 3904152

# Entrenamiento
set.seed(123)
modelo_rf_3904152 <- randomForest(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3904152,
  ntree = 500,
  mtry = floor(sqrt(6)),  # 6 variables predictoras
  importance = TRUE
)

# Predicciones
pred_train_rf_3904152 <- predict(modelo_rf_3904152, newdata = datos_3904152)
pred_test_rf_3904152  <- predict(modelo_rf_3904152, newdata = test_3904152)

# Métricas
mape_train_rf_3904152 <- mean(abs((datos_3904152$Venta - pred_train_rf_3904152) / pmax(datos_3904152$Venta, 0.01))) * 100
rmse_train_rf_3904152 <- sqrt(mean((datos_3904152$Venta - pred_train_rf_3904152)^2))

mape_test_rf_3904152 <- mean(abs((test_3904152$Venta - pred_test_rf_3904152) / pmax(test_3904152$Venta, 0.01))) * 100
rmse_test_rf_3904152 <- sqrt(mean((test_3904152$Venta - pred_test_rf_3904152)^2))

# Mostrar resultados
cat("Random Forest - Producto 3904152\n")

## Random Forest - Producto 3904152

cat("Train - MAPE:", round(mape_train_rf_3904152, 2), "| RMSE:", round(rmse_train_rf_3904152, 2), "\n")

## Train - MAPE: 19.28 | RMSE: 53268.65

cat("Test  - MAPE:", round(mape_test_rf_3904152, 2),  "| RMSE:", round(rmse_test_rf_3904152, 2),  "\n")

## Test  - MAPE: 87.56 | RMSE: 101889.8

# Guardar métricas en tabla
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "Random Forest (Train)",
  MAPE = mape_train_rf_3904152,
  RMSE = rmse_train_rf_3904152
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "Random Forest (Test)",
  MAPE = mape_test_rf_3904152,
  RMSE = rmse_test_rf_3904152
))

# Importancia de variables
varImpPlot(modelo_rf_3904152, main = "Importancia de Variables - Producto 3904152")

# Observado vs Predicho (test)
ggplot(data.frame(Observado = test_3904152$Venta, Predicho = pred_test_rf_3904152),
       aes(x = Observado, y = Predicho)) +
  geom_point(alpha = 0.5) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Observado vs Predicho - Producto 3904152 (test data)",
       x = "Venta Observada", y = "Venta Predicha") +
  theme_minimal()

# Análisis de errores (test)
errores_test_3904152 <- test_3904152$Venta - pred_test_rf_3904152
hist(errores_test_3904152, main = "Distribución de Errores - Producto 3904152 (test data)",
     xlab = "Error (Observado - Predicho)", col = "skyblue", breaks = 30)

cat("Media error:", mean(errores_test_3904152), "\n")

## Media error: -59820.25

cat("SD error:", sd(errores_test_3904152), "\n")

## SD error: 85848.66

cat("Min error:", min(errores_test_3904152), "\n")

## Min error: -208194.5

cat("Max error:", max(errores_test_3904152), "\n")

## Max error: 151176.3

cat("Mediana error:", median(errores_test_3904152), "\n")

## Mediana error: -67643.5

# Error vs Predicción (test)
ggplot(data.frame(Predicho = pred_test_rf_3904152, Error = errores_test_3904152),
       aes(x = Predicho, y = Error)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Error vs Predicción - Producto 3904152 (test data)",
       x = "Venta Predicha", y = "Error") +
  theme_minimal()

8.4 PRODUCTO 155002

# Entrenamiento
set.seed(123)
modelo_rf_155002 <- randomForest(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_155002,
  ntree = 500,
  mtry = floor(sqrt(6)),  # 6 variables predictoras
  importance = TRUE
)

# Predicciones
pred_train_rf_155002 <- predict(modelo_rf_155002, newdata = datos_155002)
pred_test_rf_155002  <- predict(modelo_rf_155002, newdata = test_155002)

# Métricas
mape_train_rf_155002 <- mean(abs((datos_155002$Venta - pred_train_rf_155002) / pmax(datos_155002$Venta, 0.01))) * 100
rmse_train_rf_155002 <- sqrt(mean((datos_155002$Venta - pred_train_rf_155002)^2))

mape_test_rf_155002 <- mean(abs((test_155002$Venta - pred_test_rf_155002) / pmax(test_155002$Venta, 0.01))) * 100
rmse_test_rf_155002 <- sqrt(mean((test_155002$Venta - pred_test_rf_155002)^2))

# Mostrar resultados
cat("Random Forest - Producto 155002\n")

## Random Forest - Producto 155002

cat("Train - MAPE:", round(mape_train_rf_155002, 2), "| RMSE:", round(rmse_train_rf_155002, 2), "\n")

## Train - MAPE: 24.91 | RMSE: 40622.51

cat("Test  - MAPE:", round(mape_test_rf_155002, 2),  "| RMSE:", round(rmse_test_rf_155002, 2),  "\n")

## Test  - MAPE: 101.53 | RMSE: 122531.1

# Guardar métricas en tabla
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "Random Forest (Train)",
  MAPE = mape_train_rf_155002,
  RMSE = rmse_train_rf_155002
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "Random Forest (Test)",
  MAPE = mape_test_rf_155002,
  RMSE = rmse_test_rf_155002
))

# Importancia de variables
varImpPlot(modelo_rf_155002, main = "Importancia de Variables - Producto 155002")

# Observado vs Predicho (test)
ggplot(data.frame(Observado = test_155002$Venta, Predicho = pred_test_rf_155002),
       aes(x = Observado, y = Predicho)) +
  geom_point(alpha = 0.5) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Observado vs Predicho - Producto 155002 (test data)",
       x = "Venta Observada", y = "Venta Predicha") +
  theme_minimal()

# Análisis de errores (test)
errores_test_155002 <- test_155002$Venta - pred_test_rf_155002
hist(errores_test_155002, main = "Distribución de Errores - Producto 155002 (test data)",
     xlab = "Error (Observado - Predicho)", col = "skyblue", breaks = 30)

cat("Media error:", mean(errores_test_155002), "\n")

## Media error: -10056.18

cat("SD error:", sd(errores_test_155002), "\n")

## SD error: 127104.2

cat("Min error:", min(errores_test_155002), "\n")

## Min error: -126419.2

cat("Max error:", max(errores_test_155002), "\n")

## Max error: 224898.8

cat("Mediana error:", median(errores_test_155002), "\n")

## Mediana error: -56067.92

# Error vs Predicción (test)
ggplot(data.frame(Predicho = pred_test_rf_155002, Error = errores_test_155002),
       aes(x = Predicho, y = Error)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Error vs Predicción - Producto 155002 (test data)",
       x = "Venta Predicha", y = "Error") +
  theme_minimal()

8.5 PRODUCTO 3678055

# Entrenamiento
set.seed(123)
modelo_rf_3678055 <- randomForest(
  Venta ~ Precio_Final_Unitario +
          Venta_Semana_Anterior +
          Cant_Semana_Anterior +
          Descuento_Semana_Anterior +
          Costo_Unitario_Semana_Anterior +
          Semana,
  data = datos_3678055,
  ntree = 500,
  mtry = floor(sqrt(6)),  # 6 variables predictoras
  importance = TRUE
)

# Predicciones
pred_train_rf_3678055 <- predict(modelo_rf_3678055, newdata = datos_3678055)
pred_test_rf_3678055  <- predict(modelo_rf_3678055, newdata = test_3678055)

# Métricas
mape_train_rf_3678055 <- mean(abs((datos_3678055$Venta - pred_train_rf_3678055) / pmax(datos_3678055$Venta, 0.01))) * 100
rmse_train_rf_3678055 <- sqrt(mean((datos_3678055$Venta - pred_train_rf_3678055)^2))

mape_test_rf_3678055 <- mean(abs((test_3678055$Venta - pred_test_rf_3678055) / pmax(test_3678055$Venta, 0.01))) * 100
rmse_test_rf_3678055 <- sqrt(mean((test_3678055$Venta - pred_test_rf_3678055)^2))

# Mostrar resultados
cat("Random Forest - Producto 3678055\n")

## Random Forest - Producto 3678055

cat("Train - MAPE:", round(mape_train_rf_3678055, 2), "| RMSE:", round(rmse_train_rf_3678055, 2), "\n")

## Train - MAPE: 26.16 | RMSE: 40659.52

cat("Test  - MAPE:", round(mape_test_rf_3678055, 2),  "| RMSE:", round(rmse_test_rf_3678055, 2),  "\n")

## Test  - MAPE: 46.57 | RMSE: 103169.6

# Guardar métricas en tabla
metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "Random Forest (Train)",
  MAPE = mape_train_rf_3678055,
  RMSE = rmse_train_rf_3678055
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "Random Forest (Test)",
  MAPE = mape_test_rf_3678055,
  RMSE = rmse_test_rf_3678055
))

# Importancia de variables
varImpPlot(modelo_rf_3678055, main = "Importancia de Variables - Producto 3678055")

# Observado vs Predicho (test)
ggplot(data.frame(Observado = test_3678055$Venta, Predicho = pred_test_rf_3678055),
       aes(x = Observado, y = Predicho)) +
  geom_point(alpha = 0.5) +
  geom_abline(slope = 1, intercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Observado vs Predicho - Producto 3678055 (test data)",
       x = "Venta Observada", y = "Venta Predicha") +
  theme_minimal()

# Análisis de errores (test)
errores_test_3678055 <- test_3678055$Venta - pred_test_rf_3678055
hist(errores_test_3678055, main = "Distribución de Errores - Producto 3678055 (test data)",
     xlab = "Error (Observado - Predicho)", col = "skyblue", breaks = 30)

cat("Media error:", mean(errores_test_3678055), "\n")

## Media error: 4118.975

cat("SD error:", sd(errores_test_3678055), "\n")

## SD error: 107296.7

cat("Min error:", min(errores_test_3678055), "\n")

## Min error: -104929.6

cat("Max error:", max(errores_test_3678055), "\n")

## Max error: 206123.7

cat("Mediana error:", median(errores_test_3678055), "\n")

## Mediana error: -34586.45

# Error vs Predicción (test)
ggplot(data.frame(Predicho = pred_test_rf_3678055, Error = errores_test_3678055),
       aes(x = Predicho, y = Error)) +
  geom_point(alpha = 0.5) +
  geom_hline(yintercept = 0, color = "red", linetype = "dashed") +
  labs(title = "Error vs Predicción - Producto 3678055 (test data)",
       x = "Venta Predicha", y = "Error") +
  theme_minimal()

8.6 MÉTRICAS ARMA, REG LINEAL Y RANDOM FOREST

metricas_comparativas %>%
  arrange(Producto) %>%
  knitr::kable(caption = "Métricas ARMA, Regresion Lineal y Random Forest por producto") %>%
  kableExtra::kable_styling(full_width = FALSE)

Métricas ARMA, Regresion Lineal y Random Forest por producto

Producto	Modelo	MAPE	RMSE
155001	ARMA	37.96077	109593.78
155001	ARMA (Test)	25.14259	67277.26
155001	Regresión Lineal (Train)	39.93493	111408.28
155001	Regresión Lineal (Test)	89.83537	157598.32
155001	Random Forest (Train)	18.88805	55005.66
155001	Random Forest (Test)	77.18471	138820.57
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
155002	Regresión Lineal (Train)	53.30857	81659.41
155002	Regresión Lineal (Test)	113.63421	140462.00
155002	Random Forest (Train)	24.90641	40622.51
155002	Random Forest (Test)	101.53221	122531.14
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3678055	Regresión Lineal (Train)	54.28565	82493.59
3678055	Regresión Lineal (Test)	35.22903	125404.28
3678055	Random Forest (Train)	26.16327	40659.52
3678055	Random Forest (Test)	46.57144	103169.62
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3904152	Regresión Lineal (Train)	38.98555	104128.86
3904152	Regresión Lineal (Test)	196.40268	209230.00
3904152	Random Forest (Train)	19.28014	53268.65
3904152	Random Forest (Test)	87.56263	101889.81
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08
3929788	Regresión Lineal (Train)	20.52872	53920.09
3929788	Regresión Lineal (Test)	34.22277	68189.37
3929788	Random Forest (Train)	10.27272	27004.10
3929788	Random Forest (Test)	26.95816	56210.34

9 XGBOOST

9.1 PRODUCTO 155001

9.1.1 SPLIT INTERNO

# Dividir los datos en entrenamiento (80%) y validación interna (20%)
set.seed(123)  # Para reproducibilidad

indices_train_155001 <- createDataPartition(datos_155001$Venta, p = 0.8, list = FALSE)

# Crear subconjuntos
datos_train_155001 <- datos_155001[indices_train_155001, ]
datos_test_155001  <- datos_155001[-indices_train_155001, ]

# Matrices predictoras y objetivo
X_train_155001 <- as.matrix(datos_train_155001[, colnames(datos_train_155001) != "Venta"])
y_train_155001 <- datos_train_155001$Venta

X_test_155001 <- as.matrix(datos_test_155001[, colnames(datos_test_155001) != "Venta"])
y_test_155001 <- datos_test_155001$Venta

# Convertir a formato DMatrix para XGBoost
dtrain_155001 <- xgb.DMatrix(data = X_train_155001, label = y_train_155001)
dtest_155001  <- xgb.DMatrix(data = X_test_155001, label = y_test_155001)

9.1.2 BUSQUEDA DE HIPERPARAMETROS CON VALIDACIÓN CRUZADA

# Crear una rejilla de combinaciones de hiperparámetros
param_grid <- expand.grid(
  eta = c(0.01, 0.05, 0.1),             # Tasa de aprendizaje
  max_depth = c(3, 5, 7),               # Profundidad del árbol
  subsample = c(0.8, 1.0),              # Proporción de muestras por árbol
  colsample_bytree = c(0.8, 1.0),       # Proporción de columnas por árbol
  min_child_weight = c(1, 3),           # Peso mínimo de nodos hijos
  gamma = c(0, 0.1)                     # Regularización
)

# Reducir combinaciones para eficiencia
set.seed(123)
param_grid_reducida <- param_grid[sample(1:nrow(param_grid), 10), ]

# Función para evaluar cada combinación con validación cruzada
evaluate_params_155001 <- function(params_row) {
  params <- list(
    objective = "reg:squarederror",
    eval_metric = "rmse",
    eta = params_row$eta,
    max_depth = params_row$max_depth,
    subsample = params_row$subsample,
    colsample_bytree = params_row$colsample_bytree,
    min_child_weight = params_row$min_child_weight,
    gamma = params_row$gamma
  )
  
  cv <- xgb.cv(
    params = params,
    data = dtrain_155001,    # <- usa DMatrix con datos_train_155001
    nrounds = 100,
    nfold = 5,
    early_stopping_rounds = 10,
    verbose = 0
  )
  
  list(
    rmse = min(cv$evaluation_log$test_rmse_mean),
    nrounds = which.min(cv$evaluation_log$test_rmse_mean),
    params = params
  )
}

# Evaluar todas las combinaciones
resultados_grid_155001 <- param_grid_reducida
resultados_grid_155001$nrounds <- NA
resultados_grid_155001$rmse <- NA

cat("Iniciando búsqueda de hiperparámetros para producto 155001...\n")

## Iniciando búsqueda de hiperparámetros para producto 155001...

for (i in 1:nrow(param_grid_reducida)) {
  cat(sprintf("Evaluando combinación %d de %d\n", i, nrow(param_grid_reducida)))
  
  resultado <- evaluate_params_155001(param_grid_reducida[i, ])
  
  resultados_grid_155001$nrounds[i] <- resultado$nrounds
  resultados_grid_155001$rmse[i] <- resultado$rmse
}

## Evaluando combinación 1 de 10
## Evaluando combinación 2 de 10
## Evaluando combinación 3 de 10
## Evaluando combinación 4 de 10
## Evaluando combinación 5 de 10
## Evaluando combinación 6 de 10
## Evaluando combinación 7 de 10
## Evaluando combinación 8 de 10
## Evaluando combinación 9 de 10
## Evaluando combinación 10 de 10

# Ordenar por mejor RMSE
resultados_grid_155001 <- resultados_grid_155001[order(resultados_grid_155001$rmse), ]

# Mostrar las 5 mejores combinaciones
cat("\nTop 5 combinaciones de hiperparámetros (Producto 155001):\n")

## 
## Top 5 combinaciones de hiperparámetros (Producto 155001):

print(head(resultados_grid_155001, 5))

##      eta max_depth subsample colsample_bytree min_child_weight gamma nrounds
## 14  0.05         5       1.0              0.8                1   0.0      48
## 144 0.10         7       1.0              1.0                3   0.1      32
## 50  0.05         5       1.0              0.8                3   0.0      63
## 137 0.05         3       1.0              1.0                3   0.1      47
## 92  0.05         3       0.8              1.0                1   0.1      55
##         rmse
## 14  113784.0
## 144 117559.9
## 50  119777.3
## 137 122169.4
## 92  127813.1

9.1.3 ENTRENA MODELO CON MEJORES HIPERPARÁMETROS

# Extraer los mejores hiperparámetros del grid
mejores_params_155001 <- list(
  objective = "reg:squarederror",
  eval_metric = "rmse",
  eta = resultados_grid_155001$eta[1],
  max_depth = resultados_grid_155001$max_depth[1],
  subsample = resultados_grid_155001$subsample[1],
  colsample_bytree = resultados_grid_155001$colsample_bytree[1],
  min_child_weight = resultados_grid_155001$min_child_weight[1],
  gamma = resultados_grid_155001$gamma[1]
)

# Número óptimo de rondas
mejor_nrounds_155001 <- resultados_grid_155001$nrounds[1]

cat("Entrenando modelo con mejores hiperparámetros...\n")

## Entrenando modelo con mejores hiperparámetros...

print(mejores_params_155001)

## $objective
## [1] "reg:squarederror"
## 
## $eval_metric
## [1] "rmse"
## 
## $eta
## [1] 0.05
## 
## $max_depth
## [1] 5
## 
## $subsample
## [1] 1
## 
## $colsample_bytree
## [1] 0.8
## 
## $min_child_weight
## [1] 1
## 
## $gamma
## [1] 0

cat("Número óptimo de rondas:", mejor_nrounds_155001, "\n")

## Número óptimo de rondas: 48

# Entrenar el modelo con los datos de split interno
modelo_xgb_155001_split <- xgb.train(
  params = mejores_params_155001,
  data = dtrain_155001,
  nrounds = mejor_nrounds_155001,
  watchlist = list(train = dtrain_155001, test = dtest_155001),
  verbose = 0
)

9.1.4 MÉTRICAS INTERNAS

# Métricas sobre datos_train (80%)
pred_train_split_155001 <- predict(modelo_xgb_155001_split, dtrain_155001)
mape_train_split_155001 <- mean(abs((y_train_155001 - pred_train_split_155001) / pmax(y_train_155001, 0.01))) * 100
rmse_train_split_155001 <- sqrt(mean((y_train_155001 - pred_train_split_155001)^2))

# Métricas sobre datos_test (20%)
pred_test_split_155001 <- predict(modelo_xgb_155001_split, dtest_155001)
mape_test_split_155001 <- mean(abs((y_test_155001 - pred_test_split_155001) / pmax(y_test_155001, 0.01))) * 100
rmse_test_split_155001 <- sqrt(mean((y_test_155001 - pred_test_split_155001)^2))

cat("Split Interno - Producto 155001\n")

## Split Interno - Producto 155001

cat("Train Split - MAPE:", round(mape_train_split_155001, 2), "| RMSE:", round(rmse_train_split_155001, 2), "\n")

## Train Split - MAPE: 13.79 | RMSE: 57460.15

cat("Test  Split - MAPE:", round(mape_test_split_155001, 2),  "| RMSE:", round(rmse_test_split_155001, 2), "\n")

## Test  Split - MAPE: 35.56 | RMSE: 99743.91

9.1.5 ENTRENAMIENTO CON DATOS COMPLETOS

# Preparar matrices con todos los datos
X_entero_155001 <- as.matrix(datos_155001[, colnames(datos_155001) != "Venta"])
y_entero_155001 <- datos_155001$Venta
dtrain_final_155001 <- xgb.DMatrix(data = X_entero_155001, label = y_entero_155001)

# Entrenar el modelo final
modelo_xgb_final_155001 <- xgb.train(
  params = mejores_params_155001,
  data = dtrain_final_155001,
  nrounds = mejor_nrounds_155001,
  verbose = 0
)

# Evaluación en datos_155001
pred_final_train_155001 <- predict(modelo_xgb_final_155001, X_entero_155001)
mape_final_train_155001 <- mean(abs((y_entero_155001 - pred_final_train_155001) / pmax(y_entero_155001, 0.01))) * 100
rmse_final_train_155001 <- sqrt(mean((y_entero_155001 - pred_final_train_155001)^2))

# Evaluación en test_155001
X_test_real_155001 <- as.matrix(test_155001[, colnames(test_155001) != "Venta"])
y_test_real_155001 <- test_155001$Venta
pred_final_test_155001 <- predict(modelo_xgb_final_155001, X_test_real_155001)
mape_final_test_155001 <- mean(abs((y_test_real_155001 - pred_final_test_155001) / pmax(y_test_real_155001, 0.01))) * 100
rmse_final_test_155001 <- sqrt(mean((y_test_real_155001 - pred_final_test_155001)^2))

cat("Modelo Final - Producto 155001\n")

## Modelo Final - Producto 155001

cat("Train - MAPE:", round(mape_final_train_155001, 2), "| RMSE:", round(rmse_final_train_155001, 2), "\n")

## Train - MAPE: 15.15 | RMSE: 59186.13

cat("Test  - MAPE:", round(mape_final_test_155001, 2),  "| RMSE:", round(rmse_final_test_155001, 2), "\n")

## Test  - MAPE: 47.41 | RMSE: 113795.2

9.1.6 TABLA DE MÉTRICAS

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "XGBoost (Train)",
  MAPE = mape_final_train_155001,
  RMSE = rmse_final_train_155001
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155001",
  Modelo = "XGBoost (Test)",
  MAPE = mape_final_test_155001,
  RMSE = rmse_final_test_155001
))

9.2 PRODUCTO 3929788

9.2.1 SPLIT INTERNO

# Dividir los datos en entrenamiento (80%) y validación interna (20%)
set.seed(123)  # Para reproducibilidad

indices_train_3929788 <- createDataPartition(datos_3929788$Venta, p = 0.8, list = FALSE)

# Crear subconjuntos
datos_train_3929788 <- datos_3929788[indices_train_3929788, ]
datos_test_3929788  <- datos_3929788[-indices_train_3929788, ]

# Matrices predictoras y objetivo
X_train_3929788 <- as.matrix(datos_train_3929788[, colnames(datos_train_3929788) != "Venta"])
y_train_3929788 <- datos_train_3929788$Venta

X_test_3929788 <- as.matrix(datos_test_3929788[, colnames(datos_test_3929788) != "Venta"])
y_test_3929788 <- datos_test_3929788$Venta

# Convertir a formato DMatrix para XGBoost
dtrain_3929788 <- xgb.DMatrix(data = X_train_3929788, label = y_train_3929788)
dtest_3929788  <- xgb.DMatrix(data = X_test_3929788, label = y_test_3929788)

9.2.2 BUSQUEDA DE HIPERPARAMETROS CON VALIDACIÓN CRUZADA

# Crear una rejilla de combinaciones de hiperparámetros
param_grid <- expand.grid(
  eta = c(0.01, 0.05, 0.1),             # Tasa de aprendizaje
  max_depth = c(3, 5, 7),               # Profundidad del árbol
  subsample = c(0.8, 1.0),              # Proporción de muestras por árbol
  colsample_bytree = c(0.8, 1.0),       # Proporción de columnas por árbol
  min_child_weight = c(1, 3),           # Peso mínimo de nodos hijos
  gamma = c(0, 0.1)                     # Regularización
)

# Reducir combinaciones para eficiencia
set.seed(123)
param_grid_reducida <- param_grid[sample(1:nrow(param_grid), 10), ]

# Función para evaluar cada combinación con validación cruzada
evaluate_params_3929788 <- function(params_row) {
  params <- list(
    objective = "reg:squarederror",
    eval_metric = "rmse",
    eta = params_row$eta,
    max_depth = params_row$max_depth,
    subsample = params_row$subsample,
    colsample_bytree = params_row$colsample_bytree,
    min_child_weight = params_row$min_child_weight,
    gamma = params_row$gamma
  )
  
  cv <- xgb.cv(
    params = params,
    data = dtrain_3929788,    # <- usa DMatrix con datos_train_155001
    nrounds = 100,
    nfold = 5,
    early_stopping_rounds = 10,
    verbose = 0
  )
  
  list(
    rmse = min(cv$evaluation_log$test_rmse_mean),
    nrounds = which.min(cv$evaluation_log$test_rmse_mean),
    params = params
  )
}

# Evaluar todas las combinaciones
resultados_grid_3929788 <- param_grid_reducida
resultados_grid_3929788$nrounds <- NA
resultados_grid_3929788$rmse <- NA

cat("Iniciando búsqueda de hiperparámetros para producto 3929788...\n")

## Iniciando búsqueda de hiperparámetros para producto 3929788...

for (i in 1:nrow(param_grid_reducida)) {
  cat(sprintf("Evaluando combinación %d de %d\n", i, nrow(param_grid_reducida)))
  
  resultado <- evaluate_params_3929788(param_grid_reducida[i, ])
  
  resultados_grid_3929788$nrounds[i] <- resultado$nrounds
  resultados_grid_3929788$rmse[i] <- resultado$rmse
}

## Evaluando combinación 1 de 10
## Evaluando combinación 2 de 10
## Evaluando combinación 3 de 10
## Evaluando combinación 4 de 10
## Evaluando combinación 5 de 10
## Evaluando combinación 6 de 10
## Evaluando combinación 7 de 10
## Evaluando combinación 8 de 10
## Evaluando combinación 9 de 10
## Evaluando combinación 10 de 10

# Ordenar por mejor RMSE
resultados_grid_3929788 <- resultados_grid_3929788[order(resultados_grid_3929788$rmse), ]

# Mostrar las 5 mejores combinaciones
cat("\nTop 5 combinaciones de hiperparámetros (Producto 3929788):\n")

## 
## Top 5 combinaciones de hiperparámetros (Producto 3929788):

print(head(resultados_grid_3929788, 5))

##      eta max_depth subsample colsample_bytree min_child_weight gamma nrounds
## 50  0.05         5       1.0              0.8                3   0.0      54
## 90  0.10         7       1.0              0.8                1   0.1      33
## 144 0.10         7       1.0              1.0                3   0.1      29
## 92  0.05         3       0.8              1.0                1   0.1      48
## 137 0.05         3       1.0              1.0                3   0.1      85
##         rmse
## 50  62577.22
## 90  65352.69
## 144 66586.11
## 92  66701.52
## 137 67238.66

9.2.3 ENTRENA MODELO CON MEJORES HIPERPARÁMETROS

# Extraer los mejores hiperparámetros del grid
mejores_params_3929788 <- list(
  objective = "reg:squarederror",
  eval_metric = "rmse",
  eta = resultados_grid_3929788$eta[1],
  max_depth = resultados_grid_3929788$max_depth[1],
  subsample = resultados_grid_3929788$subsample[1],
  colsample_bytree = resultados_grid_3929788$colsample_bytree[1],
  min_child_weight = resultados_grid_3929788$min_child_weight[1],
  gamma = resultados_grid_3929788$gamma[1]
)

# Número óptimo de rondas
mejor_nrounds_3929788 <- resultados_grid_3929788$nrounds[1]

cat("Entrenando modelo con mejores hiperparámetros...\n")

## Entrenando modelo con mejores hiperparámetros...

print(mejores_params_3929788)

## $objective
## [1] "reg:squarederror"
## 
## $eval_metric
## [1] "rmse"
## 
## $eta
## [1] 0.05
## 
## $max_depth
## [1] 5
## 
## $subsample
## [1] 1
## 
## $colsample_bytree
## [1] 0.8
## 
## $min_child_weight
## [1] 3
## 
## $gamma
## [1] 0

cat("Número óptimo de rondas:", mejor_nrounds_3929788, "\n")

## Número óptimo de rondas: 54

# Entrenar el modelo con los datos de split interno
modelo_xgb_3929788_split <- xgb.train(
  params = mejores_params_3929788,
  data = dtrain_3929788,
  nrounds = mejor_nrounds_3929788,
  watchlist = list(train = dtrain_3929788, test = dtest_3929788),
  verbose = 0
)

9.2.4 MÉTRICAS INTERNAS

# Métricas sobre datos_train (80%)
pred_train_split_3929788 <- predict(modelo_xgb_3929788_split, dtrain_3929788)
mape_train_split_3929788 <- mean(abs((y_train_3929788 - pred_train_split_3929788) / pmax(y_train_3929788, 0.01))) * 100
rmse_train_split_3929788 <- sqrt(mean((y_train_3929788 - pred_train_split_3929788)^2))

# Métricas sobre datos_test (20%)
pred_test_split_3929788 <- predict(modelo_xgb_3929788_split, dtest_3929788)
mape_test_split_3929788 <- mean(abs((y_test_3929788 - pred_test_split_3929788) / pmax(y_test_3929788, 0.01))) * 100
rmse_test_split_3929788 <- sqrt(mean((y_test_3929788 - pred_test_split_3929788)^2))

cat("Split Interno - Producto 3929788\n")

## Split Interno - Producto 3929788

cat("Train Split - MAPE:", round(mape_train_split_3929788, 2), "| RMSE:", round(rmse_train_split_3929788, 2), "\n")

## Train Split - MAPE: 10.72 | RMSE: 34115.99

cat("Test  Split - MAPE:", round(mape_test_split_3929788, 2),  "| RMSE:", round(rmse_test_split_3929788, 2), "\n")

## Test  Split - MAPE: 12.26 | RMSE: 32974.97

9.2.5 ENTRENAMIENTO CON DATOS COMPLETOS

# Preparar matrices con todos los datos
X_entero_3929788 <- as.matrix(datos_3929788[, colnames(datos_3929788) != "Venta"])
y_entero_3929788 <- datos_3929788$Venta
dtrain_final_3929788 <- xgb.DMatrix(data = X_entero_3929788, label = y_entero_3929788)

# Entrenar el modelo final
modelo_xgb_final_3929788 <- xgb.train(
  params = mejores_params_3929788,
  data = dtrain_final_3929788,
  nrounds = mejor_nrounds_3929788,
  verbose = 0
)

# Evaluación en datos_3929788
pred_final_train_3929788 <- predict(modelo_xgb_final_3929788, X_entero_3929788)
mape_final_train_3929788 <- mean(abs((y_entero_3929788 - pred_final_train_3929788) / pmax(y_entero_3929788, 0.01))) * 100
rmse_final_train_3929788 <- sqrt(mean((y_entero_3929788 - pred_final_train_3929788)^2))

# Evaluación en test_3929788
X_test_real_3929788 <- as.matrix(test_3929788[, colnames(test_3929788) != "Venta"])
y_test_real_3929788 <- test_3929788$Venta
pred_final_test_3929788 <- predict(modelo_xgb_final_3929788, X_test_real_3929788)
mape_final_test_3929788 <- mean(abs((y_test_real_3929788 - pred_final_test_3929788) / pmax(y_test_real_3929788, 0.01))) * 100
rmse_final_test_3929788 <- sqrt(mean((y_test_real_3929788 - pred_final_test_3929788)^2))

cat("Modelo Final - Producto 3929788\n")

## Modelo Final - Producto 3929788

cat("Train - MAPE:", round(mape_final_train_3929788, 2), "| RMSE:", round(rmse_final_train_3929788, 2), "\n")

## Train - MAPE: 10.57 | RMSE: 33358.9

cat("Test  - MAPE:", round(mape_final_test_3929788, 2),  "| RMSE:", round(rmse_final_test_3929788, 2), "\n")

## Test  - MAPE: 25.99 | RMSE: 64972.72

9.2.6 TABLA DE MÉTRICAS

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "XGBoost (Train)",
  MAPE = mape_final_train_3929788,
  RMSE = rmse_final_train_3929788
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3929788",
  Modelo = "XGBoost (Test)",
  MAPE = mape_final_test_3929788,
  RMSE = rmse_final_test_3929788
))

9.3 PRODUCTO 3904152

9.3.1 SPLIT INTERNO

# Dividir los datos en entrenamiento (80%) y validación interna (20%)
set.seed(123)  # Para reproducibilidad

indices_train_3904152 <- createDataPartition(datos_3904152$Venta, p = 0.8, list = FALSE)

# Crear subconjuntos
datos_train_3904152 <- datos_3904152[indices_train_3904152, ]
datos_test_3904152  <- datos_3904152[-indices_train_3904152, ]

# Matrices predictoras y objetivo
X_train_3904152 <- as.matrix(datos_train_3904152[, colnames(datos_train_3904152) != "Venta"])
y_train_3904152 <- datos_train_3904152$Venta

X_test_3904152 <- as.matrix(datos_test_3904152[, colnames(datos_test_3904152) != "Venta"])
y_test_3904152 <- datos_test_3904152$Venta

# Convertir a formato DMatrix para XGBoost
dtrain_3904152 <- xgb.DMatrix(data = X_train_3904152, label = y_train_3904152)
dtest_3904152  <- xgb.DMatrix(data = X_test_3904152, label = y_test_3904152)

9.3.2 BUSQUEDA DE HIPERPARAMETROS CON VALIDACIÓN CRUZADA

# Crear una rejilla de combinaciones de hiperparámetros
param_grid <- expand.grid(
  eta = c(0.01, 0.05, 0.1),             # Tasa de aprendizaje
  max_depth = c(3, 5, 7),               # Profundidad del árbol
  subsample = c(0.8, 1.0),              # Proporción de muestras por árbol
  colsample_bytree = c(0.8, 1.0),       # Proporción de columnas por árbol
  min_child_weight = c(1, 3),           # Peso mínimo de nodos hijos
  gamma = c(0, 0.1)                     # Regularización
)

# Reducir combinaciones para eficiencia
set.seed(123)
param_grid_reducida <- param_grid[sample(1:nrow(param_grid), 10), ]

# Función para evaluar cada combinación con validación cruzada
evaluate_params_3904152 <- function(params_row) {
  params <- list(
    objective = "reg:squarederror",
    eval_metric = "rmse",
    eta = params_row$eta,
    max_depth = params_row$max_depth,
    subsample = params_row$subsample,
    colsample_bytree = params_row$colsample_bytree,
    min_child_weight = params_row$min_child_weight,
    gamma = params_row$gamma
  )
  
  cv <- xgb.cv(
    params = params,
    data = dtrain_3904152,    # <- usa DMatrix con datos_train_155001
    nrounds = 100,
    nfold = 5,
    early_stopping_rounds = 10,
    verbose = 0
  )
  
  list(
    rmse = min(cv$evaluation_log$test_rmse_mean),
    nrounds = which.min(cv$evaluation_log$test_rmse_mean),
    params = params
  )
}

# Evaluar todas las combinaciones
resultados_grid_3904152 <- param_grid_reducida
resultados_grid_3904152$nrounds <- NA
resultados_grid_3904152$rmse <- NA

cat("Iniciando búsqueda de hiperparámetros para producto 3904152...\n")

## Iniciando búsqueda de hiperparámetros para producto 3904152...

for (i in 1:nrow(param_grid_reducida)) {
  cat(sprintf("Evaluando combinación %d de %d\n", i, nrow(param_grid_reducida)))
  
  resultado <- evaluate_params_3904152(param_grid_reducida[i, ])
  
  resultados_grid_3904152$nrounds[i] <- resultado$nrounds
  resultados_grid_3904152$rmse[i] <- resultado$rmse
}

## Evaluando combinación 1 de 10
## Evaluando combinación 2 de 10
## Evaluando combinación 3 de 10
## Evaluando combinación 4 de 10
## Evaluando combinación 5 de 10
## Evaluando combinación 6 de 10
## Evaluando combinación 7 de 10
## Evaluando combinación 8 de 10
## Evaluando combinación 9 de 10
## Evaluando combinación 10 de 10

# Ordenar por mejor RMSE
resultados_grid_3904152 <- resultados_grid_3904152[order(resultados_grid_3904152$rmse), ]

# Mostrar las 5 mejores combinaciones
cat("\nTop 5 combinaciones de hiperparámetros (Producto 3904152):\n")

## 
## Top 5 combinaciones de hiperparámetros (Producto 3904152):

print(head(resultados_grid_3904152, 5))

##      eta max_depth subsample colsample_bytree min_child_weight gamma nrounds
## 50  0.05         5       1.0              0.8                3   0.0      49
## 14  0.05         5       1.0              0.8                1   0.0      51
## 92  0.05         3       0.8              1.0                1   0.1      47
## 137 0.05         3       1.0              1.0                3   0.1      41
## 90  0.10         7       1.0              0.8                1   0.1      19
##          rmse
## 50   92982.82
## 14   95795.14
## 92   99107.42
## 137  99518.53
## 90  105856.90

9.3.3 ENTRENA MODELO CON MEJORES HIPERPARÁMETROS

# Extraer los mejores hiperparámetros del grid
mejores_params_3904152 <- list(
  objective = "reg:squarederror",
  eval_metric = "rmse",
  eta = resultados_grid_3904152$eta[1],
  max_depth = resultados_grid_3904152$max_depth[1],
  subsample = resultados_grid_3904152$subsample[1],
  colsample_bytree = resultados_grid_3904152$colsample_bytree[1],
  min_child_weight = resultados_grid_3904152$min_child_weight[1],
  gamma = resultados_grid_3904152$gamma[1]
)

# Número óptimo de rondas
mejor_nrounds_3904152 <- resultados_grid_3904152$nrounds[1]

cat("Entrenando modelo con mejores hiperparámetros...\n")

## Entrenando modelo con mejores hiperparámetros...

print(mejores_params_3904152)

## $objective
## [1] "reg:squarederror"
## 
## $eval_metric
## [1] "rmse"
## 
## $eta
## [1] 0.05
## 
## $max_depth
## [1] 5
## 
## $subsample
## [1] 1
## 
## $colsample_bytree
## [1] 0.8
## 
## $min_child_weight
## [1] 3
## 
## $gamma
## [1] 0

cat("Número óptimo de rondas:", mejor_nrounds_3904152, "\n")

## Número óptimo de rondas: 49

# Entrenar el modelo con los datos de split interno
modelo_xgb_3904152_split <- xgb.train(
  params = mejores_params_3904152,
  data = dtrain_3904152,
  nrounds = mejor_nrounds_3904152,
  watchlist = list(train = dtrain_3904152, test = dtest_3904152),
  verbose = 0
)

9.3.4 MÉTRICAS INTERNAS

# Métricas sobre datos_train (80%)
pred_train_split_3904152 <- predict(modelo_xgb_3904152_split, dtrain_3904152)
mape_train_split_3904152 <- mean(abs((y_train_3904152 - pred_train_split_3904152) / pmax(y_train_3904152, 0.01))) * 100
rmse_train_split_3904152 <- sqrt(mean((y_train_3904152 - pred_train_split_3904152)^2))

# Métricas sobre datos_test (20%)
pred_test_split_3904152 <- predict(modelo_xgb_3904152_split, dtest_3904152)
mape_test_split_3904152 <- mean(abs((y_test_3904152 - pred_test_split_3904152) / pmax(y_test_3904152, 0.01))) * 100
rmse_test_split_3904152 <- sqrt(mean((y_test_3904152 - pred_test_split_3904152)^2))

cat("Split Interno - Producto 3904152\n")

## Split Interno - Producto 3904152

cat("Train Split - MAPE:", round(mape_train_split_3904152, 2), "| RMSE:", round(rmse_train_split_3904152, 2), "\n")

## Train Split - MAPE: 14.45 | RMSE: 52366

cat("Test  Split - MAPE:", round(mape_test_split_3904152, 2),  "| RMSE:", round(rmse_test_split_3904152, 2), "\n")

## Test  Split - MAPE: 32.87 | RMSE: 137420.3

9.3.5 ENTRENAMIENTO CON DATOS COMPLETOS

# Preparar matrices con todos los datos
X_entero_3904152 <- as.matrix(datos_3904152[, colnames(datos_3904152) != "Venta"])
y_entero_3904152 <- datos_3904152$Venta
dtrain_final_3904152 <- xgb.DMatrix(data = X_entero_3904152, label = y_entero_3904152)

# Entrenar el modelo final
modelo_xgb_final_3904152 <- xgb.train(
  params = mejores_params_3904152,
  data = dtrain_final_3904152,
  nrounds = mejor_nrounds_3904152,
  verbose = 0
)

# Evaluación en datos_3904152
pred_final_train_3904152 <- predict(modelo_xgb_final_3904152, X_entero_3904152)
mape_final_train_3904152 <- mean(abs((y_entero_3904152 - pred_final_train_3904152) / pmax(y_entero_3904152, 0.01))) * 100
rmse_final_train_3904152 <- sqrt(mean((y_entero_3904152 - pred_final_train_3904152)^2))

# Evaluación en test_3904152
X_test_real_3904152 <- as.matrix(test_3904152[, colnames(test_3904152) != "Venta"])
y_test_real_3904152 <- test_3904152$Venta
pred_final_test_3904152 <- predict(modelo_xgb_final_3904152, X_test_real_3904152)
mape_final_test_3904152 <- mean(abs((y_test_real_3904152 - pred_final_test_3904152) / pmax(y_test_real_3904152, 0.01))) * 100
rmse_final_test_3904152 <- sqrt(mean((y_test_real_3904152 - pred_final_test_3904152)^2))

cat("Modelo Final - Producto 3904152\n")

## Modelo Final - Producto 3904152

cat("Train - MAPE:", round(mape_final_train_3904152, 2), "| RMSE:", round(rmse_final_train_3904152, 2), "\n")

## Train - MAPE: 15.63 | RMSE: 52020.93

cat("Test  - MAPE:", round(mape_final_test_3904152, 2),  "| RMSE:", round(rmse_final_test_3904152, 2), "\n")

## Test  - MAPE: 48.23 | RMSE: 79333.37

9.3.6 TABLA DE MÉTRICAS

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "XGBoost (Train)",
  MAPE = mape_final_train_3904152,
  RMSE = rmse_final_train_3904152
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3904152",
  Modelo = "XGBoost (Test)",
  MAPE = mape_final_test_3904152,
  RMSE = rmse_final_test_3904152
))

9.4 PRODUCTO 155002

9.4.1 SPLIT INTERNO

# Dividir los datos en entrenamiento (80%) y validación interna (20%)
set.seed(123)  # Para reproducibilidad

indices_train_155002 <- createDataPartition(datos_155002$Venta, p = 0.8, list = FALSE)

# Crear subconjuntos
datos_train_155002 <- datos_155002[indices_train_155002, ]
datos_test_155002  <- datos_155002[-indices_train_155002, ]

# Matrices predictoras y objetivo
X_train_155002 <- as.matrix(datos_train_155002[, colnames(datos_train_155002) != "Venta"])
y_train_155002 <- datos_train_155002$Venta

X_test_155002 <- as.matrix(datos_test_155002[, colnames(datos_test_155002) != "Venta"])
y_test_155002 <- datos_test_155002$Venta

# Convertir a formato DMatrix para XGBoost
dtrain_155002 <- xgb.DMatrix(data = X_train_155002, label = y_train_155002)
dtest_155002  <- xgb.DMatrix(data = X_test_155002, label = y_test_155002)

9.4.2 BUSQUEDA DE HIPERPARAMETROS CON VALIDACIÓN CRUZADA

# Crear una rejilla de combinaciones de hiperparámetros
param_grid <- expand.grid(
  eta = c(0.01, 0.05, 0.1),             # Tasa de aprendizaje
  max_depth = c(3, 5, 7),               # Profundidad del árbol
  subsample = c(0.8, 1.0),              # Proporción de muestras por árbol
  colsample_bytree = c(0.8, 1.0),       # Proporción de columnas por árbol
  min_child_weight = c(1, 3),           # Peso mínimo de nodos hijos
  gamma = c(0, 0.1)                     # Regularización
)

# Reducir combinaciones para eficiencia
set.seed(123)
param_grid_reducida <- param_grid[sample(1:nrow(param_grid), 10), ]

# Función para evaluar cada combinación con validación cruzada
evaluate_params_155002 <- function(params_row) {
  params <- list(
    objective = "reg:squarederror",
    eval_metric = "rmse",
    eta = params_row$eta,
    max_depth = params_row$max_depth,
    subsample = params_row$subsample,
    colsample_bytree = params_row$colsample_bytree,
    min_child_weight = params_row$min_child_weight,
    gamma = params_row$gamma
  )
  
  cv <- xgb.cv(
    params = params,
    data = dtrain_155002,    # <- usa DMatrix con datos_train_155001
    nrounds = 100,
    nfold = 5,
    early_stopping_rounds = 10,
    verbose = 0
  )
  
  list(
    rmse = min(cv$evaluation_log$test_rmse_mean),
    nrounds = which.min(cv$evaluation_log$test_rmse_mean),
    params = params
  )
}

# Evaluar todas las combinaciones
resultados_grid_155002 <- param_grid_reducida
resultados_grid_155002$nrounds <- NA
resultados_grid_155002$rmse <- NA

cat("Iniciando búsqueda de hiperparámetros para producto 155002...\n")

## Iniciando búsqueda de hiperparámetros para producto 155002...

for (i in 1:nrow(param_grid_reducida)) {
  cat(sprintf("Evaluando combinación %d de %d\n", i, nrow(param_grid_reducida)))
  
  resultado <- evaluate_params_155002(param_grid_reducida[i, ])
  
  resultados_grid_155002$nrounds[i] <- resultado$nrounds
  resultados_grid_155002$rmse[i] <- resultado$rmse
}

## Evaluando combinación 1 de 10
## Evaluando combinación 2 de 10
## Evaluando combinación 3 de 10
## Evaluando combinación 4 de 10
## Evaluando combinación 5 de 10
## Evaluando combinación 6 de 10
## Evaluando combinación 7 de 10
## Evaluando combinación 8 de 10
## Evaluando combinación 9 de 10
## Evaluando combinación 10 de 10

# Ordenar por mejor RMSE
resultados_grid_155002 <- resultados_grid_155002[order(resultados_grid_155002$rmse), ]

# Mostrar las 5 mejores combinaciones
cat("\nTop 5 combinaciones de hiperparámetros (Producto 155002):\n")

## 
## Top 5 combinaciones de hiperparámetros (Producto 155002):

print(head(resultados_grid_155002, 5))

##      eta max_depth subsample colsample_bytree min_child_weight gamma nrounds
## 50  0.05         5       1.0              0.8                3   0.0      47
## 14  0.05         5       1.0              0.8                1   0.0      40
## 92  0.05         3       0.8              1.0                1   0.1      59
## 137 0.05         3       1.0              1.0                3   0.1      46
## 90  0.10         7       1.0              0.8                1   0.1      26
##         rmse
## 50  86869.37
## 14  89673.86
## 92  89853.22
## 137 92169.64
## 90  93260.29

9.4.3 ENTRENA MODELO CON MEJORES HIPERPARÁMETROS

# Extraer los mejores hiperparámetros del grid
mejores_params_155002 <- list(
  objective = "reg:squarederror",
  eval_metric = "rmse",
  eta = resultados_grid_155002$eta[1],
  max_depth = resultados_grid_155002$max_depth[1],
  subsample = resultados_grid_155002$subsample[1],
  colsample_bytree = resultados_grid_155002$colsample_bytree[1],
  min_child_weight = resultados_grid_155002$min_child_weight[1],
  gamma = resultados_grid_155002$gamma[1]
)

# Número óptimo de rondas
mejor_nrounds_155002 <- resultados_grid_155002$nrounds[1]

cat("Entrenando modelo con mejores hiperparámetros...\n")

## Entrenando modelo con mejores hiperparámetros...

print(mejores_params_155002)

## $objective
## [1] "reg:squarederror"
## 
## $eval_metric
## [1] "rmse"
## 
## $eta
## [1] 0.05
## 
## $max_depth
## [1] 5
## 
## $subsample
## [1] 1
## 
## $colsample_bytree
## [1] 0.8
## 
## $min_child_weight
## [1] 3
## 
## $gamma
## [1] 0

cat("Número óptimo de rondas:", mejor_nrounds_155002, "\n")

## Número óptimo de rondas: 47

# Entrenar el modelo con los datos de split interno
modelo_xgb_155002_split <- xgb.train(
  params = mejores_params_155002,
  data = dtrain_155002,
  nrounds = mejor_nrounds_155002,
  watchlist = list(train = dtrain_155002, test = dtest_155002),
  verbose = 0
)

9.4.4 MÉTRICAS INTERNAS

# Métricas sobre datos_train (80%)
pred_train_split_155002 <- predict(modelo_xgb_155002_split, dtrain_155002)
mape_train_split_155002 <- mean(abs((y_train_155002 - pred_train_split_155002) / pmax(y_train_155002, 0.01))) * 100
rmse_train_split_155002 <- sqrt(mean((y_train_155002 - pred_train_split_155002)^2))

# Métricas sobre datos_test (20%)
pred_test_split_155002 <- predict(modelo_xgb_155002_split, dtest_155002)
mape_test_split_155002 <- mean(abs((y_test_155002 - pred_test_split_155002) / pmax(y_test_155002, 0.01))) * 100
rmse_test_split_155002 <- sqrt(mean((y_test_155002 - pred_test_split_155002)^2))

cat("Split Interno - Producto 155002\n")

## Split Interno - Producto 155002

cat("Train Split - MAPE:", round(mape_train_split_155002, 2), "| RMSE:", round(rmse_train_split_155002, 2), "\n")

## Train Split - MAPE: 18 | RMSE: 44397.44

cat("Test  Split - MAPE:", round(mape_test_split_155002, 2),  "| RMSE:", round(rmse_test_split_155002, 2), "\n")

## Test  Split - MAPE: 34.89 | RMSE: 91093.81

9.4.5 ENTRENAMIENTO CON DATOS COMPLETOS

# Preparar matrices con todos los datos
X_entero_155002 <- as.matrix(datos_155002[, colnames(datos_155002) != "Venta"])
y_entero_155002 <- datos_155002$Venta
dtrain_final_155002 <- xgb.DMatrix(data = X_entero_155002, label = y_entero_155002)

# Entrenar el modelo final
modelo_xgb_final_155002 <- xgb.train(
  params = mejores_params_155002,
  data = dtrain_final_155002,
  nrounds = mejor_nrounds_155002,
  verbose = 0
)

# Evaluación en datos_155002
pred_final_train_155002 <- predict(modelo_xgb_final_155002, X_entero_155002)
mape_final_train_155002 <- mean(abs((y_entero_155002 - pred_final_train_155002) / pmax(y_entero_155002, 0.01))) * 100
rmse_final_train_155002 <- sqrt(mean((y_entero_155002 - pred_final_train_155002)^2))

# Evaluación en test_155002
X_test_real_155002 <- as.matrix(test_155002[, colnames(test_155002) != "Venta"])
y_test_real_155002 <- test_155002$Venta
pred_final_test_155002 <- predict(modelo_xgb_final_155002, X_test_real_155002)
mape_final_test_155002 <- mean(abs((y_test_real_155002 - pred_final_test_155002) / pmax(y_test_real_155002, 0.01))) * 100
rmse_final_test_155002 <- sqrt(mean((y_test_real_155002 - pred_final_test_155002)^2))

cat("Modelo Final - Producto 155002\n")

## Modelo Final - Producto 155002

cat("Train - MAPE:", round(mape_final_train_155002, 2), "| RMSE:", round(rmse_final_train_155002, 2), "\n")

## Train - MAPE: 17.08 | RMSE: 43397.75

cat("Test  - MAPE:", round(mape_final_test_155002, 2),  "| RMSE:", round(rmse_final_test_155002, 2), "\n")

## Test  - MAPE: 53.71 | RMSE: 122995.6

9.4.6 TABLA DE MÉTRICAS

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "XGBoost (Train)",
  MAPE = mape_final_train_155002,
  RMSE = rmse_final_train_155002
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "155002",
  Modelo = "XGBoost (Test)",
  MAPE = mape_final_test_155002,
  RMSE = rmse_final_test_155002
))

9.5 PRODUCTO 3678055

9.5.1 SPLIT INTERNO

# Dividir los datos en entrenamiento (80%) y validación interna (20%)
set.seed(123)  # Para reproducibilidad

indices_train_3678055 <- createDataPartition(datos_3678055$Venta, p = 0.8, list = FALSE)

# Crear subconjuntos
datos_train_3678055 <- datos_3678055[indices_train_3678055, ]
datos_test_3678055  <- datos_3678055[-indices_train_3678055, ]

# Matrices predictoras y objetivo
X_train_3678055 <- as.matrix(datos_train_3678055[, colnames(datos_train_3678055) != "Venta"])
y_train_3678055 <- datos_train_3678055$Venta

X_test_3678055 <- as.matrix(datos_test_3678055[, colnames(datos_test_3678055) != "Venta"])
y_test_3678055 <- datos_test_3678055$Venta

# Convertir a formato DMatrix para XGBoost
dtrain_3678055 <- xgb.DMatrix(data = X_train_3678055, label = y_train_3678055)
dtest_3678055  <- xgb.DMatrix(data = X_test_3678055, label = y_test_3678055)

9.5.2 BUSQUEDA DE HIPERPARAMETROS CON VALIDACIÓN CRUZADA

# Crear una rejilla de combinaciones de hiperparámetros
param_grid <- expand.grid(
  eta = c(0.01, 0.05, 0.1),             # Tasa de aprendizaje
  max_depth = c(3, 5, 7),               # Profundidad del árbol
  subsample = c(0.8, 1.0),              # Proporción de muestras por árbol
  colsample_bytree = c(0.8, 1.0),       # Proporción de columnas por árbol
  min_child_weight = c(1, 3),           # Peso mínimo de nodos hijos
  gamma = c(0, 0.1)                     # Regularización
)

# Reducir combinaciones para eficiencia
set.seed(123)
param_grid_reducida <- param_grid[sample(1:nrow(param_grid), 10), ]

# Función para evaluar cada combinación con validación cruzada
evaluate_params_3678055 <- function(params_row) {
  params <- list(
    objective = "reg:squarederror",
    eval_metric = "rmse",
    eta = params_row$eta,
    max_depth = params_row$max_depth,
    subsample = params_row$subsample,
    colsample_bytree = params_row$colsample_bytree,
    min_child_weight = params_row$min_child_weight,
    gamma = params_row$gamma
  )
  
  cv <- xgb.cv(
    params = params,
    data = dtrain_3678055,    # <- usa DMatrix con datos_train_155001
    nrounds = 100,
    nfold = 5,
    early_stopping_rounds = 10,
    verbose = 0
  )
  
  list(
    rmse = min(cv$evaluation_log$test_rmse_mean),
    nrounds = which.min(cv$evaluation_log$test_rmse_mean),
    params = params
  )
}

# Evaluar todas las combinaciones
resultados_grid_3678055 <- param_grid_reducida
resultados_grid_3678055$nrounds <- NA
resultados_grid_3678055$rmse <- NA

cat("Iniciando búsqueda de hiperparámetros para producto 3678055...\n")

## Iniciando búsqueda de hiperparámetros para producto 3678055...

for (i in 1:nrow(param_grid_reducida)) {
  cat(sprintf("Evaluando combinación %d de %d\n", i, nrow(param_grid_reducida)))
  
  resultado <- evaluate_params_3678055(param_grid_reducida[i, ])
  
  resultados_grid_3678055$nrounds[i] <- resultado$nrounds
  resultados_grid_3678055$rmse[i] <- resultado$rmse
}

## Evaluando combinación 1 de 10
## Evaluando combinación 2 de 10
## Evaluando combinación 3 de 10
## Evaluando combinación 4 de 10
## Evaluando combinación 5 de 10
## Evaluando combinación 6 de 10
## Evaluando combinación 7 de 10
## Evaluando combinación 8 de 10
## Evaluando combinación 9 de 10
## Evaluando combinación 10 de 10

# Ordenar por mejor RMSE
resultados_grid_3678055 <- resultados_grid_3678055[order(resultados_grid_3678055$rmse), ]

# Mostrar las 5 mejores combinaciones
cat("\nTop 5 combinaciones de hiperparámetros (Producto 3678055):\n")

## 
## Top 5 combinaciones de hiperparámetros (Producto 3678055):

print(head(resultados_grid_3678055, 5))

##      eta max_depth subsample colsample_bytree min_child_weight gamma nrounds
## 92  0.05         3       0.8              1.0                1   0.1      38
## 137 0.05         3       1.0              1.0                3   0.1      42
## 50  0.05         5       1.0              0.8                3   0.0      58
## 90  0.10         7       1.0              0.8                1   0.1      23
## 144 0.10         7       1.0              1.0                3   0.1      24
##         rmse
## 92  88804.88
## 137 89118.86
## 50  89777.18
## 90  90640.12
## 144 92839.62

9.5.3 ENTRENA MODELO CON MEJORES HIPERPARÁMETROS

# Extraer los mejores hiperparámetros del grid
mejores_params_3678055 <- list(
  objective = "reg:squarederror",
  eval_metric = "rmse",
  eta = resultados_grid_3678055$eta[1],
  max_depth = resultados_grid_3678055$max_depth[1],
  subsample = resultados_grid_3678055$subsample[1],
  colsample_bytree = resultados_grid_3678055$colsample_bytree[1],
  min_child_weight = resultados_grid_3678055$min_child_weight[1],
  gamma = resultados_grid_3678055$gamma[1]
)

# Número óptimo de rondas
mejor_nrounds_3678055 <- resultados_grid_3678055$nrounds[1]

cat("Entrenando modelo con mejores hiperparámetros...\n")

## Entrenando modelo con mejores hiperparámetros...

print(mejores_params_3678055)

## $objective
## [1] "reg:squarederror"
## 
## $eval_metric
## [1] "rmse"
## 
## $eta
## [1] 0.05
## 
## $max_depth
## [1] 3
## 
## $subsample
## [1] 0.8
## 
## $colsample_bytree
## [1] 1
## 
## $min_child_weight
## [1] 1
## 
## $gamma
## [1] 0.1

cat("Número óptimo de rondas:", mejor_nrounds_3678055, "\n")

## Número óptimo de rondas: 38

# Entrenar el modelo con los datos de split interno
modelo_xgb_3678055_split <- xgb.train(
  params = mejores_params_3678055,
  data = dtrain_3678055,
  nrounds = mejor_nrounds_3678055,
  watchlist = list(train = dtrain_3678055, test = dtest_3678055),
  verbose = 0
)

9.5.4 MÉTRICAS INTERNAS

# Métricas sobre datos_train (80%)
pred_train_split_3678055 <- predict(modelo_xgb_3678055_split, dtrain_3678055)
mape_train_split_3678055 <- mean(abs((y_train_3678055 - pred_train_split_3678055) / pmax(y_train_3678055, 0.01))) * 100
rmse_train_split_3678055 <- sqrt(mean((y_train_3678055 - pred_train_split_3678055)^2))

# Métricas sobre datos_test (20%)
pred_test_split_3678055 <- predict(modelo_xgb_3678055_split, dtest_3678055)
mape_test_split_3678055 <- mean(abs((y_test_3678055 - pred_test_split_3678055) / pmax(y_test_3678055, 0.01))) * 100
rmse_test_split_3678055 <- sqrt(mean((y_test_3678055 - pred_test_split_3678055)^2))

cat("Split Interno - Producto 3678055\n")

## Split Interno - Producto 3678055

cat("Train Split - MAPE:", round(mape_train_split_3678055, 2), "| RMSE:", round(rmse_train_split_3678055, 2), "\n")

## Train Split - MAPE: 28.62 | RMSE: 64305.89

cat("Test  Split - MAPE:", round(mape_test_split_3678055, 2),  "| RMSE:", round(rmse_test_split_3678055, 2), "\n")

## Test  Split - MAPE: 42 | RMSE: 81885.14

9.5.5 ENTRENAMIENTO CON DATOS COMPLETOS

# Preparar matrices con todos los datos
X_entero_3678055 <- as.matrix(datos_3678055[, colnames(datos_3678055) != "Venta"])
y_entero_3678055 <- datos_3678055$Venta
dtrain_final_3678055 <- xgb.DMatrix(data = X_entero_3678055, label = y_entero_3678055)

# Entrenar el modelo final
modelo_xgb_final_3678055 <- xgb.train(
  params = mejores_params_3678055,
  data = dtrain_final_3678055,
  nrounds = mejor_nrounds_3678055,
  verbose = 0
)

# Evaluación en datos_3678055
pred_final_train_3678055 <- predict(modelo_xgb_final_3678055, X_entero_3678055)
mape_final_train_3678055 <- mean(abs((y_entero_3678055 - pred_final_train_3678055) / pmax(y_entero_3678055, 0.01))) * 100
rmse_final_train_3678055 <- sqrt(mean((y_entero_3678055 - pred_final_train_3678055)^2))

# Evaluación en test_3678055
X_test_real_3678055 <- as.matrix(test_3678055[, colnames(test_3678055) != "Venta"])
y_test_real_3678055 <- test_3678055$Venta
pred_final_test_3678055 <- predict(modelo_xgb_final_3678055, X_test_real_3678055)
mape_final_test_3678055 <- mean(abs((y_test_real_3678055 - pred_final_test_3678055) / pmax(y_test_real_3678055, 0.01))) * 100
rmse_final_test_3678055 <- sqrt(mean((y_test_real_3678055 - pred_final_test_3678055)^2))

cat("Modelo Final - Producto 3678055\n")

## Modelo Final - Producto 3678055

cat("Train - MAPE:", round(mape_final_train_3678055, 2), "| RMSE:", round(rmse_final_train_3678055, 2), "\n")

## Train - MAPE: 30.76 | RMSE: 64641.97

cat("Test  - MAPE:", round(mape_final_test_3678055, 2),  "| RMSE:", round(rmse_final_test_3678055, 2), "\n")

## Test  - MAPE: 37.14 | RMSE: 118112.2

9.5.6 TABLA DE MÉTRICAS

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "XGBoost (Train)",
  MAPE = mape_final_train_3678055,
  RMSE = rmse_final_train_3678055
))

metricas_comparativas <- rbind(metricas_comparativas, data.frame(
  Producto = "3678055",
  Modelo = "XGBoost (Test)",
  MAPE = mape_final_test_3678055,
  RMSE = rmse_final_test_3678055
))

9.6 MÉTRICAS ARMA, REG LINEAL, RANDOM FOREST Y XGBOOST

metricas_comparativas %>%
  arrange(Producto) %>%
  knitr::kable(caption = "Métricas ARMA, Regresion Lineal, Random Forest y XGBoost por producto") %>%
  kableExtra::kable_styling(full_width = FALSE)

Métricas ARMA, Regresion Lineal, Random Forest y XGBoost por producto

Producto	Modelo	MAPE	RMSE
155001	ARMA	37.96077	109593.78
155001	ARMA (Test)	25.14259	67277.26
155001	Regresión Lineal (Train)	39.93493	111408.28
155001	Regresión Lineal (Test)	89.83537	157598.32
155001	Random Forest (Train)	18.88805	55005.66
155001	Random Forest (Test)	77.18471	138820.57
155001	XGBoost (Train)	15.15127	59186.13
155001	XGBoost (Test)	47.40820	113795.24
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
155002	Regresión Lineal (Train)	53.30857	81659.41
155002	Regresión Lineal (Test)	113.63421	140462.00
155002	Random Forest (Train)	24.90641	40622.51
155002	Random Forest (Test)	101.53221	122531.14
155002	XGBoost (Train)	17.07560	43397.75
155002	XGBoost (Test)	53.71319	122995.60
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3678055	Regresión Lineal (Train)	54.28565	82493.59
3678055	Regresión Lineal (Test)	35.22903	125404.28
3678055	Random Forest (Train)	26.16327	40659.52
3678055	Random Forest (Test)	46.57144	103169.62
3678055	XGBoost (Train)	30.76315	64641.97
3678055	XGBoost (Test)	37.13504	118112.21
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3904152	Regresión Lineal (Train)	38.98555	104128.86
3904152	Regresión Lineal (Test)	196.40268	209230.00
3904152	Random Forest (Train)	19.28014	53268.65
3904152	Random Forest (Test)	87.56263	101889.81
3904152	XGBoost (Train)	15.63334	52020.93
3904152	XGBoost (Test)	48.22606	79333.37
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08
3929788	Regresión Lineal (Train)	20.52872	53920.09
3929788	Regresión Lineal (Test)	34.22277	68189.37
3929788	Random Forest (Train)	10.27272	27004.10
3929788	Random Forest (Test)	26.95816	56210.34
3929788	XGBoost (Train)	10.57228	33358.90
3929788	XGBoost (Test)	25.98709	64972.72

10 VISUALIZACIÓN DE MÉTRICAS

# Colores personalizados por tipo de modelo base
colores_modelos <- c(
  "ARMA" = "#1f77b4",
  "ARMA (Test)" = "#aec7e8",
  "Regresión Lineal (Train)" = "#ff7f0e",
  "Regresión Lineal (Test)" = "#ffbb78",
  "Random Forest (Train)" = "#2ca02c",
  "Random Forest (Test)" = "#98df8a",
  "XGBoost (Train)" = "#d62728",
  "XGBoost (Test)" = "#ff9896"
)

# Obtener todos los productos únicos
productos <- unique(metricas_comparativas$Producto)

# Crear gráficos por producto
for (prod in productos) {
  datos_prod <- metricas_comparativas %>% filter(Producto == prod)
  
  # Gráfico de MAPE
  print(
    ggplot(datos_prod, aes(x = Modelo, y = MAPE, fill = Modelo)) +
      geom_bar(stat = "identity", width = 0.6) +
      geom_text(aes(label = round(MAPE, 1)), vjust = -0.5, size = 3.5) +
      scale_fill_manual(values = colores_modelos) +
      labs(
        title = paste("MAPE por modelo - Producto", prod),
        x = "", y = "MAPE (%)"
      ) +
      theme_minimal() +
      theme(
        legend.position = "none",
        axis.text.x = element_text(angle = 45, hjust = 1)
      ) +
      ylim(0, max(datos_prod$MAPE, na.rm = TRUE) * 1.1)
  )
  
  # Gráfico de RMSE
  print(
    ggplot(datos_prod, aes(x = Modelo, y = RMSE, fill = Modelo)) +
      geom_bar(stat = "identity", width = 0.6) +
      geom_text(aes(label = round(RMSE, 1)), vjust = -0.5, size = 3.5) +
      scale_fill_manual(values = colores_modelos) +
      labs(
        title = paste("RMSE por modelo - Producto", prod),
        x = "", y = "RMSE"
      ) +
      theme_minimal() +
      theme(
        legend.position = "none",
        axis.text.x = element_text(angle = 45, hjust = 1)
      ) +
      ylim(0, max(datos_prod$RMSE, na.rm = TRUE) * 1.1)
  )
}

11 ESTIMACIÓN DE PRECIOS

11.1 PREPARACIÓN DE DATOS

prepare_price_data <- function(df, product_id) {
  product_data <- df %>%
    filter(ID_Inventario == product_id) %>%
    arrange(Trx_Fecha) %>%
    select(
      Semana,
      Precio_Final_Unitario,
      Venta_Semana_Anterior,
      Cant_Semana_Anterior,
      Descuento_Semana_Anterior,
      Costo_Unitario_Semana_Anterior
    )

  return(product_data)
}

# Aplicar la función a todos los productos
ids <- unique(datos$ID_Inventario)

productos_preparados <- map_df(ids, function(id) {
  prepare_price_data(datos, id)
})

head(productos_preparados)

## # A tibble: 6 × 6
##   Semana Precio_Final_Unitario Venta_Semana_Anterior Cant_Semana_Anterior
##    <dbl>                 <dbl>                 <dbl>                <dbl>
## 1      1                  870.                   NA                    NA
## 2      2                  776.                78039.                   91
## 3      3                  693.               169112.                  217
## 4      4                  650.               155189.                  250
## 5      5                  641.               208317.                  320
## 6      6                  629.               205799.                  354
## # ℹ 2 more variables: Descuento_Semana_Anterior <dbl>,
## #   Costo_Unitario_Semana_Anterior <dbl>

11.2 PRECIOS SIMULADOS

simular_escenarios_precio <- function(df, product_id, n = 20, semanas_a_simular = 8) {
  # Filtrar datos del producto
  data_producto <- df %>% filter(ID_Inventario == product_id)

  # Calcular rango histórico de precios (percentil 5% a 95%) usando Precio_Final_Unitario
  precio_min <- quantile(data_producto$Precio_Final_Unitario, 0.05, na.rm = TRUE)
  precio_max <- quantile(data_producto$Precio_Final_Unitario, 0.95, na.rm = TRUE)

  # Crear vector de precios simulados
  precios_simulados <- seq(precio_min, precio_max, length.out = n)

  # Obtener última semana y fecha
  ultima_fila <- data_producto %>% arrange(desc(Semana)) %>% .[1, ]
  ultima_semana <- ultima_fila$Semana
  ultima_fecha <- ultima_fila$Trx_Fecha

  # Expandir combinaciones: semanas futuras × precios simulados
  simulacion <- expand.grid(
    Semana = ultima_semana + 1:semanas_a_simular,
    Precio_Final_Unitario = precios_simulados  
  ) %>%
    mutate(
      ID_Inventario = product_id,
      Venta_Semana_Anterior = ultima_fila$Venta_Semana_Anterior,
      Cant_Semana_Anterior = ultima_fila$Cant_Semana_Anterior,
      Descuento_Semana_Anterior = ultima_fila$Descuento_Semana_Anterior,
      Costo_Unitario_Semana_Anterior = ultima_fila$Costo_Unitario_Semana_Anterior,
      Trx_Fecha = ultima_fecha + 7 * (Semana - ultima_semana)
    )

  return(simulacion)
}

11.2.1 APLICAR SIMULACIONES A TODOS LOS PRODUCTOS

productos_ids <- unique(datos$ID_Inventario)  # o usa top_ids si ya los definiste

simulaciones_precio_lista <- setNames(
  lapply(productos_ids, function(id) simular_escenarios_precio(datos, id)),
  productos_ids
)

11.2.2 ESTIMAR PRECIO ÓPTIMO POR PRODUCTO

#DEFINE LA FUNCION DE SIMULAR PRECIOS POR PRODUCTO
simular_precios_por_producto <- function(product_id, datos_hist, datos_test, modelos_xgb, columnas_modelo, devolver_todas = FALSE) {
  modelo <- modelos_xgb[[product_id]]
  
  test_producto <- datos_test %>%
    filter(ID_Inventario == as.numeric(product_id)) %>%
    select(
      Semana, Trx_Fecha,
      Precio_Lista_Unitario, Precio_Final_Unitario,
      Venta_Semana_Anterior, Cant_Semana_Anterior,
      Descuento_Semana_Anterior, Costo_Unitario_Semana_Anterior,
      Venta
    ) %>%
    mutate(Producto = product_id) %>%
    drop_na()
  
  precios_hist <- datos_hist %>%
    filter(ID_Inventario == as.numeric(product_id)) %>%
    pull(Precio_Final_Unitario)
  
  precio_min <- quantile(precios_hist, 0.05, na.rm = TRUE)
  precio_max <- quantile(precios_hist, 0.95, na.rm = TRUE)
  precios_simulados <- seq(precio_min, precio_max, length.out = 20)
  
  simulaciones <- test_producto %>%
  rowwise() %>%
  do({
    fila <- .
    sim <- tibble(
      Precio_Final_Unitario = precios_simulados,
      Venta_Semana_Anterior = fila$Venta_Semana_Anterior,
      Cant_Semana_Anterior = fila$Cant_Semana_Anterior,
      Descuento_Semana_Anterior = fila$Descuento_Semana_Anterior,
      Costo_Unitario_Semana_Anterior = fila$Costo_Unitario_Semana_Anterior,
      Semana = fila$Semana
    )
    
    X_sim <- sim %>% select(all_of(columnas_modelo)) %>% as.matrix()
    sim$Venta_Predicha <- predict(modelo, newdata = X_sim)
    
    sim <- sim %>%
      mutate(
        Producto = fila$Producto,
        Trx_Fecha = fila$Trx_Fecha,
        Precio_Lista_Unitario = fila$Precio_Lista_Unitario,
        Precio_Real = fila$Precio_Final_Unitario,
        Venta_Real = fila$Venta,
        Margen_Esperado = Venta_Predicha - Costo_Unitario_Semana_Anterior * Cant_Semana_Anterior,
        Descuento_Sugerido = 1 - Precio_Final_Unitario / Precio_Lista_Unitario,
        Descuento_Real = 1 - Precio_Real / Precio_Lista_Unitario,
        Es_Precio_Optimo = Venta_Predicha == max(Venta_Predicha, na.rm = TRUE)
      )
    
    if (devolver_todas) {
      sim
    } else {
      sim %>% filter(Es_Precio_Optimo) %>% slice_head(n = 1)
    }
  }) %>%
  ungroup()
}

modelos_xgb_final <- list(
  "155001" = modelo_xgb_final_155001,
  "3929788" = modelo_xgb_final_3929788,
  "3904152" = modelo_xgb_final_3904152,
  "155002" = modelo_xgb_final_155002,
  "3678055" = modelo_xgb_final_3678055
)

columnas_modelo <- c(
  "Precio_Final_Unitario", 
  "Venta_Semana_Anterior", 
  "Cant_Semana_Anterior", 
  "Descuento_Semana_Anterior", 
  "Costo_Unitario_Semana_Anterior", 
  "Semana"
)

11.2.3 TABLA DE SIMULACIONES DE PRECIOS

### TABLA DE SIMULACIONES DE PRECIOS
tabla_completa_simulada <- bind_rows(
  lapply(names(modelos_xgb_final), simular_precios_por_producto,
         datos_hist = datos,
         datos_test = test,
         modelos_xgb = modelos_xgb_final,
         columnas_modelo = columnas_modelo,
         devolver_todas = TRUE)
) %>%
  select(
    Producto, Semana, Trx_Fecha,
    Precio_Lista_Unitario,
    Precio_Real,
    Precio_Simulado = Precio_Final_Unitario,
    Descuento_Real,
    Descuento_Sugerido,
    Venta_Real,
    Venta_Predicha,
    Margen_Esperado,
    Es_Precio_Optimo
  )

11.2.4 TABLA DE PRECIOS CON MAYOR VENTA ESPERADA

tabla_comparativa_optimos <- bind_rows(
  lapply(names(modelos_xgb_final), simular_precios_por_producto,
         datos_hist = datos,
         datos_test = test,
         modelos_xgb = modelos_xgb_final,
         columnas_modelo = columnas_modelo,
         devolver_todas = FALSE)
) %>%
  select(
    Producto, Semana, Trx_Fecha,
    Precio_Lista_Unitario,
    Precio_Real,
    Precio_Optimo = Precio_Final_Unitario,
    Descuento_Real,
    Descuento_Sugerido,
    Venta_Real,
    Venta_Predicha,
    Margen_Esperado
  )

11.2.5 TABLA DE PRECIOS CON MAYOR VENTA ESPERADA

### TABLA DE PRECIOS CON MAYOR VENTA ESPERADA
tabla_comparativa_optimos <- bind_rows(
  lapply(names(modelos_xgb_final), simular_precios_por_producto,
         datos_hist = datos,
         datos_test = test,
         modelos_xgb = modelos_xgb_final,
         columnas_modelo = columnas_modelo,
         devolver_todas = FALSE)
) %>%
  mutate(Cantidad_Estimada = Venta_Predicha / Precio_Final_Unitario) %>%  # Precio óptimo
  select(
    Producto, Semana, Trx_Fecha,
    Precio_Lista_Unitario,
    Precio_Real,
    Precio_Optimo = Precio_Final_Unitario,
    Descuento_Real,
    Descuento_Sugerido,
    Venta_Real,
    Venta_Predicha,
    Cantidad_Estimada,
    Margen_Esperado
  )

head(tabla_comparativa_optimos)

## # A tibble: 6 × 12
##   Producto Semana Trx_Fecha  Precio_Lista_Unitario Precio_Real Precio_Optimo
##   <chr>     <dbl> <date>                     <dbl>       <dbl>         <dbl>
## 1 155001       93 2024-10-07                 5600         505.          391.
## 2 155001       94 2024-10-14                 5600         505.          391.
## 3 155001       95 2024-10-21                 5600         503.          404.
## 4 155001       96 2024-10-28                 5600         498.          404.
## 5 155001       97 2024-11-04                 5624.        503.          391.
## 6 155001       98 2024-11-11                 5736.        511.          404.
## # ℹ 6 more variables: Descuento_Real <dbl>, Descuento_Sugerido <dbl>,
## #   Venta_Real <dbl>, Venta_Predicha <dbl>, Cantidad_Estimada <dbl>,
## #   Margen_Esperado <dbl>

head(tabla_completa_simulada)

## # A tibble: 6 × 12
##   Producto Semana Trx_Fecha  Precio_Lista_Unitario Precio_Real Precio_Simulado
##   <chr>     <dbl> <date>                     <dbl>       <dbl>           <dbl>
## 1 155001       93 2024-10-07                  5600        505.            391.
## 2 155001       93 2024-10-07                  5600        505.            404.
## 3 155001       93 2024-10-07                  5600        505.            417.
## 4 155001       93 2024-10-07                  5600        505.            431.
## 5 155001       93 2024-10-07                  5600        505.            444.
## 6 155001       93 2024-10-07                  5600        505.            457.
## # ℹ 6 more variables: Descuento_Real <dbl>, Descuento_Sugerido <dbl>,
## #   Venta_Real <dbl>, Venta_Predicha <dbl>, Margen_Esperado <dbl>,
## #   Es_Precio_Optimo <lgl>

11.2.6 DESCARGAR A CSV

#write.csv(tabla_comparativa_optimos, "tabla_precios_optimos.csv", row.names = FALSE)
#write.csv(tabla_completa_simulada, "tabla_simulaciones_completas.csv", row.names = FALSE)