Curso: Análisis de datos
Magíster en Data Science - Universidad del Desarrollo
La preparación de datos es una fase esencial en el proceso de análisis de datos que involucra una serie de actividades destinadas a garantizar que los datos estén en condiciones óptimas para su posterior análisis.
La preparación de datos es crucial porque afecta directamente la calidad y confiabilidad de los resultados obtenidos en cualquier análisis posterior.
Podemos clasificar estos datos que recopilamos de muchas maneras:
Medios enriquecidos: Datos de medios y entretenimiento, datos de vigilancia, datos geoespaciales, audio, datos meteorológicos
Colecciones de documentos digitalizados: Facturas, registros, correos electrónicos, aplicaciones de productividad
Internet de las cosas: Datos de sensores, datos de teletipos.
Otra manera de clasificar los datos con relación a la temporalidad en la cual son tomados y cuál es la unidad de análisis.
En Pandas podemos cargar una gran variedad de datos, a través de la familia de funciones read_tipo
En Pandas podemos cargar una gran variedad de datos, a través de la familia de funciones read_tipo
Algunos tipos de argumentos para funciones read:
low_memory indica que usemos pocos recursos (o no) del sistema.La coma es un separador de campos, newline denota registros
a,b,c,d,message1,2,3,4,hello5,6,7,8,world9,10,11,12,fooPuede tener un encabezado (a,b,c,d,message), pero no es requisito
Sin tipo de información: no sabemos qué son las columnas (números, strings, punto flotante, etc.)
¿Y qué pasa con las comas en un valor?: doble comillas
Se puede utilizar otros delimitadores (|, , )
df = pd.read_csv(fname)df = pd.read_csv(fname, sep='\t\')df = pd.read_csv(fname, skiprows=3)df.to_csv()df.to_csv('example.dsv', sep='\|')df.to_csv('example.dsv', na_rep='NULL')Un formato para datos web
Aspecto muy similar a a diccionarios y listas python
Ejemplo: { "name": "Wes", "places_lived": ["United States", "Spain", "Germany"], "pet": null, "siblings": [{"name": "Scott", "age": 25, "pet": "Zuko"}, {"name": "Katie", "age": 33, "pet": "Cisco"}] }
No hay variables sino elementos independientes, pero permite nulos Valores: strings, arreglos, diccionarios, números, booleanos, o nulos
pd.read_json(<filename>, orient=<orientation>)df.to_json(<filename>, orient=<orientation>){index -> [index], columns -> [columns],data -> [values]}[{column -> value}, ... , {column -> value}]{index -> {column -> value}}{column -> {index -> value}}lxml (también ElementTree)CSV, JSON y XML son todos formatos de texto
¿Qué es un formato binario?
Pickle: Python’s built-in serialization
import pickle
# Objeto que queremos guardar
data = {'nombre': 'Juan', 'edad': 25, 'profesion': 'ingeniero'}
# Guardar el objeto en un archivo utilizando pickle
with open('datos.pickle', 'wb') as archivo:
pickle.dump(data, archivo)
# Cargar el objeto desde el archivo utilizando pickle
with open('datos.pickle', 'rb') as archivo:
datos_cargados = pickle.load(archivo)
print("Objeto cargado:", datos_cargados)Objeto cargado: {'nombre': 'Juan', 'edad': 25, 'profesion': 'ingeniero'}HDF5: Librería para almacenar gran cantidad de datos científicos
Formato jerárquico de datos
Interfaces in C, Java, MATLAB, etc.
Aguanta compresión
Usar pd.HDFStore para acceder
Comandos: read_hdf/to_hdf, se necesita especificar objeto
Excel: se necesita especificar la hoja cuando la hoja de cálculo tiene múltiples hojas
pd.ExcelFile or pd.read_excel
Las bases de datos relacionales son similares a los marcos de datos múltiples pero tienen muchas más características
vínculos entre tablas via foreign keys
SQL para crear, almacenar y query datos
sqlite3 es una base de datos simple con built-in support in python
Python tiene una database API que te permite acceder a la mayoría de los sistemas de bases de datos a través de un API común
Sintaxis similar (¡pero no igual!) de otros sistemas de bases de datos (MySQL, Microsoft SQL Server, Oracle, etc.)
SQLAlchemy: Paquete de python que se abstrae de las diferencias entre distintos sistemas de bases de datos
SQLAlchemy apoya la lectura de queries a data frame:
… pero, ¿y si los datos no son o están correctos… …confiables ..en formato correcto?
Muchas veces los datos con los que queremos trabajar no están en el formato adecuado para los análisis que querenos realizar.
En este sentido, generalmente para análisis de corte transversal nuestro ideal es trabajar con Tidy Data
“Tidy Data is a standar way of mapping the meaning of a dataset to its structure¨
Un tipo de estructura de datos útil para poder realizar modelos y análisis, son los llamados datos ordenados o Tidy Data Propuesto por Hadley Wickham (2014), se ha vuelto un estándar deseable para analizar datos.
Se caracteriza por que los datos son representados en tablas rectangulares, de tal manera que:
Cada variable (feature) forma una columna.
Cada observación (registro) forma una fila.
Cada dato (valor) está en una celda de la tabla.
Con Tidy data podemos tener una estandarización en el tratamiento de los datos:
Muchas veces un flujo de trabajo workflow empieza limpiando y ordenando los datos con el objetivo de que sean Tidy, para luego ser analizados y finalmente, comunicados sus resultados.
Fuente: https://allisonhorst.com/other-r-fun
Fuente: https://allisonhorst.com/other-r-fun
NO!
Existen muchos otros tipos de estructuras de datos que no son tidy y que eso no hace que no sean útiles o “desordenadas”.
Es importante tener en cuenta que siempre existen múltiples formas de representar la misma información.
Existen dos principales motivos para utilizar otras estructuras de datos:
2 enfoques para lidiar con ellos:
Filtrar
Llenar/ reemplazar :
Missing en Pandas
import pandas as pd
import numpy as np
data = {'Nombre': ['Juan', 'Ana', 'Luis', np.nan, 'Carlos'],
'Edad': [25, 30, np.nan, 30, 28]}
df = pd.DataFrame(data)
# Eliminar filas con valores faltantes
df = df.dropna()
# Llenar valores faltantes con un valor específico
df['Edad'].fillna(0, inplace=True)
print(df) Nombre Edad
0 Juan 25.0
1 Ana 30.0
4 Carlos 28.0duplicated : retorna una Series booleana , indicando si la fila es un duplicado o no la primera instancia no es marcada como un duplicado.drop_duplicates: saca todas las filas donde duplicated es Truekeep: Cuál de los valores es el que quiero mantener (first or last)Taller de aplicación 1: Pregunta 4
Uno de los errores de registro más típico, tiene que ver con que los textos/strings estan ingresados con errores.
Una de las razones de la popularidad de Python es por su capacidad de procesar texto/strings.
split(<delimiter>) “quiebra” o separa un string en partes: s = "12,13,14" slist = s.split(',') # ["12", "13", " 14"]
<delimiter>.join([<str>]): Une varios strings por un delimitador ":".join(slist) # "12:13: 14”
strip(): remueve los espacios en blanco iniciales y finales [p.strip() for p in slist] # ["12", "13", "14"]
replace(<from>,<to>): Cambia un substring por otro s.replace(',', ':') # "12:13: 14”
upper()/lower(): casing "AbCd".upper () # "ABCD” "AbCd".lower() # "abcd"
A veces, los datos se almacenan en el formato incorrecto y necesitas corregirlos.
import pandas as pd
data = {'Fecha': ['2023-08-26', '2023-08-27', '2023-08-28'],
'Ventas': ['$1000', '$1500', '$1200']}
df = pd.DataFrame(data)
# Convertir la columna 'Ventas' a números eliminando el símbolo de dólar
df['Ventas'] = df['Ventas'].str.replace('$', '').astype(float)
print(df) Fecha Ventas
0 2023-08-26 1000.0
1 2023-08-27 1500.0
2 2023-08-28 1200.0Podemos encontrar donde estan los problemas facilmente:
index()encuentra donde ocurre primero un substring(error si no lo encuentra):
find(<str>): Lo mismo que index pero -1 si no es encontrado . . .
startswith() or endswith(): chequeo booleano para la ocurrencia de un string . . .
Cualquier columna o serie puede tener métodos string (e.g. replace, split) aplicado a la serie completa
Está vectorizado para columnas completas o incluso el dataframe (lo cual lo hace rápido)
Se debe usar .str.
import pandas as pd
import numpy as np
data = pd.Series({'Dave': 'dave@google.com', 'Steve': 'steve@gmail.com', 'Rob': 'rob@gmail.com', 'Wes': np.nan})
contains_gmail = data.str.contains('gmail')
split_at = data.str.split('@').str[1]
last_three_chars = data.str[-3:]
print("Contains 'gmail':")
print(contains_gmail)Contains 'gmail':
Dave False
Steve True
Rob True
Wes NaN
dtype: objectA veces, queremos deshacernos de columnas que no son relevantes para nuestro análisis. . . .
| Nombre | Edad | Peso (kg) | |
|---|---|---|---|
| 0 | Juan | 25 | 70 |
| 1 | Ana | 30 | 65 |
| 2 | Luis | 35 | 80 |
| 3 | Carlos | 28 | 75 |
| Nombre | Edad | |
|---|---|---|
| 0 | Juan | 25 |
| 1 | Ana | 30 |
| 2 | Luis | 35 |
| 3 | Carlos | 28 |
import pandas as pd
# Crear DataFrame de ejemplo en formato largo
data = {'Fecha': ['2023-08-01', '2023-08-01', '2023-08-02', '2023-08-02'],
'Ciudad': ['A', 'B', 'A', 'B'],
'Temperatura': [25, 28, 26, 29]}
df_largo = pd.DataFrame(data)
# Realizar el reshape de largo a ancho usando pivot()
df_ancho = df_largo.pivot(index='Fecha', columns='Ciudad', values='Temperatura')
print("DataFrame en formato largo:")
print(df_largo)
print("\nDataFrame en formato ancho:")
print(df_ancho)| Ciudad | A | B |
|---|---|---|
| Fecha | ||
| 2023-08-01 | 25 | 28 |
| 2023-08-02 | 26 | 29 |
| Fecha | Ciudad | Temperatura | |
|---|---|---|---|
| 0 | 2023-08-01 | A | 25 |
| 1 | 2023-08-01 | B | 28 |
| 2 | 2023-08-02 | A | 26 |
| 3 | 2023-08-02 | B | 29 |
pd.get_dummies(df[‘key’])
import pandas as pd
# Lista de razas de perros
razas = ['Labrador', 'Poodle', 'Bulldog', 'Golden Retriever', 'Chihuahua', 'Husky']
# Crear un DataFrame con la lista de razas
df = pd.DataFrame({'Raza': razas})
# Razas que queremos crear como variables dicotómicas
razas_interes = ['Labrador', 'Poodle', 'Bulldog']
# Crear variables dicotómicas para las razas de interés
for raza in razas_interes:
df[raza] = df['Raza'].apply(lambda x: 1 if x == raza else 0)
# Eliminar la columna original de 'Raza'
df.drop(columns=['Raza'], inplace=True)
print(df)| Labrador | Poodle | Bulldog | |
|---|---|---|---|
| 0 | 1 | 0 | 0 |
| 1 | 0 | 1 | 0 |
| 2 | 0 | 0 | 1 |
| 3 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 |
| 5 | 0 | 0 | 0 |
Muchas veces tenemos varios dataset que queremos unir. Existen dos métodos principales:
Apliar/concatenar/append: Consiste en agregar un dataset a continuación de otro, para esto tienen que tener la misma forma.
Uniones Merge / Join: Las uniones combinan DataFrames utilizando columnas en común como clave. Puedes realizar diferentes tipos de uniones, como “inner”, “outer”, “left” y “right”
Creemos los dataframes: . . .
Hagamos el apilar. Atención a los index
Usemos ignorar index . . .
Utilizando la función pd.merge()
# Crear dos DataFrames con columnas en común
df3 = pd.DataFrame({'Key': ['A', 'B', 'C'], 'Value': [1, 2, 3]})
df4 = pd.DataFrame({'Key': ['B', 'C', 'D'], 'Value': [4, 5, 6]})
# Unión interna basada en la columna 'Key'
inner_join = pd.merge(df3, df4, on='Key', how='inner')
# Unión externa basada en la columna 'Key'
outer_join = pd.merge(df3, df4, on='Key', how='outer')
print("Unión interna:")
print(inner_join)
print("\nUnión externa:")
print(outer_join)| Key | Value_x | Value_y | |
|---|---|---|---|
| 0 | B | 2 | 4 |
| 1 | C | 3 | 5 |
| Key | Value_x | Value_y | |
|---|---|---|---|
| 0 | A | 1.0 | NaN |
| 1 | B | 2.0 | 4.0 |
| 2 | C | 3.0 | 5.0 |
| 3 | D | NaN | 6.0 |
Detección
import pandas as pd
import numpy as np
# Crear un conjunto de datos con valores atípicos
data = [10, 15, 20, 25, 30, 35, 200, 40, 45, 50]
# Crear un DataFrame
df = pd.DataFrame({'Valor': data})
# Calcular el rango intercuartílico (IQR)
Q1 = df['Valor'].quantile(0.25)
Q3 = df['Valor'].quantile(0.75)
IQR = Q3 - Q1
# Definir los límites para identificar valores atípicos
lower_limit = Q1 - 1.5 * IQR
upper_limit = Q3 + 1.5 * IQR
# Identificar valores atípicos
outliers = df[(df['Valor'] < lower_limit) | (df['Valor'] > upper_limit)]
print("Valores atípicos:")
print(outliers)Valores atípicos:
Valor
6 200La estandarización es un proceso importante en el análisis de datos y el aprendizaje automático.
Consiste en transformar los valores de una variable de manera que tengan una media de cero y una desviación estándar de uno.
Esta transformación se logra mediante la fórmula:
\[ z = \frac{x - \mu}{\sigma} \]
import pandas as pd
# Crear un DataFrame con datos
data = {'Valor': [10, 15, 20, 25, 30, 35, 40, 45, 50]}
df = pd.DataFrame(data)
# Calcular la media y la desviación estándar
mean = df['Valor'].mean()
std_dev = df['Valor'].std()
# Estandarización de los datos utilizando Pandas
df['Valor_estandarizado'] = (df['Valor'] - mean) / std_dev
print(df) Valor Valor_estandarizado
0 10 -1.460593
1 15 -1.095445
2 20 -0.730297
3 25 -0.365148
4 30 0.000000
5 35 0.365148
6 40 0.730297
7 45 1.095445
8 50 1.460593import numpy as np
# Datos originales
data = [10, 15, 20, 25, 30, 35, 40, 45, 50]
# Calcular la media y la desviación estándar
mean = np.mean(data)
std_dev = np.std(data)
# Estandarización de los datos
standardized_data = [(x - mean) / std_dev for x in data]
print("Datos originales:", data)
print("Datos estandarizados:", standardized_data)Datos originales: [10, 15, 20, 25, 30, 35, 40, 45, 50]
Datos estandarizados: [-1.5491933384829668, -1.161895003862225, -0.7745966692414834, -0.3872983346207417, 0.0, 0.3872983346207417, 0.7745966692414834, 1.161895003862225, 1.5491933384829668]La normalización es un proceso esencial en el análisis de datos y el aprendizaje automático.
Consiste en ajustar los valores de una variable para que se encuentren dentro de un rango específico, generalmente entre 0 y 1.
La fórmula matemática utilizada para la normalización es:
\[x_{\text{norm}} = \frac{x - \min(x)}{\max(x) - \min(x)} \]
import pandas as pd
# Crear un DataFrame con datos
data = {'Valor': [10, 15, 20, 25, 30, 35, 40, 45, 50]}
df = pd.DataFrame(data)
# Calcular los valores mínimo y máximo
min_value = df['Valor'].min()
max_value = df['Valor'].max()
# Aplicar la normalización min-max
df['Valor_normalizado'] = (df['Valor'] - min_value) / (max_value - min_value)
print(df) Valor Valor_normalizado
0 10 0.000
1 15 0.125
2 20 0.250
3 25 0.375
4 30 0.500
5 35 0.625
6 40 0.750
7 45 0.875
8 50 1.000import numpy as np
# Datos originales
data = np.array([10, 15, 20, 25, 30, 35, 40, 45, 50])
# Calcular los valores mínimo y máximo
min_value = np.min(data)
max_value = np.max(data)
# Aplicar la normalización min-max utilizando NumPy
normalized_data = (data - min_value) / (max_value - min_value)
print("Datos originales:", data)
print("Datos normalizados:", normalized_data)Datos originales: [10 15 20 25 30 35 40 45 50]
Datos normalizados: [0. 0.125 0.25 0.375 0.5 0.625 0.75 0.875 1. ]
Curso Análisis de Datos - Sesión 2