Análisis de Series Temporales en Ventas Retail

Definitivamente la musica estorba, por favor no la pongan!!

El manejo de \*\*series temporales\*\* es fundamental cuando trabajamos con datos que incluyen fechas y tiempos. \*\*Pandas\*\* proporciona herramientas poderosas para manipular, analizar y visualizar series temporales de manera eficiente. Aquí te explico las operaciones clave que puedes realizar con \*\*Pandas\*\* para trabajar con datos de tipo temporal. \### 1. \*\*Creación de Series Temporales\*\* \#### Crear una serie de fechas: Puedes crear una serie de fechas usando `pd.date\_range()`. ```python import pandas as pd \# Crear una serie de fechas desde el 1 de enero de 2023, con 10 días de frecuencia fechas = pd.date\_range(start='2023-01-01', periods=10, freq='D') print(fechas) ``` \#### Crear un DataFrame con una columna de fechas: ```python \# Crear un DataFrame con fechas y datos data = pd.DataFrame({ 'fecha': pd.date\_range('2023-01-01', periods=10, freq='D'), 'valor': range(10) }) print(data) ``` \### 2. \*\*Conversión de Fechas (Datetime)\*\* Si tienes una columna de fechas como texto, puedes convertirla a formato \*\*datetime\*\* usando `pd.to\_datetime()`. ```python \# Crear un DataFrame con fechas como cadenas data = pd.DataFrame({ 'fecha': \['2023-01-01', '2023-01-02', '2023-01-03'], 'valor': \[10, 20, 30] }) \# Convertir la columna 'fecha' a formato datetime data\['fecha'] = pd.to\_datetime(data\['fecha']) print(data.dtypes) ``` \### 3. \*\*Indexación y Selección por Fechas\*\* Cuando trabajas con series temporales, a menudo querrás usar las fechas como índice. Esto facilita la selección de datos basados en intervalos de tiempo. \#### Establecer una columna de fechas como índice: ```python data.set\_index('fecha', inplace=True) print(data) ``` \#### Selección de datos por fecha: ```python \# Seleccionar datos de una fecha específica print(data.loc\['2023-01-02']) \# Seleccionar datos por rango de fechas print(data.loc\['2023-01-01':'2023-01-03']) ``` \### 4. \*\*Resampling (Re-Muestreo)\*\* El \*\*resampling\*\* permite agrupar datos por diferentes frecuencias de tiempo (como días, meses, o años). Es útil para agregar, promediar o tomar la suma de datos en diferentes intervalos de tiempo. \#### Ejemplo de re-muestreo a frecuencia mensual: ```python \# Crear un DataFrame con datos diarios data = pd.DataFrame({ 'fecha': pd.date\_range(start='2023-01-01', periods=100, freq='D'), 'valor': range(100) }) data.set\_index('fecha', inplace=True) \# Re-muestrear a frecuencia mensual y sumar los valores data\_mensual = data.resample('M').sum() print(data\_mensual) ``` \#### Frecuencias comunes para resampling: \- `D`: Día. \- `M`: Mes. \- `Y`: Año. \- `H`: Hora. \- `T`: Minuto. \### 5. \*\*Shifting y Lagging\*\* El desplazamiento (`shift()`) se utiliza para mover datos hacia adelante o hacia atrás en el tiempo. Esto es útil para calcular diferencias entre períodos consecutivos. \#### Ejemplo de `shift()`: ```python \# Desplazar los valores hacia abajo data\['valor\_shift'] = data\['valor'].shift(1) print(data) ``` \#### Calcular la diferencia entre períodos: ```python \# Calcular la diferencia entre un valor y el anterior data\['diferencia'] = data\['valor'] - data\['valor'].shift(1) print(data) ``` \### 6. \*\*Ventanas Móviles (Rolling Windows)\*\* Las ventanas móviles permiten aplicar funciones (como media, suma, etc.) sobre ventanas deslizantes de datos temporales. \#### Ejemplo de media móvil: ```python \# Calcular la media móvil de 3 días data\['media\_movil'] = data\['valor'].rolling(window=3).mean() print(data) ``` \### 7. \*\*Frecuencias de Fechas Personalizadas\*\* Pandas permite trabajar con diferentes frecuencias de tiempo, no solo días o meses. Puedes crear series de tiempo con frecuencias personalizadas, como días laborables (`B`), horas (`H`), semanas (`W`), etc. \#### Ejemplo de días laborables: ```python \# Crear una serie temporal solo con días laborables fechas\_laborables = pd.date\_range(start='2023-01-01', periods=10, freq='B') print(fechas\_laborables) ``` \#### Frecuencias comunes: \- `B`: Días laborables. \- `W`: Semanas. \- `H`: Horas. \- `T` o `min`: Minutos. \- `S`: Segundos. \### 8. \*\*Visualización de Series Temporales\*\* Podemos usar \*\*Matplotlib\*\* para visualizar datos de series temporales. \#### Ejemplo de gráfico de línea para una serie temporal: ```python import matplotlib.pyplot as plt \# Crear una serie temporal con datos aleatorios data = pd.DataFrame({ 'fecha': pd.date\_range(start='2023-01-01', periods=100, freq='D'), 'valor': np.random.randn(100).cumsum() }) data.set\_index('fecha', inplace=True) \# Graficar la serie temporal data\['valor'].plot(title='Serie Temporal') plt.xlabel('Fecha') plt.ylabel('Valor') plt.show() ``` \### 9. \*\*Resampling con Agregaciones Personalizadas\*\* Además de sumar o promediar, puedes aplicar cualquier función personalizada al re-muestrear los datos. \#### Ejemplo de re-muestreo con agregación personalizada: ```python \# Re-muestrear por mes y aplicar diferentes agregaciones data\_resample = data.resample('M').agg({ 'valor': \['sum', 'mean', 'max'] }) print(data\_resample) ``` \### 10. \*\*Manipulación Avanzada de Series Temporales\*\* \#### Descomposición estacional: Puedes descomponer una serie temporal en sus componentes estacionales, tendencia y residuales usando `statsmodels`. ```python from statsmodels.tsa.seasonal import seasonal\_decompose \# Descomponer la serie temporal resultado = seasonal\_decompose(data\['valor'], model='additive', period=30) \# Graficar los resultados de la descomposición resultado.plot() plt.show() ``` \#### Ajuste de zonas horarias (time zones): Pandas permite ajustar y convertir zonas horarias de manera eficiente. ```python \# Convertir a zona horaria UTC data = data.tz\_localize('UTC') \# Convertir a una nueva zona horaria data = data.tz\_convert('America/New\_York') print(data) ``` \### Resumen de Operaciones Clave: \- \*\*`pd.date\_range()`\*\*: Para crear series de fechas. \- \*\*`pd.to\_datetime()`\*\*: Para convertir columnas de fechas. \- \*\*`set\_index()`\*\*: Para establecer fechas como índice. \- \*\*`resample()`\*\*: Para cambiar la frecuencia temporal. \- \*\*`shift()`\*\*: Para desplazar datos en el tiempo. \- \*\*`rolling()`\*\*: Para aplicar funciones sobre ventanas móviles. \- \*\*`tz\_localize()` y `tz\_convert()`\*\*: Para ajustar zonas horarias. Con estas herramientas puedes manejar series temporales de manera eficiente en Pandas. Si tienes alguna duda o quieres profundizar en un tema específico, ¡avísame!

Una forma de ver que en el Q4 del 2010 (siendo vísperas navideñas, no tuvo el impacto en ventas, como en el Q4 del 2011, donde se disparó mucho! 

Para colocar una nueva columna en una posición específica en un DataFrame de Pandas, puedes usar el método `insert()`. Este método te permite especificar el índice donde deseas insertar la nueva columna. Aquí tienes un ejemplo: ```python import pandas as pd # DataFrame de ejemplo df = pd.DataFrame({ 'A': [1, 2, 3], 'B': [4, 5, 6] }) # Insertar nueva columna 'C' en la posición 1 df.insert(1, 'C', [7, 8, 9]) print(df) ``` Esto insertará la columna 'C' en la posición 1, desplazando las demás columnas a la derecha.

El manejo de series temporales en Pandas es clave para analizar datos a lo largo del tiempo. Permite detectar tendencias, estacionalidades y fluctuaciones cíclicas en tus datos. La conversión de fechas a tipo datetime es fundamental, así como establecer la columna de tiempo como índice del DataFrame. Utilizando métodos como `resample`, puedes agrupar tus datos por periodos, ya sean días, meses o años, facilitando el análisis y la visualización. Para graficar, puedes usar Matplotlib, lo que ayuda a identificar patrones visualmente.

🟢 **Qué es un Timestamp** Un timestamp es una representación de un **momento específico en el tiempo**. Generalmente, se expresa como el número de segundos o milisegundos transcurridos desde una **fecha y hora base**, que suele ser el 1 de enero de 1970 a la medianoche UTC (Conocida como la **Epoch** en UNIX). Los timestamps pueden ser representados en diferentes unidades de tiempo. Los más comunes son:* **Segundos**: Por ejemplo, `1609459200` representa el 1 de enero de 2021. * **Milisegundos**: Por ejemplo, `1609459200000` representa el mismo momento pero en milisegundos. No confundas este concepto con formatos de fecha que generan algunos lenguajes de programación como: `YYYY-MM-DDTHH:MM:SS.sssZ` o `datetime(2024, 9, 16, 8, 48, 2, 313465)`. **¡Nunca pares de aprender!** 🚀🚀

**Manejo de series temporales en Pandas** Se refiere a trabajar con datos indexados por fechas y tiempos. Pandas facilita esta tarea con herramientas para: * **Indexación Temporal**: Utiliza fechas como índices en DataFrames o Series. * **Generación de Fechas**: Usa `pd.date_range()` y `pd.to_datetime()` para crear o convertir datos temporales. * **Resampling**: Cambia la frecuencia de los datos (por ejemplo, de diaria a mensual) con `resample()`. * **Desplazamiento**: Mueve datos en el tiempo con `shift()`. * **Rolling Windows**: Aplica funciones estadísticas a ventanas móviles con `rolling()`. Estas herramientas te permiten analizar y modelar datos temporales de manera eficiente.

 

#### **1. Cargar y Previsualizar el Dataset** file\_path = 'online\_retail.csv' df = pd.read\_csv(file\_path) print(df.head()) **Descripción**: * Carga el archivo online\_retail.csv en un DataFrame de Pandas llamado df usando read\_csv. * Muestra las primeras cinco filas del DataFrame utilizando head() para previsualizar su estructura. **Resultado**: Las primeras cinco filas del conjunto de datos, con columnas como InvoiceNo, StockCode, Description, Quantity, InvoiceDate, UnitPrice, CustomerID y Country. #### **2. Comprender la Estructura del Dataset** df.info() **Descripción**: * El método info() proporciona un resumen del conjunto de datos, incluyendo: * El número de filas. * Los nombres de las columnas. * Conteo de valores no nulos por columna. * Tipos de datos por columna. * Uso de memoria del DataFrame. **Resultado**: Un resumen de la estructura del conjunto de datos, ayudando a comprender su tamaño y la presencia de datos faltantes. #### **3. Convertir InvoiceDate a Formato Datetime** df\['InvoiceDate'] = pd.to\_datetime(df\['InvoiceDate']) df.info() **Descripción**: * Convierte la columna InvoiceDate al formato datetime64 utilizando pd.to\_datetime. * El tipo de dato actualizado se refleja en la salida de df.info(). **Resultado**: El tipo de dato de la columna InvoiceDate cambia de object a datetime64. #### **4. Eliminar Filas con InvoiceDate Faltante** df.dropna(subset=\['InvoiceDate'], inplace=True) **Descripción**: * Elimina filas donde la columna InvoiceDate tiene valores faltantes utilizando dropna. **Resultado**: Un DataFrame sin filas con valores faltantes en la columna InvoiceDate. El tamaño del conjunto de datos se reducirá. #### **5. Establecer InvoiceDate como Índice** df.set\_index('InvoiceDate', inplace=True) print(df.head()) **Descripción**: * Establece la columna InvoiceDate como el índice del DataFrame utilizando set\_index. * El DataFrame actualizado se muestra con head(). **Resultado**: Un DataFrame donde la columna InvoiceDate es ahora el índice, facilitando operaciones basadas en el tiempo. #### **6. Extraer Año, Mes, Día y Hora** df\['Year'] = df.index.year df\['Month'] = df.index.month df\['Day'] = df.index.day df\['Hour'] = df.index.hour print(df.head()) **Descripción**: * Extrae el año, mes, día y hora del índice InvoiceDate y los agrega como nuevas columnas (Year, Month, Day, Hour) en el DataFrame. **Resultado**: Un DataFrame con columnas adicionales para Year, Month, Day y Hour, útil para análisis basados en tiempo. #### **7. Filtrar Filas por Año** df\_2011 = df.loc\['2011'] print(df\_2011.head()) **Descripción**: * Filtra el conjunto de datos para incluir solo filas del año 2011 usando .loc. **Resultado**: Un subconjunto del DataFrame con filas donde InvoiceDate pertenece a 2011. #### **8. Filtrar Filas por Mes y Año** df\_dec\_2011 = df.loc\['2011-12'] print(df\_dec\_2011.head()) **Descripción**: * Filtra el conjunto de datos para incluir solo filas de diciembre de 2011 utilizando .loc con un rango de fechas. **Resultado**: Un subconjunto del DataFrame con filas donde InvoiceDate pertenece a diciembre de 2011. #### **9. Filtrar Filas por un Rango de Fechas** df\_dec\_range = df.loc\['2010-12-01':'2010-12-15'] print(df\_dec\_range.head()) **Descripción**: * Filtra el conjunto de datos para incluir filas donde InvoiceDate cae entre el 1 y el 15 de diciembre de 2010 usando .loc. **Resultado**: Un subconjunto del DataFrame con filas dentro del rango de fechas especificado. #### **10. Crear un Rango de Fechas** date\_range = pd.date\_range(start='2024-01-01', end='2024-12-31', freq='D') print(date\_range) **Descripción**: * Genera un rango de fechas desde el 1 de enero de 2024 hasta el 31 de diciembre de 2024 con frecuencia diaria usando pd.date\_range. **Resultado**: Un DatetimeIndex que contiene todas las fechas dentro del rango especificado. #### **11. Crear un DataFrame del Rango de Fechas** df\_dates = pd.DataFrame(date\_range, columns=\['Date']) print(df\_dates.head()) **Descripción**: * Crea un DataFrame df\_dates a partir del rango de fechas generado, con una sola columna llamada Date. **Resultado**: Un DataFrame que contiene las primeras filas de la columna Date.

Una pregunta. No se supone que los indices deben ser UNICOS. Como se trabaja eso si las fechas son las mismas en muchos casos.

algo que no aclaran en la clase es el uso del formato, por defecto pd.dateTime usa 'yyyy-mm-dd' cuidado si sus datos estan en un formato yankee o latino y quieren pasar a dateTime, deben verificar en que formato vienen sus datos para poder transformarlos bien a DateTime

📝 Mis apuntes de la clase Las series de tiempo representan datos en un punto determinado del tiempo, esto nos permite realizar análisis de tendencias, patrones estacionales, fluctuaciones u otros comportamientos a lo largo del tiempo. Trabajar con series de tiempo nos permite realizar operaciones complejas de forma eficiente. Por ejemplo: * Filtrado por fechas. * Remuestreo. * Análisis de tendencias.- Acceso avanzado a los datos por medio de la funcionalidad `loc`, indicando solo el año, mes o rango de fechas. Al trabajarlas con pandas debemos: * Asegurar que las columnas que contengan datos de fecha y hora tengan el formato adecuado. Se corrigen con la función `pd.to\_date()`. * Cambiar el ídice numérico del DataFrame por el valor de la columna que contenga la fecha en el formato `datetime`. Se logra con la función integrada en la instancia del DF `df.set\_index("columna", inplace=True)` El formato datetime de pandas habilita nuevas funcionalidades: * Extracción de partes especificas de la fecha (año, mes, día, nombre del mes, día de la semana, etc.). * Indexación por fechas. * Generar rango de tiempo con `pf.date\_range()`.- Manejo de datos faltantes con `interpolate`.- Etc. **Ejemplos:** ```js """ Cambiamos el indice numérico del dataframe por un indice datetime a partir de la columna InvoiceDate """ print("Indice anterior:", df.index.dtype) df.set_index("InvoiceDate", inplace=True) print("Indice nuevo:", df.index.dtype) df.head() ``` Al colocar `InvoiceDate` como índice ésta columna ya no aparece en el DataFrame, por lo tanto para acceder a sus respectivos valores lo haremos mediante la propiedad `index`. ```js print(df.index[:5]) # Extraer elementos de especificos de una fecha: print("Año", df.sample(5).index.year[:5]) print("Mes", df.sample(5).index.month[:5]) print("Nombre mes:", df.sample(5).index.month_name()) # Filtro avanzado a partir del indice tipo datetime con .loc print("Enero 2011:") display(retail_df.loc["2011-01"].sample(5)) print("Rango: desde 01/15/2011 al 15/12/2011 ") display(retail_df.loc["2011-12-01" : "2011-12-15"].sample(5)) ```

Sería interesante que en el futuro se hagan cursos de Series de Tiempo (clásica, multivariada, con machine learning, modelos avanzados etc). Es un campo con mucha demanda y transversal a varios perfiles profesionales.