# Dependencias Generales import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns

df = pd.read_csv('./cars.csv') df

df.dtypes

df.describe()

salarios = np.random.randint(1600,8000,100) # Creamos 100 salarios aleatorios donde el min es 1600 y max 8000 suma_salarios = np.sum(salarios) numero_total_de_salarios = len(salarios) media_arimetica = suma_salarios/numero_total_de_salarios print(f""" La suma del conjuto de salarios es: {suma_salarios} La cantidad de salarios sumados es: {numero_total_de_salarios} La media arimetica es: {media_arimetica} """)

notas = np.linspace(1,10, 7).round() datos = len(notas) indice_mediana = int((datos-1)/2) # En programacion el indice empieza desde el 0, no el 1, por eso se resta 1 mediana = notas[indice_mediana] print(f""" La lista de notas es: {notas} La cantidad de notas cargadas es: {datos} El indice de la mediana es: {indice_mediana} El valor de la Mediana es: {mediana} """)

notas = np.linspace(1,10, 8).round() mediana = np.median(notas) print(mediana)

salarios = np.random.randint(25000,45000, 13) bill_gates = np.array(250000) salarios_y_bill_gates = np.union1d(salarios,bill_gates) numeros_de_datos = len(salarios_y_bill_gates) media_arimetica = np.mean(salarios_y_bill_gates) mediana = np.median(salarios_y_bill_gates) print(f""" El promedio es de los sueldos es: ${media_arimetica} La mediana es de los sueldos es: ${mediana} """) plt.figure(figsize=(20,5)) plt.hist(salarios_y_bill_gates, bins=30) plt.grid() plt.show()

df = pd.read_csv("./cars.csv") # Cargamos la base de datos pd.options.display.max_columns = 0 # para visualiar todas las columnas df # Visualizamos las dos primeras filas del BD

# inspeccionemos el atributo de price_usd (variable numérica continua) de los autos listados en el dataset: df['price_usd'].mean() # Vemos el promedio de precio en todo el catalogo

df['price_usd'].median() # Vemos la mediana en el catalogo

df['price_usd'].plot.hist(bins=20) # Graficamos el histograma

# resulta más interesante analizar los precios por marcas, asi que utilizaremos la libreria SeaBorn que se especializa para la visualizacion estadistica. sns.displot(data=df, x='price_usd', hue='manufacturer_name'); # Lo que vemos es que nos da de resultado un grafico muy sobrecargado, ,y al haber tantas categorias, el grafico pierde el proposito de facilitar la informacion

# Puede tener mas sentido analizar los autos por una categoria sns.displot(data=df, x='price_usd', hue='engine_type', multiple='stack');

# No se aprecian los autos eléctricos en el histograma, así que haremos un conteo de los autos teniendo en cuenta si es a diesel, gasolina o electrico df.groupby('engine_type').count()

# El histograma anterior era dificil de analizar ya que no se podiamos ver los autos electricos # Ahora inspeccionaremos los precios de una marca y modelo en particular para hacer la informacion mas facil de leer Q7_df = df[(df['manufacturer_name']=='Audi') & (df['model_name']=='Q7')] # Filtramos con PanDas el DataFrame de los autos que queremos clasificar sns.displot(data=Q7_df, x='price_usd',hue='year_produced', multiple='dodge')

autaco = df[ (df['transmission']=='automatic') & (df['body_type'] > 'suv') & (df['engine_capacity'] == 1.8)] plt.figure(figsize=(10,10)) sns.histplot(data=autaco, x='price_usd' ,y='year_produced',hue='manufacturer_name', multiple='dodge')

mercedes_benz = df[ (df['manufacturer_name']=='Mercedes-Benz') & (df['body_type']=='suv') & (df['year_produced']>2013) ] sns.displot(data=mercedes_benz, x='price_usd', hue='color', multiple='stack')

conjunto_de_datos = np.array([185,165,170,182,155]) x_maximo = conjunto_de_datos.max() x_minimo = conjunto_de_datos.min() R = x_maximo-x_minimo print(R)

print('Cuartiles con Numpy') print(f""" 1er cuartil: {np.quantile(conjunto_de_datos,0.25)} 2do cuartil: {np.quantile(conjunto_de_datos,0.50)} 3er cuartil: {np.quantile(conjunto_de_datos,0.75)} """) # Cuartiles con Numpy # print('Cuartiles con Pandas') # display(pd.DataFrame(conjunto_de_datos).describe()) # Forma de sacar mas facil los cuartiles con PanDas print('Diagrama de caja') sns.boxenplot(data=conjunto_de_datos, orient='horizontal');

# Seguiremos trabajando con la base de datos dada df.head()

# Desviacion estandar # Calcular la desviacion estandar en python es tan simple como esto, pero es importante entender el transfondo matematico para ser buenos programadores :) std_poblacional = df['price_usd'].std(ddof=0) std_muestral = df['price_usd'].std(ddof=1) print(std_poblacional, std_muestral)

# Rango = valor max - valor min rango = df['price_usd'].max() - df['price_usd'].min() rango

# Cuartiles # Como sabemos la mediana es uno de los valores de los cuartiles, asi que procedemos a calcularla mediana = df['price_usd'].median() q1 = df['price_usd'].quantile(0.25) q3 = df['price_usd'].quantile(0.75) min_val = df['price_usd'].quantile(q=0) max_val = df['price_usd'].quantile(q=1) print(min_val, q1, mediana, q3, max_val)

# Podemos hacerlo tambien de una forma mas facil para tener los cuartiles, valores max y min, mediana y promedio df['price_usd'].describe()

# Rango Intercuartil (IQR) iqr = q3-q1 iqr

min_limit = q1 - 1.5 * iqr max_limit = q3 + 1.5 * iqr print(f""" {min_limit} {max_limit} """)

# Graficar sns.histplot(data=df ,x='price_usd');

sns.boxplot(data=df ,x='price_usd');

sns.boxplot(data=df ,x='engine_fuel', y='price_usd');

df['price_usd'].describe()

# Usaremos Pandas y Seaborn para las visualizaciones y lectura de los dataframes # Trabajaremos con un dataset distinto al de los autos iris = sns.load_dataset('iris') iris.head()

# scatterplot sns.relplot( kind='scatter', data=iris, x='sepal_length', y='petal_length', ) print('Grafico sin segmentacion categorica') plt.show() sns.relplot( kind='scatter', data=iris, x='sepal_length', y='petal_length', hue='species', ) print('Grafico con segmentacion categorica') plt.show() print('Al principio parece no existir una relación entre las distintas flores en el gráfico de dispersión, pero cuando segmentamos las flores por su categoría de especies, podemos ver las grandes diferencias que nos permite segmentar las especies en términos de estos atributos específicos')

# joinplot sns.jointplot( data=iris, x='sepal_length', y='petal_length', hue='species',) print(' Trabajamos con el diagrama Joinplot para poder ')

# box plot sns.boxplot( data=iris, x='species', y='sepal_width' )

# barplot sns.barplot(data=iris, x='species', y='sepal_width')

# pairplot sns.pairplot( data=iris, hue=('species'), corner=True, kind='scatter') plt.show() print('Podemos ayudarnos de pairplot para poder visualizar las distintas relaciones de las variables en el dataset de forma rápida, y ver como se segmentan, de esta forma cabe a resaltar que la iris virginia tiende a ser más grande que las cetosas y versicolor en casi todas sus variables, excepto en el largo del sépalo con su ancho, donde la iris setosa es más ancha que y larga que sus otras dos especies')

import timeit #para medir el tiempo de ejecución de los modelos from sklearn import datasets, linear_model #datasets para descargar un modelo y linear_model para hacer una regresión lineal X,y = datasets.load_diabetes(return_X_y=True) # Cargamos el dataset raw = X[:, None,2] # Transformamos las dimensiones para que se ajuste al formato de entrada pre procesamiento

# min-max normalization max_raw = max(raw) min_raw = min(raw) minmax_scaled = (2*raw - max_raw - min_raw)/(max_raw - min_raw) # Z-score normalization avg = np.average(raw) std = np.std(raw) z_scaled = (raw-avg)/std # es importante tener una noción de los datos originales antes y después de escalarlos: fig, axs = plt.subplots(3,1, sharex=True) axs[0].hist(raw); # Conjunto original axs[1].hist(minmax_scaled); # Conjunto minmax normalization axs[2].hist(z_scaled); # Conjunto z-score normalization

def train_raw(): linear_model.LinearRegression().fit(raw,y) def train_scaled(): linear_model.LinearRegression().fit(minmax_scaled,y) def train_z_scaled(): linear_model.LinearRegression().fit(z_scaled,y)

raw_time = timeit.timeit(train_raw, number = 100) # repite la ejecución del código 100 veces y sobre eso calcula el tiempo scaled_time = timeit.timeit(train_scaled, number = 100) z_scaled_time = timeit.timeit(train_z_scaled, number = 100) print(' train raw: {}'.format(raw_time)) print(' train scaled: {}'.format(scaled_time)) print('train zscaled: {}'.format(z_scaled_time))

df.head()

df.price_usd.hist(bins=100);

p = 10000 df.price_usd.apply(lambda x: np.tanh(x/p)).hist()

df['price_usd'].hist(bins=100);

from sklearn.preprocessing import PowerTransformer from sklearn.model_selection import train_test_split price = df.price_usd bc = PowerTransformer(method='box-cox') yj = PowerTransformer(method='yeo-johnson') tanh = price.apply(lambda x: np.tanh(x/10000)) def map_data(method): # Convertimos el DF de Pandas a un array en Numpy x = price.to_numpy() # Redimensionamos el array a 1 dimension a 2 dimensiones x = np.reshape(x,(len(x),1)) # Vaya a la documentacion de sklearn :p x_train, x_test = train_test_split(x,test_size=0.5) x_trans = method.fit(x_train).transform(x_test) return x_trans fig, axs = plt.subplots(nrows=1,ncols=5, figsize=(20,6)) axs[0].hist(price,bins=50) axs[0].set_title('Raw price usd') axs[1].hist(map_data(bc),bins=50, color='green') axs[1].set_title('Method Box-Cox') axs[2].hist(map_data(yj),bins=50, color='pink') axs[2].set_title('Method Yeo-johnson') axs[3].hist(map_data(bc),bins=50, color='green') axs[3].hist(map_data(yj),bins=50, color='pink') axs[3].set_title('Comparasion Box-Cox and Yeo-Johnson') axs[4].hist(tanh,bins=50); axs[4].set_title('Method TanH');

pd.get_dummies(df['engine_type']) # Aunque La funcion se llame "get_dummies" de PanDas, hace referencia a un One-hot, se profundiza mas dentro de la documentacion.

# Dependencias import sklearn.preprocessing as preprocessing encoder = preprocessing.OneHotEncoder(handle_unknown='ignore')

encoder.fit(df[['engine_type']].values);

eficiente = encoder.transform([['gasoline'],['diesel'],['oil']]).toarray() id_columns = pd.DataFrame(df['engine_type'].drop_duplicates()) pd.DataFrame(eficiente, columns=id_columns['engine_type'])

encoder.fit(df[['year_produced']].values);

no_eficiente = encoder.transform([[2016],[2019],[190]]).toarray() id_columns = pd.DataFrame(df['year_produced'].drop_duplicates()) pd.DataFrame(no_eficiente, columns=id_columns['year_produced'])

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

import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.preprocessing import StandardScaler iris = sns.load_dataset('iris')

# Una forma rapida de visualizar las correlaciones de los datos del dataset, es usando el metodo visual "pairplot" sns.pairplot(iris, hue='species' ,corner=True);

# Nombres de las columnas iris.columns

# Esta es la normalizacion de restar el promedio y dividir por la desv estandar por cada variable para que todas queden estandar scaler = StandardScaler() scaled = scaler.fit_transform( iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']] ) scaled; # Todos estos numeros ya se encuentran normalizados de acuerdo a la distribucion misma de sus datos. # Para calcular la matriz de correlaciones, asi que debemos hacer la matriz Transpuesta

# Matriz Transpuesta scaled.T;

# Matriz de covarianza covariance_matrix = np.cov(scaled.T) covariance_matrix

# Visualizacion de la Matriz de covarianza # Graficamos con un mapa de calor ya que nos facilita la visualizacion de los datos plt.figure(figsize=(10,10)) sns.set(font_scale=1.5) sns.heatmap( data=covariance_matrix, annot=True, # Valores numericos dentro de la matriz cbar=True, # Barra a la derecha square=True, # no se fmt='.5f', # Decimales de los valores dentro de la matriz annot_kws={'size':15}, # Tamano de fuente de los valores yticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],# Leyenda X xticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'],# Leyenda Y );

fig, axs = plt.subplots(1,3,figsize=(40,12),sharex=True,sharey=True) fig.suptitle('Diferencias en distintos metodos de calcular la matriz de Covarianza') # Si usas el metodo 3 sin este formato, te van a salir acomodados de una forma distinta la matriz de cov, pero con resultados correctos x = iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']] # Los 3 metodos con los que saque la matrix de cov methods = { # Metodo usado en clase 'covariance_matrix,':covariance_matrix, # Metodo en los comentarios 'iris.corr(),':iris.corr(), # lo mismo que se supone que hace skitlearn pero sin ser parte de la libreria '((x - x.mean())/x.std()).cov()':((x - x.mean())/x.std()).cov().T} cont = 0 for title, method in methods.items(): axs[cont].set_title(title) sns.heatmap( data=method, annot=True, cbar=False, # cmap='RdYlGn', square=True, fmt='.19f', annot_kws={'size':10}, yticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'], xticklabels=['sepal_length', 'sepal_width', 'petal_length', 'petal_width'], ax=axs[cont] ); cont+=1 plt.show()

import numpy as np A = np.array([[1,2], [1,0]]) values, vectors = np.linalg.eig(A)

values

vectors

np.matmul(A, vectors.T[1]) values[1]*vectors.T[1] print( f''' np.matmul(A, vectors.T[1]) Que te da como resultado: {np.matmul(A, vectors.T[1])} values[1]*vectors.T[1] Mientras que por otro lado calculando: {values[1]*vectors.T[1]} Dando los mismos resultados ''')

values[1]*vectors.T[1]

import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from sklearn.preprocessing import StandardScaler # Normalizacion: Z-score iris = sns.load_dataset('iris') # Normalizacion de los datos scaler = StandardScaler() scaled = scaler.fit_transform( iris[['sepal_length','sepal_width','petal_length','petal_width']] ) covariance_matrix = np.cov(scaled.T) covariance_matrix

# Identificamos el minimo numero de variables para escribir nuestro dataset sns.pairplot(iris)

sns.jointplot(data=iris, x='petal_length', y='petal_width') # Datos sin Normalizar sns.jointplot(x=scaled[:, 2], y=scaled[:, 3]) # Datos Normalizados

# eigen values: valores propios # eigen vectors: vectores propios eigen_values, eigen_vectors = np.linalg.eig(covariance_matrix) # Descomponemos la Matriz de Covarianza en las 3 matrices que necesitamos

eigen_values

eigen_vectors

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

from sklearn.decomposition import PCA pca = PCA(n_components=2) # Creamos una instancia del elemento PCA, y le indicamos lo reduciremos a 2 componentes pca.fit(scaled) # Hacemos el fit sobre los datos escalados (No hacerlo con los originales)

pca.explained_variance_ratio_

reduced_scaled = pca.transform(scaled) # Transformamos los datos escalados, y nos entrega la transformacion resultante de la descomposicion de valores y vectores propios reduced_scaled[:5] # Ahora los data points poseen solo 2 componentes, a diferencia de antes que teniamos 4 componentes. # Y cabe recalcar que se esta capturando mas del 90% de los datos, que ya podria ser contada como una cantidad decente

iris['pca_1'] = reduced_scaled[:,0] # Principal Component 1 iris['pca_2'] = reduced_scaled[:,1] # Principal Component 2 iris

sns.jointplot(data=iris, x='pca_1', y='pca_2', hue='species')