Estructuras de dataframes en detalle

Para tranformar dtype object a datetime:

pd.to_datetime(
    df_meteorites['year'],
    errors = 'coerce',
    format ='%m/%d/%Y %H:%M:%S %p'
)

Pipelines de procesamiento para variables categóricas

.
Cuando se tiene variables categóricas se hace un mapeo numérico. Para eso hay 2 métodos, de manera que sean fácilmente interpretables en modelos de machine learning:
.

• Dummy: Es la representación más compacta que se puede tener de los datos. Es mejor usarla cuando los inputs son variables linealmente independientes (no tienen un grado de correlación significativo). Es decir, las cuando se sabe que las categorías son independientes entre sí.

• One-hot: Es más extenso. Permite incluir categorías que no estaban en el dataset inicialmente. De forma que si se filtra una categoría que no estaba incluida, igual se pueda representar numéricamente y no de error en el modelo (este modelo es más cool y es el que se usa).

.

Hay errores en la notación de Pandas y los tratan como que ambos modelos son lo mismo, pero en la realidad el Dummy no se usa. Aún así, en Pandas el método es .get_dummies() para realizar un procesamiento one-hot.
.

Podemos utilizar tambié:

df = pd.read_csv(‘filename.csv’, parse_dates=[‘file_date’])

Otra forma de ver las columnas de un Dataframe sin usar list, es:

df_meteorites.columns

Por si le sirve a alguien, el archivo actual descarga la columna ‘year’ solo con el año, por lo que para cambiarla a formato Datetime, solo tienen que poner en format = ‘%Y’ , de lo contrario les va da error.

pd.to_datetime(
    df_meteorites['year'],
    errors='coerce',
    format= '%Y' 

¿Qué vamos a aprender en esta clase?

Aprenderemos en detalle las diferentes variables que podemos llegar a encontrar en un mismo dataframe como variables categóricas, tipo tiempo, de texto, numéricas como float y enteras.

Nota: Recordemos que una gran ventaja de trabajar con variables categóricas es que se reduce el uso de memoria ram y también el espacio que ocupan los archivos.

Fixing a data type

.

• object -> Python strings (or other Python objects)
• bool -> enables logical and mathematical operations
• int -> mathematical operations can be performed
• float -> mathematical operations can be performed
• category -> results in less memory usage and faster processing
• datetime -> enables a rich set of date-based attributes and methods

.

** Avoid storing data as string (when is possible)

Cuando hago el proceso de cambio de los datos en Year a un formato datetime, me aparece NaT en los valores, pero el dtype como datetime64[ns]. Alguien sabe por qué puede estar sucediendo esto?

Por otro lado, no hubiese sido más sencillo hacerlo al cargar el archivo usando parse_dates? Agradezco quien pueda responderme 😃

Una ventaja de usar variables categóricas es que normalmente se necesita menos memoria RAM y también ocupan menos espacio los archivos.

Es muy útil transformar los dos valores de la categoría “fell” en dummies, cuando se trabaja con muchas más categorías 3 o más siempre se debe hacer eso, al menos cuando son variables de tipo nominal y se desea lanzar una regresión, esto evita el problema de colinealidad perfecta, en la econometría se profundiza mucho sobre este tema.

Para cambiar el tipo de dato una variable:

df_info['martricula'] = df_info['matricula'].astype(int)

Para un conjunto de variables:

df_info[['matricula', 'otro_valor_numerico']] = df_info[['matricula', 'otro_valor_numerico']].astype(int)

Hava a nice code!

Una manera que se puede hacer para no colocar el format es:

df['year'] = pd.to_datetime(df['year'], errors = 'coerce')

el lugar donde encontré esto fue:

• https://pandas.pydata.org/docs/reference/api/pandas.to_datetime.html

• https://stackoverflow.com/questions/32888124/pandas-out-of-bounds-nanosecond-timestamp-after-offset-rollforward-plus-adding-a

las variables dummys son muy util a la hora de hacer modelos de regresion de nuestros datos.

Una variable dummy sirve para representar la presencia o la ausencia de un valor en algo, si está presente toma el valor 1 y sino está presente toma el valor 0 y esto lo podemos aplicar para cada categoria

Algunas de sus ventajas son:

• tenemos una representacion numerica del valor de nuestras categorias
• Podemos aplicar el mismo modelo para cada categoria ya que todas siguen la misma logica

Lo podemos resumir en:
"Simplificar las categorias para analizarlas todas con la misma herramientas, es como adaptar una llave para que sea capaz de usarse en muchas tuercas que para nosotros serían columnas (o categorias)"

Esto ya empieza a pacerce a una base de datos tipo SQL al tomar esos cursos antes que este siento que entiendo un montón más.

pd.to_datetime(df_meteorites[‘year’],
errors =‘coerce’,
format=’%m/%d/%Y %H:%M:%S %p’)

errors Coerce: cuando detecta un valor que no corresponde a tiempo genera una variable no numerica

Esta clase me tardó como 2 horas, la intención es aprender y reforzar los conocimientos.

Es rico ir rápido, pero es mejor si disfrutamos el proceso

👾

Estructuras de Dataframes

• df.nunique() muestra la cantidad de valores únicos de cada columna
• df[[‘columna1’,‘columna2’]] = df[ [‘columna1’, ‘columna2’] ].astype(‘category’) cambia el tipo de variable y la mantiene en el dataframe
• df[‘columna1’].value_counts() me permite saber cuántas veces aparece cada valor en esa columna
• pd.get_dummies(df[‘columna1’]) genera columnas dummies para esa columna, por ejemplo pasa de string a número
• df[‘unos’] = 1 : esto crea una nueva columna con un 1 en todos sus registros
• df[[ ‘nueva columna1’, ‘nueva columna2’ ]] = pd.get_dummies(df[‘columna original’]) con esto reemplazamos la columna original que tenía dos valores distintos generando dos nuevas variables dummies
• df[columna de fecha] = pd.to_datetime(
  df[columna],
  errors = ‘coerce’,
  format = '%m/%d/%Y %H:%M:%S %p’
  Esto genera que la columna de fecha que está en string pase a formato tipo datetime
• df.rename( columns= {‘columna original’:‘nombre nuevo’} inplace=True) renombra una columna y gracias a inplace aplica estos cambios de manera permanente en el dataframe actual

al usar df_meteorites.convert_dtypes() este nos da unicamente cuales son las mejores opciones, pero ¿cómo hago para que esos data types se guarden tal cual?

Nosotros podemos asignar valores nuevos a un dataframe ya creado, con:

import pandas as pd

df = pd.DataFrame(
{
'edad':[10, 12, 11, 10],
'grado_escolar':[5, 7, 7, 6]
}, index=['Juan', 'Jose', 'alejandro', 'camilo'])

Para asignar nuevos valores, por ejemplo cambiando los valores de una persona hacia otra se hace asi:

df.loc['Juan', :] = df.loc['Jose', :]

o asi tambien

df.loc['Juan', :] = df.loc['Jose', :].values

Ok, esta clase me destrozó

errors = 'coerce' cuando no encuentra un formato correspondiente a tiempo crea un variable no numerica

Aqui esta el resumen de los comandos que hemos visto, espero que sea de utilidad.

Un pequeño aporte: cuando hace la transformación de las categorías en 0 y 1 y las agrega en diferentes columnas es debido a que cuando se realiza una regresión como variables independientes no genere un problema que se llama colinealidad perfecta, es decir que una variable se relacione con si misma.

Entendido y poniéndolo en práctica

Variables de tiempo.

excelente