#Ejercicio de indentificación de tipos de datos en python import pandas as pd df = pd.read_csv("cars.csv") df #df muestra todo el dataframe #df.describe() es un método para

df.dtypes #nos muestra el tipo de dato por columna

df.describe()

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

#Media df['price_usd'].mean()

#Mediana df['price_usd'].median()

#Grafico en pandas de un histograma de frecuencia df['price_usd'].plot.hist(bins=20) #bins da los intervalos de valores en los que se trazará el diagrama

import seaborn as sns #distribution plot para hacer un histograma con las marcas de carros sns.displot(df, x='price_usd', hue='manufacturer_name') #hue crea un histograma por cada una de las categorías de manufactorer_name #Estos histogramas por marca no permiten visualizar adecuadamente la información

#Histograma, de barras apiladadf con el tipo de combustible que necesitan sns.displot(df, x='price_usd', hue='engine_type', multiple='stack') #En este caso hue crea un histograma por cada tipo de motor #multiple stack nos deja apliar(stack) las barras

df.groupby('engine_type').count() #Al igual que en SQL existe groupby #Solo hay 10 eléctricos comparado con 25000 a gasolina

Q7_df = df[(df['manufacturer_name'] == 'Ford') & (df['model_name'] == 'Mustang')] #Esto es un filtro! sns.histplot(Q7_df, x='price_usd', hue='year_produced') #Hacemos histogramas por precio y año de producción

import pandas as pd import matplotlib.pyplot as plt import seaborn as sns df = pd.read_csv('cars.csv')

df['price_usd'].std()

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

#Quartiles median = df['price_usd'].median() Q1 = df['price_usd'].quantile(q=0.25) #toma el primer 25% de todos los datos 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)

#Rango Intercuartil iqr = Q3 - Q1 iqr

minlimit = Q1 - 1.5*iqr maxlimit = Q3 + 1.3*iqr print(minlimit, maxlimit)

sns.histplot(df['price_usd'])

sns.boxplot(df['price_usd'])

#Diagramas de caja del precio para cada tipo de motor sns.boxplot(x='engine_fuel', y='price_usd', data=df)

import pandas as pd import seaborn as sns iris = sns.load_dataset('iris')#Data set dentro de seaborn para clasificar setosas iris.head()

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

sns.set_theme() sns.jointplot( data=iris, x='sepal_length', y='petal_length', hue='species',palette='inferno',kind='kde')

sns.boxplot(data=iris, x='species', y='sepal_length',palette='Paired')

sns.barplot(data=iris, x='species', y='sepal_length',palette='viridis')

import timeit #para medir el tiempo de ejecución de los modelos import numpy as np import pandas as pd import matplotlib.pyplot as plt 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) #carga el dataset raw = X[:, None, 2] #transformación en las dimensiones para que se ajuste al formato de entrada del preprocesamiento

#reglas de escalamiento lineal, aplicamos max-min max_raw = max(raw) #raw = datos crudos min_raw = min(raw) scaled = (2*raw - max_raw - min_raw)/(max_raw - min_raw) # es importante tener una noción de los datos originales antes y después de escalarlos: fig, axs = plt.subplots(2, 1, sharex=True) axs[0].hist(raw) axs[1].hist(scaled)

# modelos para entrenamiento def train_raw(): linear_model.LinearRegression().fit(raw, y) def train_scaled(): linear_model.LinearRegression().fit(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) print(f'train raw: {raw_time}') print(f'train scaled: {scaled_time}')

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

# Acá se puede apreciar como la distribución está fuertemente sesgada df.price_usd.hist()

# Transformación con tanh(x) # Esta línea toma la columna y le aplica a toda una función matemática p = 10000 df.price_usd.apply(lambda x: np.tanh(x/p)).hist()

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

pd.get_dummies(df['engine_type'])#Dummies es lo que entendemos como one hot, por tanto, es un one hot!

import sklearn.preprocessing as preprocessing #módulo de preprocesamiento encoder = preprocessing.OneHotEncoder(handle_unknown='ignore') #Cuando lleguen valores que no estén dentro de las categorías previas, #las nuevas se codifican como un vector nulo

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

encoder.transform([['gasoline'],['diesel'], ['aceite']]).toarray() #Aceite es la categoría "nueva" y esta se representa con el vector nulo

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

encoder.transform([[2016], [2009], [190]]).toarray() #190 es el año "nuevo"

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

#sns.set_theme() sns.pairplot(iris, hue='species', palette='inferno') #este gráfico no sirve si hay demasiadas variables

iris.columns #Vemos todas las categorías

scaler = StandardScaler()#Escalador scaled = scaler.fit_transform( iris[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]#No ocupamos species ) scaled.T #Transponemos el arreglo con .T

covariance_matrix = np.cov(scaled.T) covariance_matrix

# Mapa de calor de la matriz de covarianza plt.figure(figsize=(10,10)) sns.set(font_scale=1.5) 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'])

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)

sns.jointplot(x=iris['petal_length'],y=iris['petal_width'])#Tomamos dos variables con alta correlación sns.jointplot(x=scaled[:,2],y=scaled[:,3])#Estandarizamos

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

eigen_vectors

#Aquí vemos como cada valor propio captura varianza en terminos de porcentaje variance_explained=[] for i in eigen_values: variance_explained.append((i/sum(eigen_values))*100) variance_explained

#Ahora utilizamos el método PCA from sklearn.decomposition import PCA pca=PCA(n_components=2)#Reducimos a dos componentes pca.fit(scaled)#Hacemos fit sobre los datos escalados pca.explained_variance_ratio_#Vemos el radio de la varianza y las dos direcciones principales

reduced_scaled=pca.transform(scaled)#Reducimos las variables que fueron escaladas

reduced_scaled

iris['pca_1']=scaled[:,0] iris['pca_2']=scaled[:,1] sns.jointplot(iris['pca_1'],iris['pca_2'],hue=iris['species'])