Descriptive statistics

Data types

import pandas as pd df = pd.read_csv("cars.csv") df

data types in pandas

df.dtypes

.describe()

df.describe()

Measures of central tendency

Mean

df['price_usd'].mean()

Median

df['price_usd'].median()

Analyzing data distribution

df["price_usd"].plot.hist(bins=20);

import seaborn as sns sns.displot(data = df, x = "price_usd", hue = "manufacturer_name");

sns.displot(data = df, x="price_usd", hue= "engine_type", multiple = "stack");

df.groupby("engine_type").count()

Electric_Cars = df[(df["engine_type"]=="electric")] Electric_Cars

Measures of dispersion

import pandas as pd import matplotlib.pyplot as plt import seaborn as sns df = pd.read_csv("cars.csv") print(df.head(5))

Standard deviation

df["price_usd"].std()

Range - (min, max values)

pricerange = df["price_usd"].max() - df["price_usd"].min() print(pricerange)

Quartiles

median = df["price_usd"].median() Q1 = df["price_usd"].quantile(q=0.25) 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:", min_val, ", Quartile1:", Q1, ", Median:" ,median, ", Quartile3" ,Q3, ", max val" , max_val)

Outliers detection

iqr = Q3 - Q1 #left limit minlimit = Q1 - 1.5*iqr #right limit maxlimit = Q3 + 1.5*iqr print("range for outliers detection is:", minlimit, ",", maxlimit)

sns.set(rc={'figure.figsize':(11.7,8.27)}) f, (ax_hist, ax_box) = plt.subplots(2, sharex=True, gridspec_kw={"height_ratios": (.6, .4)}) sns.histplot(df['price_usd'], ax=ax_hist) sns.boxplot(df['price_usd'], ax=ax_box) ax_hist.set(xlabel='')

Scatterplots for data analysis

import pandas as pd import seaborn as sns iris = sns.load_dataset("iris") iris.head()

Scatterplot segmented by categories

sns.scatterplot(data=iris, x="sepal_length", y="petal_length", hue="species");

Jointplot

sns.jointplot(data=iris, x="sepal_length", y="petal_length", hue="species")

lm plot per categories

sns.lmplot(data=iris, x="sepal_length", y="petal_length", hue="species");

sns.pairplot(data=iris, hue="species", palette="inferno", diag_kind="kde");

Pipelines de procesamiento (Variables numéricas)

Escalamiento lineal (Normalizacion)

cuando normalizar?

Tipos de normalizacion

import timeit import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn import datasets, linear_model #se importan los datos para trabajar X, y = datasets.load_diabetes(return_X_y=True) #subset de X, se selecciona la tercera columna raw = X[:, None, 2] plt.hist(raw) plt.title("Original Data");

Normalizacion max-min

scaled = ( (2*raw) - min(raw) - max(raw) ) / ( max(raw) - min(raw) ) plt.hist(scaled) plt.title("Max-Min Scaled data [1,1]"); print(max(scaled))

scaled2 = ( raw - min(raw) ) / ( max(raw) - min(raw) ) plt.hist(scaled2) plt.title("Max-Min Scaled data [0,1]");

Normalizacion Z-score

z_scaled = raw - np.mean(raw) / np.std(raw) plt.hist(z_scaled) plt.title("Z-score Scaled data");

Clipping

Verificacion de optimizacion en modelo de ML

# modelos para entrenamiento def train_raw(): linear_model.LinearRegression().fit(raw, y) def train_scaled(): linear_model.LinearRegression().fit(scaled, y) def train_z_scaled(): linear_model.LinearRegression().fit(z_scaled, y) # medicion de tiempo de ejecucion de cada modelo #number = 1000 indica al codigo que ejecute el modelo 1000 veces raw_time = timeit.timeit(train_raw, number = 1000) scaled_time = timeit.timeit(train_raw, number = 1000) z_scaled_time = timeit.timeit(train_raw, number = 1000) print('training time for raw data:', raw_time) print('training time for scaled data :', scaled_time) print('training time for z_scaled data :', z_scaled_time)

Normalizacion en datos asimetricos (no normales)

ejemplo transformacion: tangente hiperbolica

df = pd.read_csv('cars.csv') #mostrando los datos price = df.price_usd print(price.head()) #histograma para ver distribucion plt.hist(price);

#transformacion x_s = np.tanh(price) plt.hist(x_s);

#transformacion2 a = 10000 x_s_adj = np.tanh(price/a) plt.hist(x_s_adj);

ejemplo transformacion: raiz cuadrada

Pipelines de procesamiento (Variables categoricas)

Comparativa entre Dummy & One-hot

Creacion de variables tipo one-hot

import pandas as pd df = pd.read_csv('cars.csv') #se usa la columna engine type, cuyos valores son (diesel, electric, gasoline) df

Pandas one-hot

# a pesar de que dice get_dummies, realmente esta haciendo one-hot pd.get_dummies(df["engine_type"])

One-hot con scikit-learn

import sklearn.preprocessing as preprocessing #encoder = metodo de codificacion de variables categoricas #handle_unknown = codifica las variables desconocidas como un vector de ceros encoder = preprocessing.OneHotEncoder(handle_unknown='ignore')

#ajustando el encoder a las categorias de mi dataset #(se le pasa la lista de valores sobre los cuales crea las categorias) encoder.fit(df[['engine_type']].values)

# aceite es una categoria random para ver como codifica una variable que no existe encoder.transform([['gasoline'],['diesel'],['aceite']]).toarray()

One hot con variable numerica discreta

# se ajusta el encoder a las categorias (en este caso cada categoria es un año) encoder.fit(df[["year_produced"]].values)

# se intenta con un año inexistente para probar la codificacion: encoder.transform([[2016],[2009],[3050]]).toarray()

Correlaciones

pairplot()

import numpy as np import matplotlib.pyplot as plt import seaborn as sns import pandas as pd from sklearn.preprocessing import StandardScaler #datos para trabajar iris = sns.load_dataset('iris') #grafico para identificar correlaciones sns.pairplot(iris, hue = 'species');

Covarianza

Coeficiente de correlacion

Ejemplo: Matriz de covarianzas

sns.heatmap(iris.corr(), annot=True);

Valores propios

ejemplo para matriz 2x2

#Se crea la matriz a A = np.array([[1,2], [1,0]]) #le pedimos los valores y vectores propios a python values, vectors = np.linalg.eig(A)

values

vectors

np.matmul(A, vectors[:,0])

values[0]*vectors[:,0]

np.matmul(A, vectors[:,1])

values[1]*vectors[:,1]

Principal Component Analysis (PCA)

Aplicando PCA a dataset iris (con vectores y valores propios)

import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn.preprocessing import StandardScaler # se importan los datos iris = sns.load_dataset('iris') # normalizacion Z a los datos scaler = StandardScaler() scaled = scaler.fit_transform( iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']].values ) # se crea matriz de covarianza covariance_matrix = np.cov(scaled.T) covariance_matrix

sns.pairplot(iris)

# Diagrama con variables originales sns.jointplot(x=iris["petal_length"], y=iris["petal_width"])

# Mismo diagrama con variables estandarizadas sns.jointplot(x = scaled[:, 2], y = scaled[:,3])

Se descompone la matriz en vectores y valores propios

# Descomposicion eigen_values, eigen_vectors = np.linalg.eig(covariance_matrix)

eigen_values

eigen_vectors

variance_explained = [] for i in eigen_values: variance_explained.append((i/sum(eigen_values))*100) print(variance_explained)

Aplicando PCA a dataset iris (con numpy)

from sklearn.decomposition import PCA # Indicamos que queremos quedarnos con dos componentes pca = PCA(n_components=2) # Se le aplica la transformacion (no al dataset original sino al escalado) pca.fit(scaled)

pca.explained_variance_ratio_

# Se crea un nuevo conjunto de variables reduced_scaled = pca.transform(scaled) reduced_scaled

iris["pca_1"] = scaled[:,0] iris["pca_2"] = scaled[:,1] #iris["pca_3"] = scaled[:,2] #iris["pca_4"] = scaled[:,3] iris