Importación y análisis de datos 🤓 🔍

Aquí encontrarás una guía básica de cómo realizar una exploración de datos. Iniciando con su importación usando pandas hasta realizar análisis gráfico usando seaborn y matplotlib.

Carga y transformación de datos

pandas es una librería de python que te permitirá importar diferentes tipos de archivos tales como .csv, .xlsx, .pkl (formato de almacenamiento de modelos de ml) entre otros... también te será muy útil si necesitas crear o transformar variables. En este caso, importaremos los archivos en formato .csv que Factored ha cargado previamente en un bucket de S3 en Amazon AWS. Luego, calcularemos la matriz de correlaciones de Pearson, analizaremos cada una de las variables disponibles en el dataset y crearemos nuevas columnas usando los métodos exclusivos de pandas para trabajar con columnas tipo timestamp.

En la documentación oficial encontrarás toda la información de los métodos disponibles, una introducción a los principales conceptos de la librería y links con tutoriales.

import pandas as pd
import numpy as np

df_train = pd.read_csv("https://factored-workshops.s3.amazonaws.com/taxi-trip-duration.csv")
df_train.head()

El objetivo de este modelo es predecir el tiempo total del trayecto en taxi, por lo tanto, no podemos incluir en él la variable dropoff_datetime dado que estaríamos incluyendo en el modelo una variable con la cual se puede calcular la variable respuesta (duración del trayecto = pickup_datetime - dropoff_datetime) y por lo tanto debe ser eliminada. Este escenario es más conocido como data leakage.

df_train = df_train.drop("dropoff_datetime", axis=1)

Para revisar el tipo de dato de cada columna del data frame de pandas se puede usar la propiedad dtypes.

df_train.dtypes

df_train.dtypes

Como podemos ver, la columna pickup_datetime debería tener un formato de fecha. Sin embargo, está como string. Usando la función to_datetime() podemos convertir la columna a formato de fecha.

df_train['pickup_datetime']= pd.to_datetime(df_train['pickup_datetime'])

Teniendo la columna pickup_datetime en formato fecha podemos usar las propiedades que tiene este tipo de dato para extraer el año, mes, día de la semana y hora.

df_train["year"] = df_train["pickup_datetime"].dt.year
df_train["month"] = df_train["pickup_datetime"].dt.month
df_train["weekday"] = df_train["pickup_datetime"].dt.weekday
df_train["hour"] = df_train["pickup_datetime"].dt.hour

df_train[["pickup_datetime","year","month","weekday","hour"]].head()

Usando la propiedad shape que tienen los data frames de pandas es posible ver su dimensión (# filas, # columnas)

df_train.shape

Una forma rápida de ver las estadísticas descriptivas de las columnas del data frame es usar el método describe().

pd.set_option('display.float_format', lambda x: '%.5f' % x)
df_train.describe()

De las estadísticas descriptivas podemos concluir los siguientes puntos:

• La cantidad de pasajeros transportados va desde 0 hasta 9

• La duración puede tomar mínimo 1 segundo y máximo 3'526.282 segundos que aproximadamente son 5.938 horas (¿Estos datos tienen sentido?) Es importante revisar si existen datos atípicos.

• Los datos corresponden a los meses entre enero y junio del año 2016

df_train[['id','trip_duration']].sort_values('trip_duration',ascending=False).head(n=10)

Organizando los registros en orden descendente por la variable trip_duration nos podemos dar cuenta que hay 5 registros que tienen un valor mayor a 1'900.000 segundos (Aprox. 22 días). Estos registros pueden ser calificados como outliers y por lo tanto pueden ser eliminados.

df_train = df_train[df_train['trip_duration'] < 100000]

CHECK POINT #1

Con cuántos registros y columnas queda el data set?

SOLUCIÓN CHECK POINT #1

df_train.shape

(1458640, 16)

El data set con el que inIciaremos el análisis de variables contiene 1'458.640 registros y 16 columnas.

Análisis de variables

Para iniciar el análisis de variables se recomienda revisar las distribuciones de las variables, su comportamiento bi-variado y la correlación entre estas.

Para realizar análisis de forma gráfica hay una gran variedad de librerías en Python como seaborn, matplotlib, plotly entre otras. seaborn y matplotlib son muy similares dado que seaborn es una librería basada en matplotlib pero con un diseño más sofisticado y más agradable a los ojos del usuario, plotly por su lado crea gráficos más dinámicos e interactivos.

#!pip install plotly #ejecutar este comando si no se tiene la librería de plotly instalada
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.express as px

Matriz de correlaciones

plt.subplots(figsize=(25,10))
sns.heatmap(df_train.corr(), annot = True, fmt='.1g', cmap="mako");

En algunos algoritmos como en la regresión logística es importante no incluir dos variables que estén correlacionadas dado que esto afecta los estimadores de los parámetros. Realizar este análisis nos ayudará a entender qué pares de variables están correlacionadas y dependiendo del algoritmo que estemos usando podremos decidir cuál incluir y cuál no. La correlación más usada es la correlación de Pearson. Sin embargo, también puedes usar la correlación de spearman si lo que buscas es evaluar la relación monotónica entre dos variables en lugar de la relación lineal entre ellas. Este artículo lo explica a mayor profundidad.

Variable respuesta: trip_duration

Para revisar la distribución de una variable podemos usar un boxplot dado que nos indicará cuales son los límites de los cuartiles de la variable.

fig, ax = plt.subplots()
sns.boxplot(data = df_train
             , x = "trip_duration"
             , ax = ax)
ax.set_title("Boxplot: trip duration")
ax.set_xlabel("Trip duration")

plt.show()

Dado que la variable tiene muchos outliers podemos truncar el rango del eje x de la gráfica para visualizar mejor los cuartiles. Para esto, podemos usar la opción ax.set_xlim() de matplotlib.

fig, ax = plt.subplots()
sns.boxplot(data = df_train
            , x = "trip_duration"
            , ax = ax)
ax.set_xlim(0,10000)
ax.set_title("Boxplot: Trip duration")
ax.set_xlabel("Trip duration")
plt.show()

Otra versión del boxplot para la variable trip_duration usando la librería plotly.

fig = px.box(df_train
             , x = "trip_duration"
             , labels = {"trip_duration": "Trip duration"}
             , title = "Boxplot: Trip duration")
fig.update_xaxes(range=[0, 10000])
fig.show()

Luego de ver con diferentes librerías cómo es la distribución de la variable respuesta trip_duration podemos concluir que tiene muchos outliers, el promedio de duración de 662seg (es decir, 11 minutos) y el 75% de los viajes duran 1075seg o menos (18min).

Vendor Id

Usando seaborn podemos realizar una gráfica de dispersión de datos cuando una de las variables es categórica, su nombre es stripplot.

fig, ax = plt.subplots(figsize=(12, 7))
sns.stripplot(data = df_train
              , x = "vendor_id"
              , y = "trip_duration"
              , ax = ax)
ax.set_title("Vendor Id vs. Trip duration");

Podemos ver que la mayoría de viajes del vendedor 1 están en su mayoría por debajo de 10.000 segundos (aprox. 2.7 horas), a diferencia del vendedor 2 donde hay muchos registros donde se supera este límite de tiempo.

Month

CHECK POINT #2

Cómo se vería un gráfico de dispersión de la duración del viaje en los diferentes meses del año?

SOLUCIÓN CHECK POINT #2

fig, ax = plt.subplots(figsize=(15, 8))

sns.stripplot(data = df_train , x="month" , y="trip_duration" , ax=ax)

ax.set_title("Month vs. Trip duration");

Usando los métodos groupby y agg podrás agregar las columnas y calcular métricas sobre cada agrupación.

df_train[['month', 'trip_duration']].groupby(by=['month']).agg({'trip_duration':['mean', 'count']})

En el resultado, podemos ver que alrededor de 230.000 - 240.0000 viajes se hacen por mes y la duración promedio está entre 900 y 1000 segundos (aprox. 15 - 16 min).

Hour

Usando los métodos de agregación crearemos un nuevo dataframe de pandas para poder representar estas métricas en gráficos de barra.

hour_trip = df_train[['hour', 'trip_duration']].groupby(by=['hour']).agg({'trip_duration': 'count'}).reset_index()

fig, ax = plt.subplots(figsize=(12, 7))
sns.barplot(data = hour_trip
              , x = "hour"
              , y = "trip_duration"
              , ax = ax)
ax.set_title("Trips by hour")
ax.set_xlabel("Hour")
ax.set_ylabel("Trips");

Era de esperarse que los horarios con mayor cantidad de viajes sean al finalizar la jornada laboral (6-7pm). Sin embargo, también podemos revisar el promedio de duración de los viajes dependiendo de la hora en la que inició el servicio.

fig, ax = plt.subplots(figsize=(12, 7))
sns.barplot(data = df_train
              , x = "hour"
              , y = "trip_duration"
              , ax = ax)
ax.set_title("Avg Trip Duration by hour")
ax.set_xlabel("Hour")
ax.set_ylabel("Avg Trip Duration");

Analizando la gráfica podemos ver que el tiempo promedio de viaje varía de acuerdo a la hora de inicio del viaje lo que quiere decir que la hora puede ser una variable interesante para predecir el tiempo de duración del viaje.

Weekday

weekday_trip = df_train[['weekday', 'trip_duration']].groupby(by=['weekday']).agg({'trip_duration': 'count'}).reset_index()

fig, ax = plt.subplots(figsize=(12, 7))
sns.lineplot(data = weekday_trip
              , x = "weekday"
              , y = "trip_duration"
              , ax = ax
              , markers = True
                )
ax.set_title("Trips by weekday")
ax.set_xlabel("weekday")
ax.set_ylabel("Trips");

Teniendo en cuenta la documentación de pandas sobre la función weekday podemos ver que 0 indica el día lunes y 6 el domingo. Teniendo en cuenta esto, podemos concluir que los días con mayor cantidad de viajes en taxi son los días cercanos al fin de semana, más específicamente entre jueves y sábado.

CHECK POINT #3

Grafica un barplot teniendo en cuenta el día de la semana (weekday) y el promedio de la duración del viaje (trip_duration).¿Qué puedes concluir del resultado? ¿Crees que esta variable es relevante para el modelo predictivo?

SOLUCIÓN CHECK POINT #3

fig, ax = plt.subplots(figsize=(12, 7))

sns.barplot(data = df_train , x = "weekday" , y = "trip_duration" , ax = ax)

ax.set_title("Avg Trip Duration by weekday")

ax.set_xlabel("weekday")

ax.set_ylabel("Avg Trip Duration");

Passengers

passengers_trip = df_train[['passenger_count','trip_duration']].groupby(by=['passenger_count']).agg({'trip_duration':['count','min','max',np.mean]})#.reset_index()
passengers_trip

De la tabla anterior podemos concluir:

• Los viajes de 0 pasajeros tienen la duración media más alta de todos los grupos por cantidad de pasajeros.

• La mayoría de los viajes los realiza una persona.

• La duración media de los viajes son muy similares independientemente si va 1 o 6 personas.

Pickup and dropoff borough

Con pandas también podemos hacer tablas dinámicas como las que conocemos de Excel. Para esto, usamos el método pivot_table como lo vemos a continuación.

pivot_table = pd.pivot_table(df_train, values='trip_duration', index=['pickup_borough'],
                    columns=['dropoff_borough'], aggfunc=np.mean)
pivot_table

Dado que en la tabla dinámica estamos comparando la misma métrica de promedio de duración del viaje entre diferentes destinos, podemos usar la gráfica de heatmap de seaborn para hacer la tabla más amigable con el usuario y de esta forma se pueden sacar conclusiones más rápidas.

plt.subplots(figsize=(25, 10))
sns.heatmap(pivot_table);

Podemos concluir que la combinación de locación inicial y locación final son determinantes para predecir la duración del viaje, por lo tanto, son variables que definitivamente deben estar incluidas en el modelo de predicción.

Referencias

Aquí podrás encontrar los links de la documentación de las librerías que usamos durante el workshop.

• pandas

• seaborn

• matplotlib

• plotly

Adicionalmente, te recomendamos leer el libro Python Data Science Handbook de Jake VanderPlas, donde podrás encontrar muy buen contenido sobre manejo de datos a través de numpy y pandas, visualización con matplotlib y desarrollo de modelos de machine learning con scikit-learn.

CHECK POINT #4

Agrega tu notebook a la rama que creaste, realiza el commit correspondiente y realiza merge con la rama main.