Apuntes del Curso de Estadística Descriptiva para Data Science.
Tipos de datos:
Los datos se dividen en 2 categorías: Los datos categóricos y numéricos.
Los datos categóricos, son todos aquellos datos que no son números, por ejemplo: categorías de películas, géneros, métodos de pago, etc.
Los datos numéricos, como te podrás imaginar son todos aquellos datos que son números, como el peso de una persona, su altura, etc.
Pero estas categorías tienen sub-divisiones. En el caso de los datos categóricos, las sub-divisiones serian los datos "ordinales" y "nominales". Su diferencia radica en que los datos ordinales contienen una relación de orden entre las categorías. Y los que no contengan esta relación son simplemente nominales.
Las sub-divisiones de los datos numéricos, son los "discretos" y "continuos". La diferencia entre ambos radica en que los datos discretos son un número entero y exacto, en cambio un dato continuo es aquel numero que contiene un decimal.
A continuación exploraremos un dataset que contiene todos estos tipos de datos.
import pandas as pd
df = pd.read_csv('cars.csv') # df = dataframe
df
Pandas contiene un metodo para poder saber el tipo de dato de cada columna: { pandas.DataFrame.dtypes }
df.dtypes
df.describe()
This chart is empty
Chart was probably not set up properly in the notebook
Medida de Tendencia Central
Medidas de Tendencia Central mas importantes
Dato timportante: La moda no aplica para datos numericos continuos.
Fórmulas:
Metáfora de Bill Gates
Medidas de Tendencia central en Python
print('promedio:', df['price_usd'].mean()) # La forma en que calculamos el promedio, ejemplo, el promedio de precios de los carros
print('mediana:', df['price_usd'].median()) # La forma en que calculamos la mediana, ejemplo, la mediana de precios de los carros
df['price_usd'].plot.hist(bins=20) # Plot es un metodo de pandas para graficar datos y plot asi mismo tiene otros metodos para elegir el tipo de graficacion.
# el histograma pide un numero de intervalos con (bins)
import seaborn as sns
sns.displot(df, x = "price_usd", hue='manufacturer_name') # Este este es un metodo que nos sirve para graficar los datos pero agregando un parametro de categorizacion. Este parametro lo ponemos como argumento en el metodo, con "hue". Ahi colocamos el nombre de la categoria que tiene el dataset que queremos usar para categorizar.
#displot = distribution plot
sns.displot(df, x = "price_usd", hue='engine_type', multiple="stack") # Para categorizarlo usar la categoria "engine_type" del dataset
# Y usamos una nueva propiedad llamada "multiple='stack'". Esta propiedad nos permite mejor ver las barras que sean menores.
df.groupby('engine_type').count() # Para categorizar los elementos que queremos recibir a la categoria lo hacemos como si estuvieramos en SQL, a traves de la propiedad ".groupby("engine_type")" que tiene pandas.
# Luego simplemente usamos el atributo ".count" que cuenta el numero de datos en las sub-categorias del tipo de motor y visualiza los datos.
Q7_audi = df[(df['manufacturer_name'] == 'Audi') & (df['model_name'] == 'Q7')] # De esta manera especificamos el tipo de dato que queremos mandar a la variable, este caso seria los datos que sean manufacturados por Audi y que sean especificamente del modelo Q7
#Q7_audi
sns.histplot(Q7_audi, x='price_usd', hue='year_produced') # Luego graficaremos lac comparacion categorica entre precio y numero de carros que haya dependiendo del año.
Medida de dispersión
El rango
El rango intercuartil
Desviación Estándar
df["price_usd"].std() #Asi calculamos la desviacion estandar
rango = df["price_usd"].max() - df["price_usd"].min()
rango
#cuartiles
median = df["price_usd"].median()
Q1 = df["price_usd"].quantile(q=0.25) #elegimos el 0.25 para que divida los cuaadros en un 25% o 1/4
Q3 = df["price_usd"].quantile(q=0.75)
min_val = df["price_usd"].quantile(q=0)
max_val = df["price_usd"].quantile(q=1.0)
print(min_val, Q1, median, Q3, max_val)
iqr = Q3 - Q1
min_limit = Q1 - 1.5*iqr # nos da un valor negativo pq estamos tratando de hallar el limite minimo en una distribucion no simetrica
max_limit = Q3 + 1.5*iqr
print(min_limit, max_limit)
sns.histplot(df["price_usd"])
sns.boxplot(df["price_usd"])
gasoline = df[(df['engine_fuel'] == 'gasoline')]
sns.boxplot(gasoline["price_usd"])
sns.boxplot(x = "engine_fuel", y = "price_usd", data=df)
Exploración Visual de los datos
#cambiaremos el conjunto de datos que estabamos usando anteriormente, ahora usaremos el dataset de iris, es un dataset que pertenece a un conjunto de datos que representan atributos especiales de flores que se llaman iris y que vienen en 3 especies distintas
iris = sns.load_dataset('iris')
iris.head()
sns.scatterplot(data=iris, x='sepal_length', y='petal_length', hue='species') # cada punto es una flor del conjunto de datos
# esta tambien puede recibir una variable categorica como "hue"
#Existe otro diagrama conocido como jointplot. Esta nos muestra ademas del scatterplot el histograma
sns.jointplot(data=iris, x='sepal_length', y='petal_length', hue='species')
sns.lmplot(data=iris, x='sepal_length', y='petal_length', hue='species')
sns.pairplot(iris, hue='species', palette='inferno', diag_kind='kde', height=2.0)
#box_plot
sns.boxplot(data=iris, x='species', y='petal_length')
iris['petal_length'].mean()
#barplot
sns.barplot(data=iris, x="species", y="petal_length")
Pipelines de procesamiento de datos numéricos
import timeit # Sirve para medir el performance de los modelos
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import datasets, linear_model # Nos permitira descargar los datasets y hacer modelos sencillos de regresion lineal
X, y = datasets.load_diabetes(return_X_y=True)
raw = X[:, None, 2]
raw
max_raw = max(raw)
min_raw = min(raw)
scaled = (2*raw - max_raw -min_raw)/(max_raw - min_raw)
avrg = np.average(raw)
std = np.std(raw)
z_score = (raw - avrg)/std
# Visualizacion de los datos escalados vs normales
fig, axs = plt.subplots(3, 1, sharex= True, tight_layout=True)
axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(z_score)
def train_raw():
linear_model.LinearRegression().fit(raw, y)
def train_scaled():
linear_model.LinearRegression().fit(scaled, y)
def train_zscore():
linear_model.LinearRegression().fit(z_score, y)
raw_time = timeit.timeit(train_raw, number = 100)
scaled_time = timeit.timeit(train_raw, number = 100)
zscore_time = timeit.timeit(train_zscore, number = 100)
print('trainning time for raw data : {} '.format(raw_time))
print('trainning time for scaled data : {}'.format(scaled_time))
print('trainning time for z-score data : {}'.format(zscore_time))
Transformación No Lineal
df.price_usd.hist()
# Un ejemplo de scikit-learn, Lognormal -> After Box-Cox
import numpy as numpy
from sklearn.preprocessing import PowerTransformer
from sklearn.preprocessing import QuantileTransformer
from sklearn.model_selection import train_test_split
rng = np.random.RandomState(304)
bc = PowerTransformer(method="box-cox")
# yj = PowerTransformer(method="yeo-johnson")
x = df['price_usd'].to_numpy()
# X_train, X_test = train_test_split(X, test_size=0.5)
y= np.reshape(x,[len(x),1])
X_train, X_test = train_test_split(y, test_size=0.5)
X_trans_bc = bc.fit(X_train).transform(X_test)
data = pd.DataFrame(X_trans_bc)
data.hist()
p = 10000 # calibrador de la tangente hiperbolica
df.price_usd.apply(lambda x: np.tanh(x/p)).hist()
pd.get_dummies(df['engine_type']) # como ves para pandas dummies es lo que nosotros conocemos como un one-hot
import sklearn.preprocessing as preprocessing # Esto es lo que contiene las reglas tanto para procesamiento numericos como categoricos
encoder = preprocessing.OneHotEncoder(handle_unknown="ignore") # aqui hacemos un metodo de codificacion de variables categoricas que utiliza la libreria importada de sklearn, ademas le pasamos un argumento que permite si llegasen valores no identificados, pues lo codifique como vector de ceros.
encoder.fit(df[['engine_type']].values) # con esta linea ajustamos el encoder a las categorias del dataset
# df[['engine_type']].values nos da la lista de valores categoricos de esa columna en un array
encoder.transform([['gasoline'],['diesel'],['aceite']]).toarray() # ahora podemos usar el encoder para transformar las categorias, para verlo lo haremos con ejemplos particulares. Para ver como funciona hay que usar arrays bidimensionales.
encoder.fit(df[['year_produced']].values)
encoder.transform([[2016], [2009], [199]]).toarray()
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler # este es para ser un escalamiento lineal de los datos
iris = sns.load_dataset('iris')
sns.pairplot(iris, hue="species")
iris.columns
scaler = StandardScaler()
scaled = scaler.fit_transform(
iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]
)
#data_df = pd.DataFrame(scaled)
#data_df
scaled.T # La transpuesta de los datos escalados para ver los arrays por categoria
covariance_matrix = np.cov(scaled.T)
covariance_matrix
plt.figure(figsize=(5,5))
sns.set(font_scale=1)
hm = sns.heatmap(covariance_matrix,
cbar=True,
annot=True,
square=True,
fmt='.2f',
annot_kws={'size': 12},
yticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],
xticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'])
iris.corr() #otra forma de hacer la matriz de covarianza
A = [[2, 6], [4, 8]]
B = [[3, 9], [5, 7]]
np.matmul(A, B)
A = np.array([[2, 4], [-1, 2]])
Ainversa = np.linalg.inv(A)
Ainversa
np.matmul(A, Ainversa)
A = np.array([[1, 2], [1, 0]])
values, vectors = np.linalg.eig(A)
print('Values: ', values, ' y Vectors: ', vectors)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
iris = sns.load_dataset('iris')
scaler = StandardScaler()
scaled = scaler.fit_transform(
iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values
)
covariance_matrix = np.cov(scaled.T)
covariance_matrix
sns.pairplot(iris) #identificamos el minimo numero de variables para describir el dataset
# lo hacemos basados en las correlaciones
#puedo enfocarme en dibujar un diagrama de dispersion de la grafica con mayor correlacion
sns.jointplot(x = iris['petal_length'], y = iris['petal_width'])
sns.jointplot(x = scaled[:,2], y=scaled[:,3]) # ademas quiero ver como queda el mismo diagrama pero con las variables estandarizadas
eigen_values, eigen_vectors = np.linalg.eig(covariance_matrix)
eigen_values
eigen_vectors
# los vectores y valores propios capturan la mayor cantidad varianza de los datos y cada una de estas direcciones es lo que llamamos una direccion principal
# cada vector propio es una de las direcciones principales a lo largo de la cual capturamos varianza de los datos originales
variance_explained = []
for i in eigen_values:
variance_explained.append((i/sum(eigen_values))) # segun la teoria matematica la varianza se puede calcular proporcional a la relacion entre el valor propio particular y la suma de todos los valores propios que hay dentro de esa matriz
variance_explained
from sklearn.decomposition import PCA # esto nos servira para transformar los datos de 4 dimensiones a 2
pca = PCA(n_components=2) # n_components sirve para coger los datos y reducirlos a un numero de componentes
pca.fit(scaled)
pca.explained_variance_ratio_ # nos devuelve las 2 direcciones principales
reduced_scaled = pca.transform(scaled) # esta capturando la suma de la varianza entre el 72 % y el 22% es decir estamos por encima del 92%
reduced_scaled
# ahora quiero ver como se evidencia este dataset respecto a las categorias de flore
iris['pca_1'] = reduced_scaled[:, 0]
iris['pca_2'] = reduced_scaled[:, 1]
iris
sns.jointplot(iris['pca_1'], iris['pca_2'], hue= iris['species'], height=5)