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_data_filtered.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 PREDICCIONES DE VENTAS

4 ARMA

4.1 PRODUCTO 155001

4.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
))

4.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

4.2 PRODUCTO 3929788

4.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
))

4.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

4.3 PRODUCTO 3904152

4.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
))

4.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

4.4 PRODUCTO 155002

4.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
))

4.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

4.5 PRODUCTO 3678055

4.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
))

4.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

4.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

5 REGRESION LINEAL

5.1 MAPA DE CALOR

# Variables numéricas relevantes para el modelo
vars_numericas <- c("Venta", "Precio_Lista_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))
)

5.2 PRODUCTO 155001

5.2.1 DATOS TRAIN 155001

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

5.2.2 DATOS TEST 155001

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

5.2.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_155001 <- lm(
  Venta ~ Precio_Lista_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_Lista_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_155001)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -156906  -64189  -20434   50236  496583 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)  
## (Intercept)                     3.170e+06  2.111e+06   1.502   0.1368  
## Precio_Lista_Unitario           8.572e+01  8.387e+01   1.022   0.3097  
## Venta_Semana_Anterior           4.461e-01  1.012e+00   0.441   0.6604  
## Cant_Semana_Anterior           -1.726e+02  3.965e+02  -0.435   0.6645  
## Descuento_Semana_Anterior      -3.327e+06  2.304e+06  -1.444   0.1524  
## Costo_Unitario_Semana_Anterior -9.610e+02  4.500e+02  -2.136   0.0356 *
## Semana                          6.378e+02  1.798e+03   0.355   0.7237  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 115400 on 84 degrees of freedom
## Multiple R-squared:  0.07848,    Adjusted R-squared:  0.01266 
## F-statistic: 1.192 on 6 and 84 DF,  p-value: 0.3184

# 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.43 | RMSE: 110897.6

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

## Test  - MAPE: 91.98 | RMSE: 157554.7

5.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
))

5.3 PRODUCTO 3929788

5.3.1 DATOS TRAIN

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

5.3.2 DATOS TEST

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

5.3.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3929788 <- lm(
  Venta ~ Precio_Lista_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_Lista_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3929788)
## 
## Residuals:
##    Min     1Q Median     3Q    Max 
## -98573 -40311  -2739  35274 191727 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                    -7.614e+05  6.171e+05  -1.234    0.221
## Precio_Lista_Unitario           5.303e+03  4.764e+03   1.113    0.269
## Venta_Semana_Anterior          -9.297e-01  1.081e+00  -0.860    0.392
## Cant_Semana_Anterior            2.740e+01  4.032e+01   0.679    0.499
## Descuento_Semana_Anterior       5.774e+05  1.061e+06   0.544    0.588
## Costo_Unitario_Semana_Anterior  3.958e+03  1.429e+04   0.277    0.782
## Semana                          1.098e+02  4.991e+02   0.220    0.826
## 
## Residual standard error: 56810 on 84 degrees of freedom
## Multiple R-squared:  0.2186, Adjusted R-squared:  0.1628 
## F-statistic: 3.917 on 6 and 84 DF,  p-value: 0.001689

# 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: 21.28 | RMSE: 54576.64

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

## Test  - MAPE: 31.1 | RMSE: 63311.33

5.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
))

5.4 PRODUCTO 3904152

5.4.1 DATOS TRAIN

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

5.4.2 DATOS TEST

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

5.4.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3904152 <- lm(
  Venta ~ Precio_Lista_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_Lista_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3904152)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -133328  -59334  -24284   20018  514946 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                    -2.374e+06  2.392e+06  -0.993    0.324
## Precio_Lista_Unitario          -6.233e+01  1.130e+02  -0.552    0.583
## Venta_Semana_Anterior           1.315e+00  2.608e+00   0.504    0.615
## Cant_Semana_Anterior           -4.463e+03  7.963e+03  -0.560    0.577
## Descuento_Semana_Anterior       2.897e+06  2.723e+06   1.064    0.290
## Costo_Unitario_Semana_Anterior  5.146e+02  5.884e+02   0.875    0.384
## Semana                          8.626e+02  1.122e+03   0.769    0.444
## 
## Residual standard error: 109800 on 84 degrees of freedom
## Multiple R-squared:  0.03534,    Adjusted R-squared:  -0.03356 
## F-statistic: 0.5129 on 6 and 84 DF,  p-value: 0.797

# 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: 40.71 | RMSE: 105502.9

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

## Test  - MAPE: 172.93 | RMSE: 179654

5.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
))

5.5 PRODUCTO 155002

5.5.1 DATOS TRAIN

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

5.5.2 DATOS TEST

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

5.5.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_155002 <- lm(
  Venta ~ Precio_Lista_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_Lista_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_155002)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -134141  -58576  -20356   36079  300149 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)
## (Intercept)                     1.210e+06  1.178e+06   1.026    0.308
## Precio_Lista_Unitario          -4.437e+01  5.244e+01  -0.846    0.400
## Venta_Semana_Anterior           1.150e+00  8.470e-01   1.358    0.178
## Cant_Semana_Anterior           -3.804e+02  3.487e+02  -1.091    0.278
## Descuento_Semana_Anterior      -1.029e+06  1.284e+06  -0.801    0.425
## Costo_Unitario_Semana_Anterior -1.235e+02  1.701e+02  -0.726    0.470
## Semana                          1.566e+03  1.190e+03   1.315    0.192
## 
## Residual standard error: 85160 on 84 degrees of freedom
## Multiple R-squared:  0.09501,    Adjusted R-squared:  0.03037 
## F-statistic:  1.47 on 6 and 84 DF,  p-value: 0.1985

# 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.16 | RMSE: 81814.8

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

## Test  - MAPE: 115.44 | RMSE: 140809.8

5.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
))

5.6 PRODUCTO 3678055

5.6.1 DATOS TRAIN

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

5.6.2 DATOS TEST

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

5.6.3 MODELO

# Ajustar modelo con entrenamiento
modelo_regresion_3678055 <- lm(
  Venta ~ Precio_Lista_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_Lista_Unitario + Venta_Semana_Anterior + 
##     Cant_Semana_Anterior + Descuento_Semana_Anterior + Costo_Unitario_Semana_Anterior + 
##     Semana, data = datos_3678055)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -139903  -47687  -13196   34789  355470 
## 
## Coefficients:
##                                  Estimate Std. Error t value Pr(>|t|)  
## (Intercept)                     1.967e+06  1.509e+06   1.303   0.1961  
## Precio_Lista_Unitario           7.866e+01  4.066e+01   1.935   0.0564 .
## Venta_Semana_Anterior          -2.438e+00  2.009e+00  -1.214   0.2282  
## Cant_Semana_Anterior            1.272e+04  1.029e+04   1.236   0.2199  
## Descuento_Semana_Anterior      -2.960e+06  1.783e+06  -1.660   0.1006  
## Costo_Unitario_Semana_Anterior -2.642e+02  1.985e+02  -1.331   0.1868  
## Semana                         -7.349e+02  5.960e+02  -1.233   0.2210  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 84030 on 84 degrees of freedom
## Multiple R-squared:  0.05395,    Adjusted R-squared:  -0.01363 
## F-statistic: 0.7983 on 6 and 84 DF,  p-value: 0.5739

# 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: 53.36 | RMSE: 80733.94

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

## Test  - MAPE: 63.93 | RMSE: 146190.7

5.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
))

5.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.43046	110897.56
155001	Regresión Lineal (Test)	91.97987	157554.70
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
155002	Regresión Lineal (Train)	53.15643	81814.80
155002	Regresión Lineal (Test)	115.43616	140809.84
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3678055	Regresión Lineal (Train)	53.36169	80733.94
3678055	Regresión Lineal (Test)	63.92659	146190.72
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3904152	Regresión Lineal (Train)	40.71452	105502.91
3904152	Regresión Lineal (Test)	172.92634	179653.99
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08
3929788	Regresión Lineal (Train)	21.27972	54576.64
3929788	Regresión Lineal (Test)	31.09822	63311.33

6 RANDOM FOREST

6.1 PRODUCTO 155001

# Entrenamiento
set.seed(123)
modelo_rf_155001 <- randomForest(
  Venta ~ Precio_Lista_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: 20.1 | RMSE: 57033.51

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

## Test  - MAPE: 84.28 | RMSE: 149257.5

# 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: -80614.77

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

## SD error: 130743.9

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

## Min error: -226994.8

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

## Max error: 250340.7

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

## Mediana error: -117253.6

# 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()

6.2 PRODUCTO 3929788

# Entrenamiento
set.seed(123)
modelo_rf_3929788 <- randomForest(
  Venta ~ Precio_Lista_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.71 | RMSE: 27422.69

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

## Test  - MAPE: 27.3 | RMSE: 55819.49

# 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: -17708.08

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

## SD error: 55097.72

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

## Min error: -95314.91

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

## Max error: 64932.72

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

## Mediana error: -22465.42

# 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()

6.3 PRODUCTO 3904152

# Entrenamiento
set.seed(123)
modelo_rf_3904152 <- randomForest(
  Venta ~ Precio_Lista_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: 21.27 | RMSE: 55972.1

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

## Test  - MAPE: 100.42 | RMSE: 113611.6

# 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: -79780.87

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

## SD error: 84189.19

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

## Min error: -244974.8

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

## Max error: 118473.8

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

## Mediana error: -74410.38

# 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()

6.4 PRODUCTO 155002

# Entrenamiento
set.seed(123)
modelo_rf_155002 <- randomForest(
  Venta ~ Precio_Lista_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: 25.66 | RMSE: 41348.42

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

## Test  - MAPE: 98.59 | RMSE: 122127.5

# 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: -7257.753

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

## SD error: 126889.6

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

## Min error: -121491.7

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

## Max error: 230978.1

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

## Mediana error: -52340.74

# 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()

6.5 PRODUCTO 3678055

# Entrenamiento
set.seed(123)
modelo_rf_3678055 <- randomForest(
  Venta ~ Precio_Lista_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: 27.52 | RMSE: 43093.85

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

## Test  - MAPE: 46.34 | RMSE: 104012.2

# 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: 5261.388

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

## SD error: 108120.8

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

## Min error: -106177.6

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

## Max error: 211300.5

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

## Mediana error: -29431.4

# 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()

6.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.43046	110897.56
155001	Regresión Lineal (Test)	91.97987	157554.70
155001	Random Forest (Train)	20.09631	57033.51
155001	Random Forest (Test)	84.27831	149257.49
155002	ARMA	51.33213	82260.20
155002	ARMA (Test)	35.86659	87005.41
155002	Regresión Lineal (Train)	53.15643	81814.80
155002	Regresión Lineal (Test)	115.43616	140809.84
155002	Random Forest (Train)	25.66472	41348.42
155002	Random Forest (Test)	98.59409	122127.47
3678055	ARMA	54.27943	82835.18
3678055	ARMA (Test)	53.77550	105823.13
3678055	Regresión Lineal (Train)	53.36169	80733.94
3678055	Regresión Lineal (Test)	63.92659	146190.72
3678055	Random Forest (Train)	27.51874	43093.85
3678055	Random Forest (Test)	46.33560	104012.22
3904152	ARMA	41.54527	99993.25
3904152	ARMA (Test)	18.70572	50062.24
3904152	Regresión Lineal (Train)	40.71452	105502.91
3904152	Regresión Lineal (Test)	172.92634	179653.99
3904152	Random Forest (Train)	21.27422	55972.10
3904152	Random Forest (Test)	100.42105	113611.58
3929788	ARMA	21.74312	57634.89
3929788	ARMA (Test)	26.25704	60053.08
3929788	Regresión Lineal (Train)	21.27972	54576.64
3929788	Regresión Lineal (Test)	31.09822	63311.33
3929788	Random Forest (Train)	10.71016	27422.69
3929788	Random Forest (Test)	27.30344	55819.49

7 XGBOOST

7.1 PRODUCTO 155001

7.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)

7.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      40
## 144 0.10         7       1.0              1.0                3   0.1      28
## 50  0.05         5       1.0              0.8                3   0.0      52
## 92  0.05         3       0.8              1.0                1   0.1      52
## 137 0.05         3       1.0              1.0                3   0.1      50
##         rmse
## 14  115100.4
## 144 118133.5
## 50  119155.6
## 92  121703.3
## 137 128796.5

7.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: 40

# 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
)

7.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: 16.95 | RMSE: 70636.75

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

## Test  Split - MAPE: 32.56 | RMSE: 100938.8

7.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: 16.81 | RMSE: 70510.56

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

## Test  - MAPE: 52.38 | RMSE: 118506.1

7.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
))

7.2 PRODUCTO 3929788

7.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)

7.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      73
## 92  0.05         3       0.8              1.0                1   0.1      62
## 14  0.05         5       1.0              0.8                1   0.0      62
## 137 0.05         3       1.0              1.0                3   0.1      60
## 90  0.10         7       1.0              0.8                1   0.1      42
##         rmse
## 50  62368.41
## 92  65177.57
## 14  67389.64
## 137 68110.39
## 90  68267.39

7.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: 73

# 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
)

7.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: 7.8 | RMSE: 24355.45

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

## Test  Split - MAPE: 15.62 | RMSE: 38020.87

7.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: 7.23 | RMSE: 23132.47

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

## Test  - MAPE: 23.4 | RMSE: 51416.15

7.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
))

7.3 PRODUCTO 3904152

7.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)

7.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
## 14  0.05         5         1              0.8                1   0.0      59
## 90  0.10         7         1              0.8                1   0.1      20
## 137 0.05         3         1              1.0                3   0.1      35
## 50  0.05         5         1              0.8                3   0.0      53
## 144 0.10         7         1              1.0                3   0.1      19
##          rmse
## 14   92882.68
## 90  100172.09
## 137 100746.74
## 50  101240.21
## 144 101622.69

7.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] 1
## 
## $gamma
## [1] 0

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

## Número óptimo de rondas: 59

# 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
)

7.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: 11.9 | RMSE: 36737.11

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

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

7.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: 11.79 | RMSE: 38513.37

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

## Test  - MAPE: 48.62 | RMSE: 82356.39

7.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
))

7.4 PRODUCTO 155002

7.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)

7.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
## 92  0.05         3       0.8              1.0                1   0.1      43
## 144 0.10         7       1.0              1.0                3   0.1      27
## 14  0.05         5       1.0              0.8                1   0.0      37
## 90  0.10         7       1.0              0.8                1   0.1      16
## 50  0.05         5       1.0              0.8                3   0.0      35
##         rmse
## 92  90353.92
## 144 91480.70
## 14  93025.91
## 90  93774.01
## 50  96099.56

7.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] 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_155002, "\n")

## Número óptimo de rondas: 43

# 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
)

7.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: 27.01 | RMSE: 57429.86

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

## Test  Split - MAPE: 37.53 | RMSE: 89854.05

7.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: 27.16 | RMSE: 59553.9

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

## Test  - MAPE: 60.72 | RMSE: 122704.9

7.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
))

7.5 PRODUCTO 3678055

7.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)

7.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
## 50  0.05         5       1.0              0.8                3   0.0      49
## 90  0.10         7       1.0              0.8                1   0.1      22
## 144 0.10         7       1.0              1.0                3   0.1      26
## 137 0.05         3       1.0              1.0                3   0.1      57
## 92  0.05         3       0.8              1.0                1   0.1      36
##         rmse
## 50  88366.96
## 90  88801.94
## 144 89648.04
## 137 90489.76
## 92  91050.69

7.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] 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_3678055, "\n")

## Número óptimo de rondas: 49

# 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
)

7.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: 23.33 | RMSE: 51393.09

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

## Test  Split - MAPE: 50.81 | RMSE: 89464.46

7.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: 24 | RMSE: 50249.95

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

## Test  - MAPE: 37.84 | RMSE: 116478.2

7.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
))

7.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.960773	109593.78
155001	ARMA (Test)	25.142587	67277.26
155001	Regresión Lineal (Train)	39.430456	110897.56
155001	Regresión Lineal (Test)	91.979875	157554.70
155001	Random Forest (Train)	20.096308	57033.51
155001	Random Forest (Test)	84.278314	149257.49
155001	XGBoost (Train)	16.806958	70510.56
155001	XGBoost (Test)	52.377346	118506.06
155002	ARMA	51.332134	82260.20
155002	ARMA (Test)	35.866590	87005.41
155002	Regresión Lineal (Train)	53.156430	81814.80
155002	Regresión Lineal (Test)	115.436164	140809.84
155002	Random Forest (Train)	25.664720	41348.42
155002	Random Forest (Test)	98.594093	122127.47
155002	XGBoost (Train)	27.161236	59553.90
155002	XGBoost (Test)	60.717951	122704.95
3678055	ARMA	54.279431	82835.18
3678055	ARMA (Test)	53.775496	105823.13
3678055	Regresión Lineal (Train)	53.361690	80733.94
3678055	Regresión Lineal (Test)	63.926587	146190.72
3678055	Random Forest (Train)	27.518738	43093.85
3678055	Random Forest (Test)	46.335602	104012.22
3678055	XGBoost (Train)	24.001673	50249.95
3678055	XGBoost (Test)	37.839720	116478.24
3904152	ARMA	41.545269	99993.25
3904152	ARMA (Test)	18.705723	50062.24
3904152	Regresión Lineal (Train)	40.714517	105502.91
3904152	Regresión Lineal (Test)	172.926337	179653.99
3904152	Random Forest (Train)	21.274221	55972.10
3904152	Random Forest (Test)	100.421047	113611.58
3904152	XGBoost (Train)	11.787404	38513.37
3904152	XGBoost (Test)	48.616251	82356.39
3929788	ARMA	21.743123	57634.89
3929788	ARMA (Test)	26.257042	60053.08
3929788	Regresión Lineal (Train)	21.279719	54576.64
3929788	Regresión Lineal (Test)	31.098224	63311.33
3929788	Random Forest (Train)	10.710160	27422.69
3929788	Random Forest (Test)	27.303435	55819.49
3929788	XGBoost (Train)	7.225458	23132.47
3929788	XGBoost (Test)	23.403897	51416.15

8 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)
  )
}

9 ESTIMACIÓN DE PRECIOS

9.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_Lista_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_Lista_Unitario Venta_Semana_Anterior Cant_Semana_Anterior
##    <dbl>                 <dbl>                 <dbl>                <dbl>
## 1      1                 4192.                   NA                    NA
## 2      2                 4192.                78039.                   91
## 3      3                 4192.               169112.                  217
## 4      4                 4192.               155189.                  250
## 5      5                 4192.               208317.                  320
## 6      6                 4192.               205799.                  354
## # ℹ 2 more variables: Descuento_Semana_Anterior <dbl>,
## #   Costo_Unitario_Semana_Anterior <dbl>

9.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%)
  precio_min <- quantile(data_producto$Precio_Lista_Unitario, 0.05, na.rm = TRUE)
  precio_max <- quantile(data_producto$Precio_Lista_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_Lista_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)
}

9.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
)

9.2.2 ESTIMAR PRECIO ÓPTIMO POR PRODUCTO

# Variables del modelo
columnas_modelo <- c(
  "Precio_Lista_Unitario", 
  "Venta_Semana_Anterior", 
  "Cant_Semana_Anterior", 
  "Descuento_Semana_Anterior", 
  "Costo_Unitario_Semana_Anterior", 
  "Semana"
)

# Lista de modelos entrenados
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
)

# Inicializar listas
resultados_simulacion_completa <- list()
tabla_resumen_optimos <- list()

# Función para estimar precio óptimo para SOLO la siguiente semana
encontrar_precio_optimo <- function(product_id) {
  # Filtrar datos históricos del producto
  data_producto <- datos %>% filter(ID_Inventario == product_id)

  # Obtener última semana y última fecha
  ultima_fila <- data_producto %>% arrange(desc(Semana)) %>% slice_head(n = 1)
  ultima_semana <- ultima_fila$Semana
  ultima_fecha <- ultima_fila$Trx_Fecha

  # Simular rango de precios posibles (percentil 5% - 95%)
  precio_min <- quantile(data_producto$Precio_Lista_Unitario, 0.05, na.rm = TRUE)
  precio_max <- quantile(data_producto$Precio_Lista_Unitario, 0.95, na.rm = TRUE)
  precios_simulados <- seq(precio_min, precio_max, length.out = 20)

  # Crear tabla simulada (1 semana + 20 precios)
  simulacion <- data.frame(
    Producto = product_id,
    Semana = ultima_semana + 1,
    Precio_Lista_Unitario = precios_simulados,
    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
  )

  # Predecir ventas con el modelo
  X_sim <- simulacion %>% select(all_of(columnas_modelo)) %>% as.matrix()
  modelo <- modelos_xgb_final[[as.character(product_id)]]
  simulacion$Venta_Predicha <- predict(modelo, newdata = X_sim)

  # Calcular margen
  simulacion$Margen_Esperado <- simulacion$Venta_Predicha - 
    simulacion$Costo_Unitario_Semana_Anterior * simulacion$Cant_Semana_Anterior

  # Guardar simulación completa
  resultados_simulacion_completa[[as.character(product_id)]] <<- simulacion

  # Obtener precio con mayor venta esperada
  mejor_fila <- simulacion %>% filter(Venta_Predicha == max(Venta_Predicha, na.rm = TRUE)) %>% slice_head(n = 1)
  tabla_resumen_optimos[[as.character(product_id)]] <<- mejor_fila %>%
    select(Producto, Trx_Fecha, Precio_Lista_Unitario, Venta_Predicha, Margen_Esperado) %>%
    rename(
      Fecha_Simulada = Trx_Fecha,
      Precio_Optimo = Precio_Lista_Unitario,
      Venta_Esperada = Venta_Predicha
    )

  # Mostrar en consola
  cat("Producto:", product_id, "\n")
  cat("Precio óptimo:", round(mejor_fila$Precio_Lista_Unitario, 2), "\n")
  cat("Venta esperada:", round(mejor_fila$Venta_Predicha, 2), "\n")
  cat("Margen esperado:", round(mejor_fila$Margen_Esperado, 2), "\n")
  cat("Fecha simulada:", as.character(mejor_fila$Trx_Fecha), "\n\n")
}

# Ejecutar simulación para todos los productos
for (id in names(modelos_xgb_final)) {
  encontrar_precio_optimo(id)
}

## Producto: 155001 
## Precio óptimo: 4355.19 
## Venta esperada: 251473.6 
## Margen esperado: 159476.7 
## Fecha simulada: 2025-01-06 
## 
## Producto: 3929788 
## Precio óptimo: 109.08 
## Venta esperada: 210494.3 
## Margen esperado: 112793.9 
## Fecha simulada: 2025-01-06 
## 
## Producto: 3904152 
## Precio óptimo: 9053.8 
## Venta esperada: 159336.3 
## Margen esperado: 96391.84 
## Fecha simulada: 2025-01-06 
## 
## Producto: 155002 
## Precio óptimo: 4845.41 
## Venta esperada: 142955.7 
## Margen esperado: 98476.9 
## Fecha simulada: 2025-01-06 
## 
## Producto: 3678055 
## Precio óptimo: 15968.4 
## Venta esperada: 198139.2 
## Margen esperado: 89879.27 
## Fecha simulada: 2025-01-06

# Tablas finales
tabla_simulacion_completa <- bind_rows(resultados_simulacion_completa)
tabla_precios_optimos <- bind_rows(tabla_resumen_optimos)

# Mostrar tabla resumen
print(tabla_precios_optimos)

##   Producto Fecha_Simulada Precio_Optimo Venta_Esperada Margen_Esperado
## 1   155001     2025-01-06     4355.1946       251473.6       159476.70
## 2  3929788     2025-01-06      109.0774       210494.3       112793.90
## 3  3904152     2025-01-06     9053.8000       159336.3        96391.84
## 4   155002     2025-01-06     4845.4059       142955.7        98476.90
## 5  3678055     2025-01-06    15968.4000       198139.2        89879.27

9.2.3 EXPORTAR A CSV

# Exportar a CSV si deseas
write.csv(tabla_simulacion_completa, "simulaciones_todas.csv", row.names = FALSE)
write.csv(tabla_precios_optimos, "precios_optimos_resumen.csv", row.names = FALSE)

9.3 SIMULACIÓN DE DIFERENTES DESCUENTOS

9.3.1 ENCONTRAR DESCUENTOS RECURRENTES

rangos_descuento <- datos %>%
  group_by(ID_Inventario) %>%
  summarise(
    Desc_min = quantile(Descuento_Semana_Anterior, 0.05, na.rm = TRUE),
    Desc_max = quantile(Descuento_Semana_Anterior, 0.95, na.rm = TRUE)
  )

9.3.2 SIMULAR DIFERENTES DESCUENTOS A LOS PRECIOS ÓPTIMOS

# Crear lista con simulaciones por producto
simular_descuentos <- function(product_id, modelo, precio_optimo, datos_base, n_sim = 10) {
  datos_producto <- datos_base %>% filter(ID_Inventario == as.numeric(product_id))
  
  # Última fila observada (corregido sin slice)
  ultima_fila <- datos_producto %>%
    arrange(desc(Semana)) %>%
    head(1)
  
  # Rango de descuentos históricos
  r <- rangos_descuento %>% filter(ID_Inventario == as.numeric(product_id))
  descuentos_simulados <- seq(r$Desc_min, r$Desc_max, length.out = n_sim)
  
  # Datos simulados
  simulacion <- data.frame(
    Producto = product_id,
    Precio_Lista_Unitario = precio_optimo,
    Descuento_Semana_Anterior = descuentos_simulados
  ) %>%
    mutate(
      Semana = ultima_fila$Semana + 1,
      Trx_Fecha = max(datos_producto$Trx_Fecha, na.rm = TRUE) + 7,
      Precio_Final_Unitario = Precio_Lista_Unitario * (1 - Descuento_Semana_Anterior),
      Venta_Semana_Anterior = ultima_fila$Venta_Semana_Anterior,
      Cant_Semana_Anterior = ultima_fila$Cant_Semana_Anterior,
      Costo_Unitario_Semana_Anterior = ultima_fila$Costo_Unitario_Semana_Anterior
    )
  
  # Variables usadas en el modelo
  columnas_modelo <- c(
    "Precio_Lista_Unitario",
    "Venta_Semana_Anterior",
    "Cant_Semana_Anterior",
    "Descuento_Semana_Anterior",
    "Costo_Unitario_Semana_Anterior",
    "Semana"
  )
  
  # Predicción y margen
  X_sim <- simulacion %>% select(all_of(columnas_modelo)) %>% as.matrix()
  simulacion$Venta_Predicha <- predict(modelo, newdata = X_sim)
  simulacion$Margen_Esperado <- simulacion$Venta_Predicha -
    simulacion$Costo_Unitario_Semana_Anterior * simulacion$Cant_Semana_Anterior
  
  return(simulacion)
}

9.3.3 PREDECIR VENTA PARA CADA DESCUENTO CON MODELO DE XGBOOST

# Generar simulaciones de descuentos para todos los productos con modelo XGBoost
simulaciones_descuentos <- bind_rows(
  lapply(names(modelos_xgb_final), function(id) {
    precio_optimo <- tabla_precios_optimos %>%
      filter(Producto == id) %>%
      pull(Precio_Optimo)

    simular_descuentos(
      product_id = id,
      modelo = modelos_xgb_final[[id]],
      precio_optimo = precio_optimo,
      datos_base = datos
    )
  })
)

# Crear tabla final para análisis o Power BI
tabla_descuentos_final <- simulaciones_descuentos %>%
  select(
    Producto,
    Precio_Lista_Unitario,
    Descuento_Semana_Anterior,
    Precio_Final_Unitario,
    Venta_Predicha,
    Margen_Esperado,
    Semana_Simulada = Semana,
    Trx_Fecha
  )

# Mostrar
print(tabla_descuentos_final)

##    Producto Precio_Lista_Unitario Descuento_Semana_Anterior
## 1    155001             4355.1946                 0.8467751
## 2    155001             4355.1946                 0.8539122
## 3    155001             4355.1946                 0.8610492
## 4    155001             4355.1946                 0.8681863
## 5    155001             4355.1946                 0.8753233
## 6    155001             4355.1946                 0.8824604
## 7    155001             4355.1946                 0.8895974
## 8    155001             4355.1946                 0.8967345
## 9    155001             4355.1946                 0.9038715
## 10   155001             4355.1946                 0.9110086
## 11  3929788              109.0774                 0.5951061
## 12  3929788              109.0774                 0.5982788
## 13  3929788              109.0774                 0.6014515
## 14  3929788              109.0774                 0.6046243
## 15  3929788              109.0774                 0.6077970
## 16  3929788              109.0774                 0.6109697
## 17  3929788              109.0774                 0.6141424
## 18  3929788              109.0774                 0.6173151
## 19  3929788              109.0774                 0.6204879
## 20  3929788              109.0774                 0.6236606
## 21  3904152             9053.8000                 0.6347199
## 22  3904152             9053.8000                 0.6395330
## 23  3904152             9053.8000                 0.6443462
## 24  3904152             9053.8000                 0.6491594
## 25  3904152             9053.8000                 0.6539725
## 26  3904152             9053.8000                 0.6587857
## 27  3904152             9053.8000                 0.6635989
## 28  3904152             9053.8000                 0.6684120
## 29  3904152             9053.8000                 0.6732252
## 30  3904152             9053.8000                 0.6780384
## 31   155002             4845.4059                 0.8495091
## 32   155002             4845.4059                 0.8564245
## 33   155002             4845.4059                 0.8633399
## 34   155002             4845.4059                 0.8702553
## 35   155002             4845.4059                 0.8771707
## 36   155002             4845.4059                 0.8840861
## 37   155002             4845.4059                 0.8910015
## 38   155002             4845.4059                 0.8979169
## 39   155002             4845.4059                 0.9048324
## 40   155002             4845.4059                 0.9117478
## 41  3678055            15968.4000                 0.6340998
## 42  3678055            15968.4000                 0.6392601
## 43  3678055            15968.4000                 0.6444205
## 44  3678055            15968.4000                 0.6495808
## 45  3678055            15968.4000                 0.6547412
## 46  3678055            15968.4000                 0.6599016
## 47  3678055            15968.4000                 0.6650619
## 48  3678055            15968.4000                 0.6702223
## 49  3678055            15968.4000                 0.6753827
## 50  3678055            15968.4000                 0.6805430
##    Precio_Final_Unitario Venta_Predicha Margen_Esperado Semana_Simulada
## 1              667.32415       269381.6       177384.74             106
## 2              636.24090       269381.6       177384.74             106
## 3              605.15765       271662.0       179665.12             106
## 4              574.07440       271662.0       179665.12             106
## 5              542.99115       271662.0       179665.12             106
## 6              511.90791       271662.0       179665.12             106
## 7              480.82466       271662.0       179665.12             106
## 8              449.74141       269093.3       177096.40             106
## 9              418.65816       269093.3       177096.40             106
## 10             387.57491       245710.2       153713.34             106
## 11              44.16476       210494.3       112793.90             106
## 12              43.81868       210196.6       112496.18             106
## 13              43.47261       215483.8       117783.35             106
## 14              43.12654       224006.4       126305.96             106
## 15              42.78047       234689.0       136988.59             106
## 16              42.43440       233632.5       135932.10             106
## 17              42.08832       232267.2       134566.84             106
## 18              41.74225       236398.7       138698.28             106
## 19              41.39618       235936.2       138235.78             106
## 20              41.05011       235936.2       138235.78             106
## 21            3307.17324       163836.4       100891.92             106
## 22            3263.59581       162644.8        99700.36             106
## 23            3220.01837       162644.8        99700.36             106
## 24            3176.44094       162644.8        99700.36             106
## 25            3132.86351       163903.0       100958.55             106
## 26            3089.28607       160996.2        98051.75             106
## 27            3045.70864       159336.3        96391.84             106
## 28            3002.13120       159336.3        96391.84             106
## 29            2958.55377       159336.3        96391.84             106
## 30            2914.97634       142735.7        79791.30             106
## 31             729.18947       125074.2        80595.32             106
## 32             695.68152       136966.0        92487.12             106
## 33             662.17357       136966.0        92487.12             106
## 34             628.66563       136966.0        92487.12             106
## 35             595.15768       143229.6        98750.80             106
## 36             561.64973       143229.6        98750.80             106
## 37             528.14178       139715.8        95236.96             106
## 38             494.63384       139715.8        95236.96             106
## 39             461.12589       137669.7        93190.87             106
## 40             427.61794       142955.7        98476.90             106
## 41            5842.84153       210851.4       102591.55             106
## 42            5760.43877       208761.7       100501.85             106
## 43            5678.03601       210637.1       102377.18             106
## 44            5595.63326       210637.1       102377.18             106
## 45            5513.23050       210452.2       102192.30             106
## 46            5430.82774       205363.9        97104.01             106
## 47            5348.42498       199879.7        91619.85             106
## 48            5266.02223       180325.8        72065.90             106
## 49            5183.61947       179498.3        71238.40             106
## 50            5101.21671       179498.3        71238.40             106
##     Trx_Fecha
## 1  2025-01-06
## 2  2025-01-06
## 3  2025-01-06
## 4  2025-01-06
## 5  2025-01-06
## 6  2025-01-06
## 7  2025-01-06
## 8  2025-01-06
## 9  2025-01-06
## 10 2025-01-06
## 11 2025-01-06
## 12 2025-01-06
## 13 2025-01-06
## 14 2025-01-06
## 15 2025-01-06
## 16 2025-01-06
## 17 2025-01-06
## 18 2025-01-06
## 19 2025-01-06
## 20 2025-01-06
## 21 2025-01-06
## 22 2025-01-06
## 23 2025-01-06
## 24 2025-01-06
## 25 2025-01-06
## 26 2025-01-06
## 27 2025-01-06
## 28 2025-01-06
## 29 2025-01-06
## 30 2025-01-06
## 31 2025-01-06
## 32 2025-01-06
## 33 2025-01-06
## 34 2025-01-06
## 35 2025-01-06
## 36 2025-01-06
## 37 2025-01-06
## 38 2025-01-06
## 39 2025-01-06
## 40 2025-01-06
## 41 2025-01-06
## 42 2025-01-06
## 43 2025-01-06
## 44 2025-01-06
## 45 2025-01-06
## 46 2025-01-06
## 47 2025-01-06
## 48 2025-01-06
## 49 2025-01-06
## 50 2025-01-06

9.3.4 EXPORTAR A CSV

# Exportar la tabla final de descuentos simulados
write.csv(tabla_descuentos_final, "tabla_descuentos_simulados.csv", row.names = FALSE)

cat("Archivo 'tabla_descuentos_simulados.csv' guardado exitosamente en el directorio de trabajo.\n")

## Archivo 'tabla_descuentos_simulados.csv' guardado exitosamente en el directorio de trabajo.