# df.types() muestra todos los tipos de las columnas. Obj normalmente es una # variable de texto import pandas as pd df = pd.read_csv('cars.csv') df.head()

# Identificando el tipo de datos que se tiene en el df # Bool y Obj: Categóricos # int y float: Numéricos df.dtypes

# Observando la estadística general del data frame df.describe()

x = [1, 2, 3, 4, 5, 6, 7, 8, 9] def media (x): media = (sum(x[0:])/len(x)) return media print('La media del conjunto es:', media(x)) def mediana(x): if len(x) % 2 != 0: return (len(x) + 1) / 2 else: return ((len(x)/2 + len(x)/2 +1)/2) print('La mediana de este conjunto es: ', mediana(x))

print('la media del precio es: ',df['price_usd'].mean().round(2),'USD') print('La mediana de los precios es: ', df['price_usd'].median(),'USD')

# Se realizan 20 intervalos con el comando binsM df['price_usd'].plot.hist(bins=20)

# Resulta más interesante analizar los precios por marcas # Utilizando seaborn

import seaborn as sns sns.displot(df, x = 'price_usd', hue = 'manufacturer_name') # Se genera un histograma por cada una de las variables categóricas, combinando # los datos categóricos con los numéricos

sns.displot(df, x='price_usd', hue = 'engine_type', multiple = 'stack')

# Se agrupan los datos y se aplica el método contar df.groupby('engine_type').count()

# Si se quiere( un histograma sencillo especializado Q7_df = df[(df['manufacturer_name'] == 'Audi') & (df['model_name'] == 'Q7')] Q7_df.head()

# Ahora para visualizar, se puede observar cuántos autos hay en el catálogo # De qué año hacen parte y cuanto cuestan sns.histplot(Q7_df, x = 'price_usd', hue = 'year_produced')

SUBARU_df = df[(df['manufacturer_name'] == 'Subaru')]

df.describe()

import pandas as pd import matplotlib.pyplot as plt import seaborn as sns

# Desviación estándar df = pd.read_csv('cars.csv') media = df['price_usd'].mean().round(3) desviacion_estandar = df['price_usd'].std().round(3) coeficiente_variabilidad = (desviacion_estandar/media).round(2) print('La media de los precios es: ', media) print('La desviación estándar de los precios es: ', desviacion_estandar) print('El coeficiente de variabilidad es de: ', coeficiente_variabilidad)

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

median = df['price_usd'].median() Q2 = median Q1 = df['price_usd'].quantile(0.25) Q3 = df['price_usd'].quantile(0.75) min_value = df['price_usd'].quantile(q=0) max_value = df['price_usd'].quantile(q=1) print('El cuartil 1 es : {}, el cuartil 2 es {}, el cuartil 3 es {}'.format(Q1, Q2, Q3)) print('El valor mínimo es: {} y el valor máximo es: {}'.format(min_value, max_value)) print('El rango intercuartil es: ', Q3-Q1)

# Calculando los outliers (datos simetricamente distribuidos) IQR = Q3 - Q1 minlimit = Q1 - 1.5*IQR maxlimit = Q3 + 1.5*IQR print('El límite mínimo es: ', minlimit) print('El límite máximo es: ', maxlimit) #Se observa que esta distribución no es simétrica al tener valores negativos

# Dibujando la distribución se observa que no es sesgada sns.histplot(df['price_usd'])

# Dibujando el digrama de caja, este permite trabajar con variables categóricas sns.boxplot(df['price_usd'])

# Dibujando el diagrama de caja con categorías sns.boxplot(x = 'price_usd', y = 'engine_fuel', data = df)

# Se carga un data sets acerca de los petalos de las flores iris = sns.load_dataset('iris') iris.head()

# scatterplot sns.scatterplot(data=iris, x = 'sepal_length', y = 'petal_length', hue = 'species')

#join plot sns.jointplot(data= iris, x= 'petal_width', y = 'petal_length', hue = 'species')

# bar plot sns.barplot(data= iris, x = 'petal_width', y = 'species')

sns.boxenplot(x = 'species', y = 'sepal_length', data = iris, palette= 'dark')

import timeit import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn import datasets, linear_model X, y = datasets.load_diabetes(return_X_y = True) raw = X[:, None, 2]

#Reglas de escalamiento aplicando min - max max_raw = max(raw) min_raw = min(raw) scaled = (2*raw -min_raw-max_raw)/(max_raw-min_raw)

# Gráfico de antes vs después fig, axs = plt.subplots(2, 1, sharex= True) axs[0].hist(raw) axs[1].hist(scaled)

media_raw = raw.mean() media_scaled = scaled.mean() print(media_raw, media_scaled)

# Luego del escalamiento se define una función para entrenar el modelo def train_raw(): linear_model.LinearRegression().fit(raw, y) train_raw def train_scaled(): linear_model.LinearRegression().fit(scaled, y) train_scaled

raw_time = timeit.timeit(train_raw, number = 100) scaled_time = timeit.timeit(train_scaled, number = 100) print('El tiempo que se demora para los datos no entrenados es: {} y para los datos entrenados es: {}'.format(raw_time,scaled_time))

# Aplicando la transformación con Z_score z_scaled = (raw - np.mean(raw))/(np.std(raw)) # Se entrenan los datos train_raw() def train_z_scaled(): linear_model.LinearRegression().fit(z_scaled, y) train_z_scaled() raw_time = timeit.timeit(train_raw, number = 100) z_scaled_time = timeit.timeit(train_z_scaled, number = 100) print(z_scaled_time, raw_time)

fig, axs = plt.subplots(2, 1, sharex= True) axs[0].hist(raw) axs[1].hist(z_scaled)

# Aplicando sklearn preprocessing from sklearn import preprocessing # Se indica el transformador z_scaler = preprocessing.StandardScaler() # Se transforma z2_scaled = z_scaler.fit_transform(raw) #Se grafica fig, axs = plt.subplots(3, 1, sharex= True) axs[0].hist(raw) axs[1].hist(z_scaled) axs[2].hist(z2_scaled)

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

# Se observa una distribución sesgada df['price_usd'].hist()

# Aplicando la transformación Tanh(x) df['price_usd'].apply(lambda x: np.tanh(x)).hist()

# Aplicando la transformación Tanh(x) p = 10000 z4 = df['price_usd'].apply(lambda x: np.tanh(x/p)).hist()

# Intentando aplicar otro transformador from sklearn.preprocessing import QuantileTransformer from sklearn.model_selection import train_test_split # Se indica el transformador qt = QuantileTransformer(n_quantiles= 1000, output_distribution= 'normal') # Se separan los X de entrenamiento y los X de test X_train, X_test = train_test_split(X, test_size=.5) # Se aplica el modelo a los datos X_trans_qt = qt.fit(X_train).transform(X_test)

fig, axs = plt.subplots(3, 1, sharex= True) axs[0].hist(X_train) axs[1].hist(X_test) axs[2].hist(X)

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

pd.get_dummies(df['engine_type'])

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

# Se ajusta el enconder para que haga el ajuste sobre la columna que se desea encoder.fit(df[['engine_type']].values)

encoder.transform([['gasoline'], ['diesel'], ['aceite']]).toarray()

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

encoder.transform([[2016], [2009], [1990]]).toarray()

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

sns.pairplot(iris, hue = 'species')

scaler = StandardScaler() scaled = scaler.fit_transform(iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']] ) scaled.T

covariance_matrix = np.cov(scaled.T) covariance_matrix

# Se puede hacer los pasos anteriores o simplemente: sns.heatmap(iris.corr(), annot = True)

import numpy as np import seaborn as sns import matplotlib.pyplot as plt import pandas as pd 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']] ) covariance_matrix = np.cov(scaled.T) covariance_matrix

iris.columns

sns.pairplot(iris)

# Se observa que existe uan buena correlación entre el petal length y el petal width, por eso se hace un gráfico sns.jointplot(x=iris['petal_length'], y = iris['petal_width']) # Se estandariza sns.jointplot(x=scaled[:,2], y = scaled[:,3])

#Se calculan los eigenvalores y los eigenvectores eigen_values, eigen_vectors = np.linalg.eig(covariance_matrix)

eigen_values

eigen_vectors

# Cada vector propio es una dirección principal a lo largo de las dimensiones de los datos # La idea es escoger los vectores que acoplen la mayor información posible # Vamos a ver esto más claramente variance_explained = [] for i in eigen_values: variance_explained.append((i/sum(eigen_values))*100) print(variance_explained)

# Sklearn posee PCA from sklearn.decomposition import PCA #Creamos una instancia pca = PCA(n_components = 2) pca.fit(scaled)

pca.explained_variance_ratio_

# PCA Descarta las direcciones que no poseen muchos datos reduced_scaled = pca.transform(scaled) reduced_scaled

# Lo que se hizo fue reducir el número de categorías que no estén relacionadas entre sí directamente, esto con el fin # de entregar el menor número de dimensiones a un modelo de M.L para que se realicen mejores predicciones, pues, a # medida que se entregan menores dimensiones mejor funciona el modelo, además, si estas categorías no están relacionadas, # las predicciones funcionan mejor. # Ahora se aplica el modelo M.L para verificar lo anterior: iris['pca_1'] = reduced_scaled[:,0] iris['pca_2'] = reduced_scaled[:,1] iris

sns.jointplot(iris['pca_1'], iris['pca_2'], hue = iris['species'])