0% encontró este documento útil (0 votos)
23 vistas35 páginas

Descriptiva Con Python.ipynb - Colab

El documento presenta un análisis descriptivo de un conjunto de datos sobre automóviles utilizando Python y la biblioteca Pandas. Se incluyen estadísticas descriptivas, visualizaciones de datos y agrupaciones para explorar relaciones entre variables como precio, tipo de motor y año de producción. Además, se utilizan gráficos de histograma y pairplot para ilustrar las distribuciones y correlaciones en los datos.

Cargado por

carrascorosana
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
0% encontró este documento útil (0 votos)
23 vistas35 páginas

Descriptiva Con Python.ipynb - Colab

El documento presenta un análisis descriptivo de un conjunto de datos sobre automóviles utilizando Python y la biblioteca Pandas. Se incluyen estadísticas descriptivas, visualizaciones de datos y agrupaciones para explorar relaciones entre variables como precio, tipo de motor y año de producción. Además, se utilizan gráficos de histograma y pairplot para ilustrar las distribuciones y correlaciones en los datos.

Cargado por

carrascorosana
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 35

24/2/25, 12:34 p.m. descriptiva con python.

ipynb - Colab

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

df.dtypes

df.describe()

odometer_value year_produced engine_capacity price_usd number_of_photos up_counter duration_listed

count 38531.000000 38531.000000 38521.000000 38531.000000 38531.000000 38531.000000 38531.000000

mean 248864.638447 2002.943734 2.055161 6639.971021 9.649062 16.306091 80.577249

std 136072.376530 8.065731 0.671178 6428.152018 6.093217 43.286933 112.826569

min 0.000000 1942.000000 0.200000 1.000000 1.000000 1.000000 0.000000

25% 158000.000000 1998.000000 1.600000 2100.000000 5.000000 2.000000 23.000000

50% 250000.000000 2003.000000 2.000000 4800.000000 8.000000 5.000000 59.000000

75% 325000.000000 2009.000000 2.300000 8990.000000 12.000000 16.000000 91.000000

max 1000000.000000 2019.000000 8.000000 50000.000000 86.000000 1861.000000 2232.000000

Distributions

2-d distributions

Values

Haz doble clic (o pulsa Intro) para editar

Debo subier el archivo al directorio para que lo pueda leer desde read_cvs y no de error, verificar que el arhcivo ese subido al direcotiro de
trabajo actual import pandas as pd df = pd.read_csv('/path/to/your/file/cars.csv') # Replace with the actual path df si el archivo esta en otra
locaclizacion o lugar actualiza la ruta del archivo para que pueda encontar

df.dtypes

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 1/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

manufacturer_name object

model_name object

transmission object

color object

odometer_value int64

year_produced int64

engine_fuel object

engine_has_gas bool

engine_type object

engine_capacity float64

body_type object

has_warranty bool

state object

drivetrain object

price_usd float64

is_exchangeable bool

location_region object

number_of_photos int64

up_counter int64

feature_0 bool

feature_1 bool

feature_2 bool

feature_3 bool

feature_4 bool

feature_5 bool

feature_6 bool

feature_7 bool

feature_8 bool

feature_9 bool

duration_listed int64

dt bj t

el comando describe nos devuelve unos estadisticos minimos descriptivos de los datos, como el promedio, percentiles,

vamos a empezar a ver caracteristicas de ciertos estadisticos, empezaremos con la media, y para ello debemo calcular la media de una
columna en particular

vamos a trabjar sobre la columna precio,usamos la funcion mean para calcular la media

Empieza a programar o a crear código con IA.

df['price_usd'].mean()

6639.971021255613

df['price_usd'].median()

4800.0

vemos que la mediana esta mas a la derecha de la media, eso nos da un sesgo hacia la derecha

histograma es una generalizacion del concpeto de diagrma de frecuencia, el diagrama de frecuencia es la representacion grafica de la tabal
de frecuencia, se usa para valores discretos, el histograma usamos en intervalode valores, mas especificamete para variables continua

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 2/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

usaoa el comand plot para dibujar, con hist() y con bins decimos la cantidad de intervalos que necesitamos,

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

<Axes: ylabel='Frequency'>

Empieza a programar o a crear código con IA.

df['price_usd'].plot.hist(bins=5)

<Axes: ylabel='Frequency'>

Hay una libreria en pyton, con enfoque estadisticos que vamos a usar, para ello debemo importar seaborn

import seaborn as sns


sns.displot(df, x='price_usd', hue='manufacturer_name')

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 3/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.FacetGrid at 0x7bdcac73e810>

indico el conjuto de dato on el que voy a trabjar, cual es lacolumman el precio, y luego hacer la separacion, ver las distribuciones por el tema
de las marcas cuando uno explora se da cuenta que la columna manufacture correspode a la fabrica o marca de autos, eso los hacemos on
hue para searpa las columnas , con la varibla cateboridca, genera una columnas por cada una de las categorias que encuente en esa
columna,

Empieza a programar o a crear código con IA.

ahora vaom a analizar los autor, por otra categoria, como ser la forma del motor otipo de motor segun su funciaonmisos, para ello
generamos otro displo

sns.displot(df, x='price_usd', hue='transmission')

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 4/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.FacetGrid at 0x7bdcad2b0710>

sns.displot(df, x='price_usd', hue='engine_fuel')

<seaborn.axisgrid.FacetGrid at 0x7bdca52f4390>

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

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 5/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.FacetGrid at 0x7bdca4d13f90>

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

<seaborn.axisgrid.FacetGrid at 0x7bdca533bf90>

df.groupby('engine_type').count()

manufacturer_name model_name transmission color odometer_value year_produced engine_fuel engine_has_gas engine_

engine_type

diesel 12874 12874 12874 12874 12874 12874 12874 12874

electric 10 10 10 10 10 10 10 10

gasoline 25647 25647 25647 25647 25647 25647 25647 25647

3 rows × 29 columns

podemoa agrupar los datos, segun algun variable categorica, y de alli aplicar algunos estadisticos sobre ellos, en este caso solo contamos
los elementos de cada grupo o categoria, pero puedo sacar, media, mediana, etc....... el histograma anterir es muy dificil analizar, ¿donde
estan los autor electrica??

inspeccionemos precios de una marca y modeo particular

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 6/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
Empieza a programar o a crear código con IA.

Empieza a programar o a crear código con IA.

tener cuidado al escribir con los espacios, y los argumentos, porque tuve que corregir con asistente

Q7_df = df[(df['manufacturer_name'] == 'Audi') & (df['model_name'] == 'Q7')]

Q7_df

manufacturer_name model_name transmission color odometer_value year_produced engine_fuel engine_has_gas engine_type

19515 Audi Q7 automatic grey 275000 2007 diesel False diesel

19547 Audi Q7 automatic white 105000 2014 diesel False diesel

19559 Audi Q7 automatic other 170000 2006 diesel False diesel

19574 Audi Q7 automatic black 185000 2016 diesel False diesel

19583 Audi Q7 automatic other 210000 2010 diesel False diesel

... ... ... ... ... ... ... ... ... ...

21756 Audi Q7 automatic silver 200000 2008 gasoline False gasoline

21812 Audi Q7 automatic black 276000 2008 diesel False diesel

21873 Audi Q7 automatic black 273000 2006 gasoline False gasoline

21900 Audi Q7 automatic white 283000 2007 diesel False diesel

21942 Audi Q7 automatic grey 262000 2007 gasoline False gasoline

79 rows × 30 columns

sns.histplot(Q7_df['price_usd'])

<Axes: xlabel='price_usd', ylabel='Count'>

sns.histplot(Q7_df['price_usd'], bins=20)

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 7/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<Axes: xlabel='price_usd', ylabel='Count'>

sns.histplot(Q7_df,x='price_usd', hue='year_produced')

<Axes: xlabel='price_usd', ylabel='Count'>

nissan_df=df.query('manufacturer_name=="Nissan" and model_name=="Primera" and year_produced>=2000')

black_cars = df[(df['color'] == 'black') & (df['price_usd'] <= 20000) & (df['year_produced'] >= 2017)]
sns.histplot(black_cars, x = 'price_usd', hue = 'year_produced')

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 8/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<Axes: xlabel='price_usd', ylabel='Count'>

Otra función muy útil de Seaborn, pairplot entrega mucha información contrastada de variables que escojamos. Acá se puede ver que el
kilometraje es también relevante respecto del precio, entre otras cosas.
Descomposición del Código
import seaborn as sns:
Haz doble clic (o pulsa Intro) para editar
Importar Seaborn: Seaborn es una librería de visualización de
datos basada en Matplotlib que proporciona una interfaz de alto
nivel para dibujar gráficos estadísticos atractivos y informativos.
import seaborn as sns
sns.set(style="ticks", color_codes=True):
sns.set(style="ticks", color_codes=True)
sns.pairplot(df,vars = ['price_usd', 'odometer_value','year_produced'], hue="engine_type") Configurar el Estilo: Establece el estilo de los gráficos de
plt.show() Seaborn. En este caso, el estilo de "ticks" añade ticks a las líneas
de los ejes.

--------------------------------------------------------------------------- color_codes=True: Permite el uso de colores con nombres


NameError Traceback (most recent call last) abreviados en las paletas de Seaborn.
<ipython-input-30-8bbf42d75b54> in <cell line: 0>() sns.pairplot(df, vars=['price_usd', 'odometer_value',
2 sns.set(style="ticks", color_codes=True) 'year_produced'], hue="engine_type"):
3 sns.pairplot(df,vars = ['price_usd', 'odometer_value','year_produced'], hue="engine_type")
df: Es el DataFrame que contiene los datos.
----> 4 plt.show()
vars=['price_usd', 'odometer_value', 'year_produced']: Especifica
NameError: name 'plt' is not defined las variables (columnas) del DataFrame que se quieren incluir en
la gráfica.

hue="engine_type": Añade colores distintos para las diferentes


categorías de la variable engine_type (tipo de motor), permitiendo
una diferenciación visual entre ellas.

plt.show():

Mostrar la gráfica: Muestra todas las subplots generadas en la


gráfica de pares (pairplot).

Ejemplo de Uso
Supongamos que tienes un DataFrame df con las siguientes
columnas: price_usd, odometer_value, year_produced y
engine_type. Al ejecutar el código, se generará una matriz de
gráficos de dispersión (scatter plots) y diagramas de densidad
(kde plots) para todas las combinaciones de las variables
especificadas. Los puntos en los gráficos estarán coloreados
según el tipo de motor.

Visualización Resultante
La visualización final permitirá ver las relaciones bivariadas entre
price_usd, odometer_value y year_produced, y cómo estas
relaciones varían según el tipo de motor (engine_type). Esto
puede proporcionar información valiosa sobre las correlaciones y
patrones en el conjunto de datos.

Espero que esto aclare lo que hace el código. Si necesitas más


detalles o tienes alguna otra pregunta, ¡estaré encantado de
ayudarte!

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 9/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
import matplotlib.pyplot as plt
Descomposición del Código
import matplotlib.pyplot as plt:
sns.set_style("whitegrid")
plt.figure(figsize=(12, 8)) Importar Matplotlib: Matplotlib es una librería de Python para la creación de gráficos y
visualizaciones. pyplot es un submódulo que proporciona una interfaz similar a MATLAB para la
sns.boxplot(x='color', y='price_usd', data=df, palette='Blues') creación de gráficos.

sns.set_style("whitegrid"):
<ipython-input-31-3b752d5189cb>:5: FutureWarning:
Configurar el Estilo de Seaborn: Seaborn es una librería de visualización de datos que se basa en
Passing `palette` without assigning `hue` is deprecated and will be removed
Matplotlib in una
y proporciona v0.14.0.
interfaz deAssign the
alto nivel. `x` variable establece
set_style("whitegrid") to `hue` and de
un estilo set `le
fondo
con cuadrícula blanca.
sns.boxplot(x='color', y='price_usd', data=df, palette='Blues')
plt.figure(figsize=(12, 8)):
<Axes: xlabel='color', ylabel='price_usd'>
Crear una Figura: plt.figure(figsize=(12, 8)) crea una nueva figura con un tamaño específico (12
pulgadas de ancho y 8 pulgadas de alto).

sns.boxplot(x='color', y='price_usd', data=df, palette='Blues'):

Crear un Diagrama de Caja (Boxplot):

x='color': Especifica la variable que se utilizará para el eje x, que en este caso es la columna color
del DataFrame df.

y='price_usd': Especifica la variable que se utilizará para el eje y, que en este caso es la columna
price_usd del DataFrame df.

data=df: Especifica el DataFrame que contiene los datos, en este caso df.

palette='Blues': Especifica la paleta de colores que se utilizará para el diagrama, en este caso una
paleta de tonos azules.

Propósito del Código


El propósito de este código es crear un diagrama de caja (boxplot) que muestre la distribución de
los precios de los automóviles (price_usd) en función de su color (color). Los boxplots son útiles
para visualizar la distribución de los datos y detectar posibles valores atípicos (outliers).

Visualización Resultante
Cuando ejecutes este código, verás un diagrama de caja para cada color de automóvil en el
DataFrame, con los precios (price_usd) mostrados en el eje y. Los boxplots te ayudarán a entender
cómo varían los precios en función del color del automóvil y a identificar posibles valores extremos.

Haz doble clic (o pulsa Intro) para editar

Los diagramas para el precio por cada color de vehículo

Diagrama de cajas por tipo de carrocería vs precio (desde modelos del 2010):

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

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

df2010 = df[df['year_produced']>=2010]
plt.figure(figsize=(12, 8))
sns.boxplot(data=df2010, x='body_type', y='price_usd', color='blue')

<Axes: xlabel='body_type', ylabel='price_usd'>

import numpy as np
import pandas as pd

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 10/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
import seaborn as sns
import matplotlib.pyplot as plt

# Generar datos aleatorios con una distribución normal Descomposición del Código
Generar datos aleatorios con una distribución normal:
data = np.random.normal(loc=0, scale=1, size=100)
python
# Agregar algunos valores atípicos en el extremo superior data = np.random.normal(loc=0, scale=1, size=100)
np.random.normal(loc=0, scale=1, size=100): Genera 100 valores aleatorios siguiendo una
data = np.append(data, [10, 12, 15]) distribución normal (media 0 y desviación estándar 1).

Agregar valores atípicos:


# Crear un DataFrame de pandas
df = pd.DataFrame({'data': data}) python
data = np.append(data, [10, 12, 15])
np.append(data, [10, 12, 15]): Añade tres valores atípicos (10, 12, 15) al array data. Estos
# Crear un diagrama de caja valores están significativamente alejados de la media de la distribución original.
sns.boxplot(x='data', data=df)
Crear un DataFrame de pandas:
plt.show()
python
df = pd.DataFrame({'data': data})
pd.DataFrame({'data': data}): Crea un DataFrame de pandas con una columna llamada data
que contiene los valores generados y los atípicos añadidos.

Crear un diagrama de caja (boxplot):

python
sns.boxplot(x='data', data=df)
plt.show()
sns.boxplot(x='data', data=df): Crea un diagrama de caja utilizando Seaborn, donde se
visualiza la distribución de la columna data del DataFrame df.

plt.show(): Muestra el gráfico generado.

Explicación del Boxplot


Boxplot: Es una representación visual de la distribución de los datos. Muestra los valores
mínimos, primer cuartil (Q1), mediana (Q2), tercer cuartil (Q3) y valores máximos. También
visualiza los valores atípicos (outliers) que están fuera del rango de los "bigotes" (whiskers)
del boxplot.

Valores atípicos: Los puntos (10, 12, 15) que añadiste se mostrarán como puntos individuales
fuera de los límites de los bigotes del boxplot, indicando que son valores significativamente
diferentes del resto de los datos.

Este código te permite visualizar cómo los valores atípicos afectan la distribución de tus datos
utilizando un diagrama de caja. Es una herramienta útil para identificar outliers y entender
mejor la distribución de tus datos.

# Generar datos con un IQR de cero en el extremo inferior


data = np.concatenate([np.repeat(0, 25), np.random.uniform(0, 10, 75)])

# Crear un DataFrame de pandas


df = pd.DataFrame({'data': data})

# Crear un diagrama de caja


sns.boxplot(x='data', data=df)
plt.show()

Explicación del código:

np.repeat(0, 25): Crea un array con 25 valores iguales a 0. Esto forzará al primer cuartil (Q1) y al mínimo a ser 0. np.random.uniform(0, 10,
75): Crea un array con 75 valores aleatorios distribuidos uniformemente entre 0 y 10. np.concatenate(): Une los dos arrays creados
anteriormente en un solo array. pd.DataFrame({'data': data}): Crea un DataFrame de pandas con los datos generados. sns.boxplot(x='data',

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 11/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
data=df): Crea el diagrama de caja. plt.show(): Muestra el diagrama. En este ejemplo, el bigote inferior del diagrama de caja tendrá longitud
cero porque el primer cuartil (Q1) y el mínimo son iguales a 0. El bigote superior sí se mostrará ya que hay variabilidad en los datos por
encima del tercer cuartil (Q3).

Espero que esta explicación sea más clara y precisa. No dudes en preguntar si tienes más dudas.

Empieza a programar o a crear código con IA.

df

data

0 0.000000

1 0.000000

2 0.000000

3 0.000000

4 0.000000

... ...

95 3.662406

96 9.905695

97 6.122890

98 3.764346

99 1.047751

100 rows × 1 columns

Okay, para generar un conjunto de datos donde el diagrama de cajas no tenga bigote superior, necesitamos que el tercer cuartil (Q3) sea
igual al valor máximo del conjunto de datos. Esto se puede lograr forzando un número considerable de valores a ser iguales al valor máximo
dentro de la distribución.

# Generar datos con un IQR de cero en el extremo superior


data = np.concatenate([np.random.uniform(0, 10, 75), np.repeat(10, 25)])

# Crear un DataFrame de pandas


df = pd.DataFrame({'data': data})

# Crear un diagrama de caja


sns.boxplot(x='data', data=df)
plt.show()

Explicación del código:

np.random.uniform(0, 10, 75): Crea un array con 75 valores aleatorios distribuidos uniformemente entre 0 y 10. np.repeat(10, 25): Crea un
array con 25 valores iguales a 10. Esto forzará al tercer cuartil (Q3) y al máximo a ser 10. np.concatenate(): Une los dos arrays creados
anteriormente en un solo array. pd.DataFrame({'data': data}): Crea un DataFrame de pandas con los datos generados. sns.boxplot(x='data',
data=df): Crea el diagrama de caja. plt.show(): Muestra el diagrama. En este caso, el bigote superior del diagrama de caja tendrá longitud

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 12/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
cero porque el tercer cuartil (Q3) y el valor máximo son iguales a 10. El bigote inferior sí se mostrará ya que hay variabilidad en los datos por
debajo del primer cuartil (Q1).

En resumen:

Para que no haya bigote inferior, se necesita que Q1 = mínimo. Para que no haya bigote superior, se necesita que Q3 = máximo. Espero que
esto te ayude a entender cómo manipular los datos para obtener el diagrama de caja que necesitas. ¡No dudes en preguntar si tienes más
dudas!

df['price_usd'].plot.box()

<Axes: >

MEDIDDAS DE DISPERSION calculo de rango, desviacion, varianza

desviacion

df['price_usd'].std()

6428.152018202915

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

rango

rango

49999.0

quartiles

median=df['price_usd'].median()
median

4800.0

Q1=df['price_usd'].quantile(q=0.25)
Q1

2100.0

Q2=df['price_usd'].quantile(q=0.50)
Q2
Q3=df['price_usd'].quantile(q=0.75)
Q3

8990.0

min_value=df['price_usd'].min()
max_value=df['price_usd'].max()

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 13/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
print(min_value,Q1,median,Q3,max_value)

1.0 2100.0 4800.0 8990.0 50000.0

Haz doble clic (o pulsa Intro) para editar

irq=Q3-Q1

calculamos los valore minimos y aximos, para detectar los outliers

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

-8235.0 19325.0

vemos que el valor minimo da un valor negativo, o sea todos nuestro valores estan dentro del limite limird para deteccion de outliers validos
para datos simetricamente distribuidos------d

Haz doble clic (o pulsa Intro) para editar

Empieza a programar o a crear código con IA.

Dibujamos el diagrama de cajas

import seaborn as sns


sns.histplot(df['price_usd'])

<Axes: xlabel='price_usd', ylabel='Count'>

Empieza a programar o a crear código con IA.

sns.boxplot(df['price_usd'])

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 14/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<Axes: ylabel='price_usd'>

un bloxpot de variable categorica con variable numerica

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

<Axes: xlabel='engine_fuel', ylabel='price_usd'>

para cambiar el tamaño de los graficos probar esto Usa, antes del código de seaborn:

plt.subplots(figsize=(10,7)) x=10, y=7, puedes modificar los números hasta que quede al tamaño que quieras.

cambiar la orientacion de la caja Entonces para corregir esto simplemente agregas al código el parámetro para que la orientación sea
horizontal
Desglose del Código
Leer el archivo CSV:
sns.boxplot(x=df['price_usd'], orient='h')
python
df = pd.read_csv('cars.csv')
pd.read_csv('cars.csv'): Carga el archivo CSV 'cars.csv' en un DataFrame de pandas llamado df.
CLASE 12- VISUALIZACION DE DATOS
Filtrar datos para 'Ford' después del año 2010:

python
import numpy as np ford = df[(df['manufacturer_name'] == 'Ford') & (df['year_produced'] > 2010)]
import pandas as pd df['manufacturer_name'] == 'Ford': Selecciona solo las filas donde el fabricante es 'Ford'.
import matplotlib.pyplot as plt
df['year_produced'] > 2010: Selecciona solo las filas donde el año de producción es mayor que 2010.
from matplotlib import cm
import seaborn as sns Combinación de ambos filtros usando & para obtener un DataFrame filtrado ford.

Crear una tabla pivote:


df = pd.read_csv('cars.csv')
python
pivot_ford = ford.pivot_table(values='price_usd', index='model_name', columns='year_produced', aggfunc=np.sum)
# Mapa de calor con pivot (Ford) values='price_usd': Los valores en la tabla pivote serán los precios en dólares.
ford = df[(df['manufacturer_name']=='Ford') & (df['year_produced']>2010)]
index='model_name': Las filas de la tabla pivote serán los nombres de los modelos.
pivot_ford = ford.pivot_table(values='price_usd', index='model_name', columns='year_produced', aggfunc=np.sum)
plt.figure(figsize=(12, 8)) columns='year_produced': Las columnas de la tabla pivote serán los años de producción.
sns.heatmap(pivot_ford, cmap='hot') aggfunc=np.sum: La función de agregación usada será la suma de los precios.

Configurar la figura para el gráfico:

python
https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3
plt.figure(figsize=(12, 8)) 15/35
plt.figure(figsize=(12, 8)): Crea una nueva figura con un tamaño de 12 por 8 pulgadas.
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

---------------------------------------------------------------------------
FileNotFoundError Traceback (most recent call last)
<ipython-input-1-dea1360c5265> in <cell line: 0>()
5 import seaborn as sns
6
----> 7 df = pd.read_csv('cars.csv')
8
9 # Mapa de calor con pivot (Ford)

4 frames
/usr/local/lib/python3.11/dist-packages/pandas/io/common.py in get_handle(path_or_buf, mode, encoding, compression, memory_map,
is_text, errors, storage_options)
871 if ioargs.encoding and "b" not in ioargs.mode:
872 # Encoding
--> 873 handle = open(
874 handle,
875 ioargs.mode,

FileNotFoundError: [Errno 2] No such file or directory: 'cars.csv'

trabajar con exploracion de datos en este caso trabajamos con la base de datos iris, que ya esta en la nube, no debemos exportarla

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

sepal_length sepal_width petal_length petal_width species

0 5.1 3.5 1.4 0.2 setosa

1 4.9 3.0 1.4 0.2 setosa

2 4.7 3.2 1.3 0.2 setosa

3 4.6 3.1 1.5 0.2 setosa

4 5.0 3.6 1.4 0.2 setosa

vamos a usar la scarteerplot, para graficas ahi vamos a indicar el data set con el cual trabajar, que poner en el eje X y que poner en el ese Y---

Esta línea de código crea un gráfico de dispersión (scatter plot) utilizando la librería
#scatterplot Seaborn. Aquí está el desglose de cada parte del código:
sns.scatterplot(data=iris, x='sepal_length', y='sepal_width')
Descomposición del Código
Importar Seaborn:
<Axes: xlabel='sepal_length', ylabel='sepal_width'>
python
import seaborn as sns
Cargar el conjunto de datos de Iris:

python
iris = sns.load_dataset('iris')
Este paso es necesario para asegurarnos de que tenemos el conjunto de datos iris
disponible.

Crear un gráfico de dispersión:

python
sns.scatterplot(data=iris, x='sepal_length', y='sepal_width')
data=iris: Especifica el conjunto de datos que se va a utilizar para la gráfica.

x='sepal_length': Define que la longitud del sépalo (sepal_length) se utilizará para


el eje X.

y='sepal_width': Define que el ancho del sépalo (sepal_width) se utilizará para el


eje Y.

Visualización Resultante
El gráfico de dispersión mostrará la relación entre la longitud del sépalo y el ancho
del sépalo para las flores en el conjunto de datos de Iris. Cada punto en el gráfico
representa una flor.

puedo agregar como argumento al graficador, una variable categorica para poder separar

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

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 16/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<Axes: xlabel='sepal_length', ylabel='petal_length'>

vamos a usar al joinplot, para realizar el diagrama de dispersion junto al diagrama o histograma asociadao a cada varibble, para visualizar

#join plot Desglose del Código


Importar Seaborn y cargar el conjunto de datos de Iris:
sns.jointplot(data=iris, x='sepal_length', y='petal_length')
python
import seaborn as sns
<seaborn.axisgrid.JointGrid at 0x7abde1318190>
import matplotlib.pyplot as plt

# Cargar el conjunto de datos de Iris


iris = sns.load_dataset('iris')
Crear un gráfico conjunto:

python
sns.jointplot(data=iris, x='sepal_length', y='petal_length')
Explicación del Gráfico Conjunto
data=iris: Especifica el conjunto de datos de Iris que se va a utilizar para el gráfico.

x='sepal_length': Define que la longitud del sépalo (sepal_length) se utilizará para el eje X.

y='petal_length': Define que la longitud del pétalo (petal_length) se utilizará para el eje Y.

Visualización Resultante
El gráfico conjunto (jointplot) incluye dos componentes principales:

Gráfico de Dispersión (Scatter Plot): Muestra la relación entre sepal_length y petal_length con
puntos en el gráfico.

Histogramas: Se añaden histogramas en la parte superior y en el lateral derecho del gráfico


de dispersión, mostrando la distribución de sepal_length y petal_length, respectivamente.

Código Completo
Aquí tienes el código completo que incluye la importación de las librerías necesarias y la
creación del gráfico conjunto:

python
import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos de Iris


iris = sns.load_dataset('iris')

# Crear el gráfico conjunto


sns.jointplot(data=iris, x='sepal_length', y='petal_length')

# Mostrar el gráfico
plt.show()
Cuando ejecutes este código, verás un gráfico conjunto que te permitirá visualizar la relación
entre la longitud del sépalo y la longitud del pétalo, así como las distribuciones de cada una
de estas características.

Empieza a programar o a crear código con IA.

tambien puedo segrear por una variable categorica, como en el caso anterior

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

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 17/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.JointGrid at 0x7abddf0ddc50>

scatterplot y jointplot en Seaborn, dos herramientas poderosas para la visualización de


datos:

scatterplot
Propósito: Crea gráficos de dispersión simples.

Componentes: Plota puntos individuales en un gráfico 2D, mostrando la relación entre


dos variables.

Personalización: Puedes agregar múltiples parámetros como hue, style, y size para
diferenciar subgrupos de datos.

Ejemplo:

python
import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos de Iris


iris = sns.load_dataset('iris')

# Crear el gráfico de dispersión


sns.scatterplot(data=iris, x='sepal_length', y='sepal_width')

# Mostrar el gráfico
plt.show()
(imagen referencial)

jointplot
Propósito: Combina gráficos de dispersión con histogramas y gráficos de densidad para
proporcionar más contexto.

Componentes: Además del gráfico de dispersión, incluye histogramas o gráficos de


densidad en los ejes X e Y.

Personalización: Permite ajustar el tipo de gráfico marginal (kind), como hist, kde, hex,
etc.
Haz doble clic (o pulsa Intro) para editar Ejemplo:

python
Empieza a programar o a crear código con IA. import seaborn as sns
import matplotlib.pyplot as plt

# Cargar el conjunto de datos de Iris


vamos a gaficar un blox pot iris = sns.load_dataset('iris')

# Crear el gráfico conjunto


sns.jointplot(data=iris, x='sepal_length', y='petal_length')
sns.boxplot(x='species', y='petal_length', data=iris)
# Mostrar el gráfico
plt.show()
<Axes: xlabel='species', ylabel='petal_length'> (imagen referencial)

Diferencias Clave:
Simplicidad: scatterplot es más simple y se centra solo en la relación entre dos variables.

Contexto Adicional: jointplot proporciona más contexto al incluir distribuciones


univariadas (histogramas o densidad) junto con el gráfico de dispersión.

Tipos de Gráficos Marginales: jointplot permite ajustar el tipo de gráfico marginal,


mientras que scatterplot solo se enfoca en puntos dispersos.

En Resumen
Usa scatterplot para una visualización rápida y sencilla de la relación entre dos variables.

Usa jointplot cuando necesitas analizar tanto la relación entre dos variables como sus
distribuciones individuales

Empieza a programar o a crear código con IA.

como hacer el diagrama de barra, aqui usamos el metodo barplot

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

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 18/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<Axes: xlabel='species', ylabel='sepal_length'>

iris.groupby('species')['sepal_length'].mean()

sepal_length

species

setosa 5.006

versicolor 5.936

virginica 6.588

dtype: float64

Ahora, por ejemplo para graficar otro estimador, en vez del promedio, podemos hacer lo siguiente:

from numpy import mean,median, std

sns.barplot(x='species', y='sepal_length', data=iris, estimator=median)

<Axes: xlabel='species', ylabel='sepal_length'>

sns.jointplot(data=iris,x='sepal_width',y='petal_width',hue='species')

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 19/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.JointGrid at 0x7f8fb01ddcd0>

from numpy import mean


sns.barplot(data=iris, x='species',y='sepal_length', estimator=mean, order=['virginica', 'versicolor','setosa'])

<Axes: xlabel='species', ylabel='sepal_length'>

para el grafico de barras use el promedio de la longitud del sépalo, para calcular el promedio u otra de las métricas que hemos visto en clase
se tiene que añadir el estimador en la función para hacerlo directamente sino tendríamos que agrupar y calcular el parámetro, yo use numpy
para añadir directamente el estimador

import seaborn as sns


sns.get_dataset_names()

['anagrams',
'anscombe',
'attention',
'brain_networks',
'car_crashes',
'diamonds',
'dots',
'dowjones',
'exercise',
'flights',
'fmri',
'geyser',
'glue',

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 20/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
'healthexp',
'iris',
'mpg',
'penguins',
'planets',
'seaice',
'taxis',
'tips',
'titanic']

Seaborn tiene un repositorio online con datasets de ejemplo para practicar. Para ver la lista de estos datasets se puede usar este código.

Empieza a programar o a crear código con IA.

CLASE 16- PROCESAMIENTO DE DATO NUMERICOS CON PYTON--- TRANSFORMACICON LINEALES


Claro, veamos qué hace esta línea de código raw = X[:, None, 2] en Python.
import timeit Descomposición de la línea
import numpy as np X: Supongamos que X es un array de NumPy.
import pandas as pd [:, None, 2]: Esto es una forma de indexación avanzada.
import matplotlib.pyplot as plt
from sklearn import datasets, linear_model Detalles
[:, None, 2]:
X, y = datasets.load_diabetes(return_X_y=True)
raw=X[:,None,2] :: Selecciona todos los elementos a lo largo del primer eje (filas).

None: Añade un nuevo eje, transformando X[:, 2] de un array unidimensional en uno bidimensional. Esto es equivalente a
np.newaxis.
timiiet es para poder medir el tiempo de ejeccion el modelo sklear nos va a permitir descargar un data set y liealmodel para hacer una
2: Selecciona el tercer elemento a lo largo del segundo eje (columnas).
regresion lineal sencilla, solo para validar el efecto de transformar los datos
En resumen
El código:

Empieza a programar o a crear código con IA. Toma el tercer valor (índice 2) de cada fila en X.

Añade una nueva dimensión a este subconjunto, convirtiéndolo en un array bidimensional en lugar de un array
unidimensional.
cargamos el dat setl, y agregamos unas dimensiones al data set para que se ajuste al formato de entrada previo al procesamiento
Por lo tanto, si X es un array de dimensiones (m, n), raw será un array de dimensiones (m, 1).

X, y = datasets.load_diabetes(return_X_y=True)
raw=X[:,None,2]
Sí, el cálculo de los valores de y en el conjunto de datos de diabetes es interno y es proporcionado por el propio dataset. La variable
objetivo (y) representa una medida cuantitativa de la progresión de la diabetes un año después de la medición inicial, y estos valores
han sido predefinidos en el conjunto de datos basado en estudios médicos y datos recolectados de pacientes.
ahora preparamo las reglas de escalamiento, como vismo la mas sencilla de todas es la regla de maximo yminimo
La función datasets.load_diabetes(return_X_y=True) carga estos datos ya calculados y listos para su uso. En otras palabras, no
necesitas realizar ningún cálculo adicional para obtener y; simplemente lo cargas y utilizas.

max_raw=max(raw) Si estás interesado en saber cómo realizar estos cálculos tú mismo para un conjunto de datos diferente, te podría mostrar un ejemplo
básico de cómo calcular una variable objetivo utilizando diferentes características (por ejemplo, en un modelo de regresión). Pero en
min_raw=min(raw) este caso específico, el cálculo ya está hecho y proporcionado en el conjunto de datos.
scaled=(2*raw-max_raw-min_raw)/(max_raw-min_raw)

para poder hacer una regla de escalamieto es necesario saber l distribucion delos datos, para ello vamos a hacer una grafica de los datos
para ver el tipo de distribucion de los datos originales vs los datos escalados, vemos a continuacion como hacer esto

usamo la libreria matplolib, y podemos hacer un gafico, en ella podemos definir lso ejes, axis,

creamos un objeto figura, para er la fisgura, creo una figra que contine todos los grafico, con subplot digo cuantas filas y cuantas columnas,
comparten la misma escala en x para ver el efecto del entrenamiento asigno un grafico a cada eje, arrego de dos elemento a cada elemento
asignno el grafico que yo quiera hago u n grafico tipo histograma

El método fit ajusta el modelo a los datos de entrenamiento calculando los parámetros óptimos que
fig, axs=plt.subplots(2,1,sharex=True) minimizan el error. Es un paso crucial en el flujo de trabajo de aprendizaje automático, ya que
axs[0].hist(raw) permite al modelo aprender de los datos y hacer predicciones precisas.
axs[1].hist(scaled)

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 21/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

(array([32., 66., 98., 90., 61., 53., 23., 12., 5., 2.]),
array([-1. , -0.8, -0.6, -0.4, -0.2, 0. , 0.2, 0.4, 0.6, 0.8, 1. ]), ¿Qué Hace Exactamente el Método fit?
<BarContainer object of 10 artists>) Inicialización: Cuando se llama a fit, el modelo se inicializa con los
¿Qué Hace Exactamente
¿Qué Haceparámetros
Exactamente el Método
predeterminados
el Método fit?fit?
o con los que tú hayas especificado.
Inicialización:
Inicialización: Cuando
Cuando se se
llamallamaa a fit,
fit, el el modelo
modelo sese inicializa
inicializa conconloslos
parámetrosCálculo de Parámetros:
predeterminados Paralos
o con unque modelo
tú de regresión
hayas lineal, fit
especificado.
parámetros predeterminados o con los que tú hayas
calcula los coeficientes que minimizan la suma de los errores especificado.
Cálculo cuadrados entreParalas predicciones delregresión
modelo y los valores reales.los
Cálculo dede Parámetros:
Parámetros: Para unun modelo
modelo dede lineal,
regresión lineal, fit calcula
fit calcula los
coeficientes
coeficientes queque minimizan
minimizan la la suma
suma de de
los los errores
errores cuadrados
cuadrados entreentre
laslas
Ecuación
predicciones del de la Recta:
modelo y los En la regresión
valores reales. lineal, la ecuación es
predicciones del modelo y los valores reales.
=0+11+22++ . El objetivo del método fit es encontrar los valores
Ecuación óptimos para los coeficientes . lineal, la ecuación es
Ecuación dede la Recta:
la Recta: EnEn la regresión
la regresión lineal, la ecuación es
=0=0+11+22++ Optimización: Utiliza algoritmos de optimización, como el descenso
+ . El objetivo del método fit es encontrar
de gradiente, para ajustar los parámetros los valoresdelóptimos
modelo para los
iterativamente
coeficientes .
y reducir el error.
1
Optimización: Utiliza Durante
Evaluación: algoritmos de optimización,
el ajuste, el modelo evalúacomo su el descenso
desempeño deen
1 gradiente,lospara ajustar
datos los parámetros
de entrenamiento del modelo
y ajusta iterativamente
los parámetros y
para mejorar la
+ reducir el error.
precisión de las predicciones.

2 Evaluación: Durante el ajuste, el modelo evalúa su desempeño en los


datos de entrenamiento y ajusta los parámetros para mejorar la precisión
2 de las predicciones.
+

. El objetivo del método fit es encontrar los valores óptimos para los
coeficientes
arriga los datos orignales y los escalaado vemos que esta entre 1 y -1, pero vemos que no es una campana y tiene un cierto sesgo pero
elesclaamento ya est .
El método de entrenamiento fit es una función fundamental en Scikit-learn y otras bibliotecas de
aprendizaje automático. Se utiliza para ajustarUtiliza
Optimización: un modelo de aprendizaje
algoritmos automático
de optimización, comoa el
losdescenso
datos de de
entrenamiento. Aquí tienes una gradiente,
explicaciónpara
detallada
ajustarde
loscómo funciona:
parámetros del modelo iterativamente y reducir
Haz doble clic (o pulsa Intro) para editar el error.

Evaluación: Durante el ajuste, el modelo evalúa su desempeño en los datos


de entrenamiento y ajusta los parámetros para mejorar la precisión de las
modelo de entranamiento, definmos ula funcion para entrenar el modleo decimo que la funcion coja el limeal model y que de alli use la
predicciones.
regresion lineal y que ese modelo lo ajuste a unos datos, los datos que defini arriba la variable X y la variable y si es que hay que precedir
unm modelo, los predictores crudos que yo hago raw y la variable y, si ,

def: Palabra clave para definir una nueva función en Python.


def train_raw():
train_raw(): Nombre de la función.
linear_model.LinearRegression().fit(raw,y) linear_model.LinearRegression(): Crea una instancia del modelo de regresión lineal de Scikit-learn.

.fit(raw, y): Ajusta el modelo a los datos de entrenamiento, donde raw son las características (features) y y es la variable objetivo
def train_scaled(): (target).
linear_model.LinearRegression().fit(scaled,y)
linear_model: Proviene del módulo sklearn, que es una librería de Python utilizada para aprendizaje automático y modelado
estadístico.

LinearRegression(): Es una clase dentro del módulo linear_model de Scikit-learn que implementa una regresión lineal ordinaria.

aso a Paso .fit(X, y): Método de entrenamiento que ajusta el modelo a los datos proporcionados.
Importar Librerías:
tambien definimos como es el modleo se ajusta al modelo escalado
datasets: Contiene varios conjuntos de datos de ejemplo, como el conjunto de datos de diabetes.

linear_model: Incluye diferentes modelos de regresión, como LinearRegression.


Empieza a programar o a crear código con IA.
Cargar los Datos:

X: Matriz de características. En el caso del conjunto de datos de diabetes, X contiene variables independientes como edad, sexo,
Empieza a programar o a crear código con IA.
índice de masa corporal, presión arterial, entre otras.

y: Vector objetivo. Representa la progresión de la diabetes, que es la variable que queremos predecir.
ahora aua estoy listo para calcular los tiempos de ejecucion del modelo, mid oun pequepo snipe den pyton para lo que yo quiero, escribo el
Crear una Instancia del Modelo:
tiempo para el modleo escalado, con la funcon timeit voy a medir un pqeiqueno snpe de codig oen pyton de cuanto , el snipe es el modlo de
modelo = linear_model.LinearRegression(): Crea un objeto del modelo de regresión lineal.
entrenamiento que yo quiero con los datos, y quiero que repita esa ejecucion un cierto numero de veces, para calcular el tiempo tal cual,
Ajustar el Modelo:
tambem escrio el tiempo para el modelo escalado
modelo.fit(X, y): El método fit ajusta el modelo a los datos de entrenamiento (X y y). Realiza los siguientes pasos internos:

Cálculo de Parámetros: Calcula los parámetros del modelo (en el caso de la regresión lineal, los coeficientes y la intersección) que
raw_time=timeit.timeit(train_raw,number=100)
minimizan el error entre las predicciones del modelo y los valores reales.
scaled_time=timeit.timeit(train_scaled,number=100)
Entrenamiento: Utiliza técnicas como el descenso de gradiente para iterar sobre los datos y ajustar los parámetros.
print('train raw: {}'.format(raw_time))
timeit.timeit(train_raw, number=100):
print('train scaled: {}'.format(scaled_time))
timeit.timeit: Es una función del módulo timeit que mide el tiempo de ejecución de un fragmento de código.
train raw: 0.11091579300000376
train_raw: La función que se está midiendo. En este caso, es la función que entrena un modelo de regresión lineal utilizando datos sin
train scaled: 0.0969008990000475
escalar (raw).

number=100: Indica que la función train_raw se ejecutará 100 veces para medir el tiempo total de ejecución.
observamos ua reduccion en el modelo de ejecucion del modleo escaladao, y es eso lo que queriamos, con esto se evidencia que el efecto
de escalar datos si contribuye a que el algoritmo tenga una mejor convergencia

.max-min scaling: mejor para datos uniformemente distribuidos .z-score scaling mejor para datos distriuidos normalmete (forma de campaa
de gauss)

Empieza a programar o a crear código con IA.

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 22/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

ahora hacemo el escalamiento con el valor Z

#Reglas de escalamiento

max_raw = max(raw)
fig, axs = plt.subplots(3, 1, sharex=True):
min_raw = min(raw)
scaled = (2*raw - max_raw - min_raw) / (max_raw - min_raw) plt.subplots(3, 1, sharex=True): Crea una figura con 3 subplots (gráficas) en una sola
columna (3 filas y 1 columna). La opción sharex=True indica que todas las subplots
compartirán el mismo eje x.
mu = np.mean(raw)
sigma = np.std(raw) axs[0].hist(raw):

axs[0]: Selecciona el primer subplot.


scaled_z = (raw - mu) / sigma
hist(raw): Crea un histograma de los datos en raw.

fig, axs = plt.subplots(3, 1, sharex=True) axs[1].hist(scaled):


axs[0].hist(raw)
axs[1]: Selecciona el segundo subplot.
axs[1].hist(scaled)
axs[2].hist(scaled_z) hist(scaled): Crea un histograma de los datos en scaled.

axs[2].hist(scaled_z):
(array([32., 66., 98., 90., 61., 53., 23., 12., 5., 2.]),
array([-1.89792941, -1.34956464, -0.80119987, -0.2528351 , 0.29552967, axs[2]: Selecciona el tercer subplot.
0.84389444, 1.39225921, 1.94062398, 2.48898875, 3.03735352,
hist(scaled_z): Crea un histograma de los datos en scaled_z.
3.58571828]),
<BarContainer object of 10 artists>) Finalidad del Código
El objetivo es visualizar y comparar la distribución de los datos originales (raw), los datos
escalados (scaled) y los datos escalados utilizando la estandarización z-score (scaled_z).

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.preprocessing import StandardScaler

# Cargar el conjunto de datos de diabetes


X, y = datasets.load_diabetes(return_X_y=True)

# Seleccionar una característica y añadir una nueva dimensión


raw = X[:, None, 2]

# Escalar los datos utilizando min-max scaling


max_raw = raw.max()
min_raw = raw.min()
scaled = (2 * raw - max_raw - min_raw) / (max_raw - min_raw)

# Escalar los datos utilizando z-score scaling


mu = np.mean(raw)
sigma = np.std(raw)
scaled_z = (raw - mu) / sigma

# Crear las gráficas


fig, axs = plt.subplots(3, 1, sharex=True, figsize=(8, 12))
axs[0].hist(raw, bins=20, color='blue', alpha=0.7)
axs[0].set_title('Histograma de Raw')
axs[1].hist(scaled, bins=20, color='green', alpha=0.7)
axs[1].set_title('Histograma de Scaled (Min-Max)')
axs[2].hist(scaled_z, bins=20, color='red', alpha=0.7)
axs[2].set_title('Histograma de Scaled (Z-Score)')
TRANSFORMACIONES NO LINEALES ADECUADA CUANDO TENEMOS DATOS QUE NO SE CONOCEN plt.xlabel('Valores')
SU DISTRIBUCION, esto podemos verlo
plt.tight_layout()
en el catago de autos usado, vemos que habia distribucion fuertemente sesgadas plt.show()

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

###distribucion sesgada,

df.price_usd.hist()

<Axes: >

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 23/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

corroboramos que la distribucion es sesgadao, entonces hacemos la transformacion con la tangente hiperboilca

## transformacion en la tangente
df.price_usd.apply(lambda x: np.tanh(x)).hist()

<Axes: >

df.price_usd.apply(lambda x: np.tanh(x)):

df.price_usd: Accede a la columna price_usd del DataFrame df, que contiene los precios de los automóviles en dólares estadounidenses.

apply(lambda x: np.tanh(x)): Aplica una función lambda (una función anónima) a cada valor de la columna price_usd. En este caso, la función lambda aplica la función
tangente hiperbólica (np.tanh(x)) de NumPy a cada valor x.

np.tanh(x):

La función tanh (tangente hiperbólica) toma un valor x y devuelve un valor transformado que está entre -1 y 1. Es una función que se utiliza comúnmente para escalar o
transformar datos, especialmente en el contexto de funciones de activación en redes neuronales.

.hist():

Una vez aplicada la transformación, se genera un histograma de los valores transformados utilizando la función hist() de Pandas, que crea una representación gráfica de la
distribución de estos valores.

Propósito del Código


El propósito de este código es transformar los valores de la columna price_usd utilizando la tangente hiperbólica y luego visualizar la distribución de estos valores
transformados con un histograma.

La tangente hiperbólica comprime los valores de entrada en el rango de -1 a 1, lo cual puede ser útil para reducir el efecto de valores extremos o atípicos y analizar mejor la
distribución de los datos transformados.

pero vemos que se colapso todo, porque la tangente hiperbolica necesita un numero para poder equlibrar balancearse, por lo que vamos a
usar un valor p

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

<Axes: >

el efet que distiuyo los datos de manera uniforme, en el link hay una formas interesantes de coom mapear datos https://scikit-
learn.org/stable/auto_examples/preprocessing/plot_map_data_to_normal.html#sphx-glr-auto-examples-preprocessing-plot-map-data-to-
normal-py

calse 17 - pipeline para variables categoricas Hay errores en la notación de Pandas y los tratan como que ambos modelos son lo mismo,
pero en la realidad el Dummy no se usa. Aún así, en Pandas el método es .get_dummies().

aqui puedes aprender un poco de hot https://interactivechaos.com/es/manual/tutorial-de-machine-learning/one-hot-encoding

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

en panda hay una funcio que se llama get_dumies(), veasmo que sucede con esta funcion, aplico ala columna engine_tyoa y vemos cual es
el resutlado de ello

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 24/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
pd.get_dummies(df['engine_type'])

La función pd.get_dummies() de la librería pandas se usa para convertir una columna


diesel electric gasoline
categórica en varias columnas binarias (o dummy variables). Esto es útil en el análisis de
0 False False True datos y el aprendizaje automático porque muchos algoritmos requieren que los datos
categóricos estén en formato numérico.
1 False False True
En tu caso, pd.get_dummies(df['engine_type']) toma la columna engine_type del DataFrame
2 False False True df y la convierte en varias columnas dummy. Por ejemplo, si engine_type contiene valores
como "diesel", "electric" y "gasoline", el resultado será un nuevo DataFrame con una columna
3 False False True para cada tipo de motor, con valores de 0 o 1 indicando la presencia o ausencia de cada tipo
4 False False True
en cada fila.

... ... ... ...

38526 False False True


Las variables dummy son especialmente útiles en una variedad de modelos de machine learning y análisis de
datos. Algunos de los tipos de modelos que se benefician de estas variables incluyen:
38527 True False False

38528 False False True Modelos lineales


Regresión Lineal: Ideal para problemas de regresión, donde se intenta predecir un valor continuo.
38529 False False True
Regresión Logística: Se utiliza para problemas de clasificación binaria (sí/no).
38530 False False True
Modelos de ensamble
38531 rows × 3 columns Random Forest: Combina múltiples árboles de decisión para mejorar la precisión y controlar el sobreajuste.

Gradient Boosting Machines (GBM): Modelos como XGBoost, LightGBM y CatBoost, que funcionan de manera
similar a los random forests pero con técnicas de boosting.
vemos que la convirtio en 3 columnas, porque tres columnas porque tenemos 3 categorias diferentes, o sea treas valoes para ese atributo,
Redes neuronales
es lo que cnocemos como one hot, en panda es dumies
Redes Neuronales Artificiales (ANN): Utilizadas tanto para clasificación como para regresión.

Redes Neuronales Recurrentes (RNN): Útiles para series temporales y datos secuenciales.
import sklearn.preprocessing as preprocessing
encoder=preprocessing.OneHotEncoder(handle_unknown='ignore')
Modelos de clasificación
Árboles de Decisión: Simples de interpretar y visualizar, ideales para problemas de clasificación.

Empieza a programar o a crear código con IA. Support Vector Machines (SVM): Se benefician de las variables dummy cuando se usa el kernel lineal.

Modelos de clustering y reducción de dimensionalidad


K-Means
importo la libreria sklearn cunado llegguen valores que Clustering:
no se estan en elaAyuda a agrupar
categoria datos en clusters
contempladas y que(agrupaciones) homogéneos.el puede
yo necesite codificarlas
codificarlo como un vector de ceros com habiamos dicho
Principal Component Analysis (PCA): Aunque PCA no se beneficia directamente de las variables dummy,
convertir categorías en variables numéricas facilita su aplicación en datos con características mixtas.

Las variables
ahora el endocer tengo que le digo que se ajuste ala columna dummy permiten
engine_type que es aprecisamente
estos modelos interpretar correctamente las relaciones categóricas en los
datos, transformando información cualitativa en un formato numérico que los algoritmos pueden procesar
eficazmente.
encoder.fit(df[['engine_type']].values)

▾ OneHotEncoder i ?

OneHotEncoder(handle_unknown='ignore')

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

array([[0., 0., 0.],


[1., 0., 0.],
[0., 0., 0.]])

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

▾ OneHotEncoder i ?

OneHotEncoder(handle_unknown='ignore')

encoder.transform([[2010],[2011],[2012]]).toarray()

array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.]])

la desventaje de one-host es el aumneto del tamaño de la variable que se crea para contneer los nuevos valores, en elcaso de lacatgoria tipo
de motto, se cre un array de 3 valoes diferntes, esto aumenta considerableme el tamaño por lo que no es efectivo para el modelo, esto es una
desventja, esto nos lleva a buscar luego una reduccion de los datos desues vemos que cuand introducimoe el concepto de correlcion
tambien nos da un motivo para la reduccion de los datos
https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 25/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

vamos a introducir el concpto de correlacion y com oeste concepto nos lleva al concetpo de reduccion de datos,

La sentencia from sklearn.preprocessing import StandardScaler sirve para importar la clase


clase 19 correlaciones StandardScaler de la librería sklearn, que se utiliza para estandarizar (normalizar) los datos.

¿Qué hace StandardScaler?


import numpy as np StandardScaler transforma los datos de tal manera que tengan media 0 y desviación estándar 1.
import matplotlib.pyplot as plt Esto es útil porque muchos algoritmos de machine learning funcionan mejor cuando las
import pandas as pd características de entrada tienen una escala similar.
import seaborn as sns
¿Por qué es importante estandarizar los datos?
from sklearn.preprocessing import StandardScaler
Estandarizar los datos puede mejorar el rendimiento y la precisión de los modelos de machine
iris=sns.load_dataset('iris') learning. Algunos de los beneficios son:

Mejora la convergencia del modelo: Al reducir las diferencias en escala, los algoritmos pueden
ahora vamos a graficar, para poder visulizar las correlaciones de todas las más
converger variables,
rápidamente.

esto los consegimos con la matriz de covarianza, pero ahora vamos


Evitaa que
ver las
el metodo visual dominen:
características pariplot de
En seaborn
algunos algoritmos, como la regresión lineal y las redes
neuronales, las características de mayor escala pueden dominar y afectar el entrenamiento del
Elemento de lista modelo.

Elemento de lista Mejora la interpretación de los coeficientes: En modelos lineales, los coeficientes son más fáciles
de interpretar cuando las características están en la misma escala.

sns.pairplot(iris)

<seaborn.axisgrid.PairGrid at 0x7e2468f50ed0>

lo que visualiza es una diagrama de dispersion de las variables, y observamos la dispersion de los puntos o grafica ,

ahora loq ue tendriamos que hacer, podriao categorizzarlo con e l metod hue podriamos colorearl los datos pra ver los grafico de dispercion
para ver si hay correlaciones claras con ciertos grupos o no

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

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 26/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.PairGrid at 0x7e246924fd90>

vamos con la parte analitica,}ara ello creo un standar de los datos corro el scalador aplico el scalador a los datos pero no voy a usar todas
las categorias por ejempo hay una categoria que no necesito

scaler=StandardScaler()
scaled= scaler.fit_transform(
iris[['sepal_length','sepal_width','petal_length','petal_width']] StandardScaler transforma los datos de tal manera que tengan media 0 y
) desviación estándar 1. Esto es útil porque muchos algoritmos de machine
learning funcionan mejor cuando las características de entrada tienen una escala
similar.

¿Por qué es importante estandarizar los datos?


no va con 3 corchetes, como lo hace en el video Estandarizar los datos puede mejorar el rendimiento y la precisión de los
modelos de machine learning. Algunos de los beneficios son:

scaled Mejora la convergencia del modelo: Al reducir las diferencias en escala, los
algoritmos pueden converger más rápidamente.
array([[-9.00681170e-01, 1.01900435e+00, -1.34022653e+00,
Evita que las características dominen: En algunos algoritmos, como la regresión
-1.31544430e+00],
lineal y las redes neuronales, las características de mayor escala pueden
[-1.14301691e+00, -1.31979479e-01, -1.34022653e+00, dominar y afectar el entrenamiento del modelo.
-1.31544430e+00],
[-1.38535265e+00, 3.28414053e-01, -1.39706395e+00, Mejora la interpretación de los coeficientes: En modelos lineales, los coeficientes
-1.31544430e+00], son más fáciles de interpretar cuando las características están en la misma
[-1.50652052e+00, 9.82172869e-02, -1.28338910e+00, escala.
-1.31544430e+00],
[-1.02184904e+00, 1.24920112e+00, -1.34022653e+00,
-1.31544430e+00],
[-5.37177559e-01, 1.93979142e+00, -1.16971425e+00,
-1.05217993e+00],
[-1.50652052e+00, 7.88807586e-01, -1.34022653e+00,
-1.18381211e+00],
[-1.02184904e+00, 7.88807586e-01, -1.28338910e+00,
-1.31544430e+00],
[-1.74885626e+00, -3.62176246e-01, -1.34022653e+00,
-1.31544430e+00],
[-1.14301691e+00, 9.82172869e-02, -1.28338910e+00,
-1.44707648e+00],
[-5.37177559e-01, 1.47939788e+00, -1.28338910e+00,
-1.31544430e+00],
[-1.26418478e+00, 7.88807586e-01, -1.22655167e+00,
-1.31544430e+00],
[-1.26418478e+00, -1.31979479e-01, -1.34022653e+00,
-1.44707648e+00],
[-1.87002413e+00, -1.31979479e-01, -1.51073881e+00,
-1.44707648e+00],
[-5.25060772e-02, 2.16998818e+00, -1.45390138e+00,
-1.31544430e+00],
[-1.73673948e-01, 3.09077525e+00, -1.28338910e+00,
-1.05217993e+00],
[-5.37177559e-01, 1.93979142e+00, -1.39706395e+00,
-1.05217993e+00],
[-9.00681170e-01, 1.01900435e+00, -1.34022653e+00,
-1.18381211e+00],
[-1.73673948e-01, 1.70959465e+00, -1.16971425e+00,

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 27/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
-1.18381211e+00],
[-9.00681170e-01, 1.70959465e+00, -1.28338910e+00,
-1.18381211e+00],
[-5.37177559e-01, 7.88807586e-01, -1.16971425e+00,
-1.31544430e+00],
[-9.00681170e-01, 1.47939788e+00, -1.28338910e+00,
-1.05217993e+00],
[-1.50652052e+00, 1.24920112e+00, -1.56757623e+00,
-1.31544430e+00],
[-9.00681170e-01, 5.58610819e-01, -1.16971425e+00,
-9.20547742e-01],
[-1.26418478e+00, 7.88807586e-01, -1.05603939e+00,
-1.31544430e+00],
[-1.02184904e+00, -1.31979479e-01, -1.22655167e+00,
-1.31544430e+00],
[-1.02184904e+00, 7.88807586e-01, -1.22655167e+00,
-1.05217993e+00],
[-7.79513300e-01, 1.01900435e+00, -1.28338910e+00,
-1.31544430e+00],
[-7.79513300e-01, 7.88807586e-01, -1.34022653e+00,
-1.31544430e+00],

vemos que los numeros ya estan normalizado, esta normalizacion tien en cuenta restar por el promedio y dividir por la desviacion estandar

necesito transponer los datos, para organizarlo de otra manera

scaled.T

array([[-9.00681170e-01, -1.14301691e+00, -1.38535265e+00,


-1.50652052e+00, -1.02184904e+00, -5.37177559e-01,
-1.50652052e+00, -1.02184904e+00, -1.74885626e+00,
-1.14301691e+00, -5.37177559e-01, -1.26418478e+00,
-1.26418478e+00, -1.87002413e+00, -5.25060772e-02,
-1.73673948e-01, -5.37177559e-01, -9.00681170e-01,
-1.73673948e-01, -9.00681170e-01, -5.37177559e-01,
-9.00681170e-01, -1.50652052e+00, -9.00681170e-01,
-1.26418478e+00, -1.02184904e+00, -1.02184904e+00,
-7.79513300e-01, -7.79513300e-01, -1.38535265e+00,
-1.26418478e+00, -5.37177559e-01, -7.79513300e-01,
-4.16009689e-01, -1.14301691e+00, -1.02184904e+00,
-4.16009689e-01, -1.14301691e+00, -1.74885626e+00,
-9.00681170e-01, -1.02184904e+00, -1.62768839e+00,
-1.74885626e+00, -1.02184904e+00, -9.00681170e-01,
-1.26418478e+00, -9.00681170e-01, -1.50652052e+00,
-6.58345429e-01, -1.02184904e+00, 1.40150837e+00,
6.74501145e-01, 1.28034050e+00, -4.16009689e-01,
7.95669016e-01, -1.73673948e-01, 5.53333275e-01,
-1.14301691e+00, 9.16836886e-01, -7.79513300e-01,
-1.02184904e+00, 6.86617933e-02, 1.89829664e-01,
3.10997534e-01, -2.94841818e-01, 1.03800476e+00,
-2.94841818e-01, -5.25060772e-02, 4.32165405e-01,
-2.94841818e-01, 6.86617933e-02, 3.10997534e-01,
5.53333275e-01, 3.10997534e-01, 6.74501145e-01,
9.16836886e-01, 1.15917263e+00, 1.03800476e+00,
1.89829664e-01, -1.73673948e-01, -4.16009689e-01,
-4.16009689e-01, -5.25060772e-02, 1.89829664e-01,
-5.37177559e-01, 1.89829664e-01, 1.03800476e+00,
5.53333275e-01, -2.94841818e-01, -4.16009689e-01,
-4.16009689e-01, 3.10997534e-01, -5.25060772e-02,
-1.02184904e+00, -2.94841818e-01, -1.73673948e-01,
-1.73673948e-01, 4.32165405e-01, -9.00681170e-01,
-1.73673948e-01, 5.53333275e-01, -5.25060772e-02,
1.52267624e+00, 5.53333275e-01, 7.95669016e-01,
2.12851559e+00, -1.14301691e+00, 1.76501198e+00,
1.03800476e+00, 1.64384411e+00, 7.95669016e-01,
6.74501145e-01, 1.15917263e+00, -1.73673948e-01,
-5.25060772e-02, 6.74501145e-01, 7.95669016e-01,
2.24968346e+00, 2.24968346e+00, 1.89829664e-01,
1.28034050e+00, -2.94841818e-01, 2.24968346e+00,
5.53333275e-01, 1.03800476e+00, 1.64384411e+00,
4.32165405e-01, 3.10997534e-01, 6.74501145e-01,
1.64384411e+00, 1.88617985e+00, 2.49201920e+00,
6.74501145e-01, 5.53333275e-01, 3.10997534e-01,
2.24968346e+00, 5.53333275e-01, 6.74501145e-01,
1.89829664e-01, 1.28034050e+00, 1.03800476e+00,
1.28034050e+00, -5.25060772e-02, 1.15917263e+00,
1.03800476e+00, 1.03800476e+00, 5.53333275e-01,
7.95669016e-01, 4.32165405e-01, 6.86617933e-02],
[ 1.01900435e+00, -1.31979479e-01, 3.28414053e-01,
9.82172869e-02, 1.24920112e+00, 1.93979142e+00,
7.88807586e-01, 7.88807586e-01, -3.62176246e-01,
9.82172869e-02, 1.47939788e+00, 7.88807586e-01,
-1.31979479e-01, -1.31979479e-01, 2.16998818e+00,
3.09077525e+00, 1.93979142e+00, 1.01900435e+00,
1.70959465e+00, 1.70959465e+00, 7.88807586e-01,
1.47939788e+00, 1.24920112e+00, 5.58610819e-01,

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 28/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

podemos hacer la lectura, que el primer subarreglo son todos los datos dela primera variable, el segundo todos los datos de la segunda
variable, y asi sucesivemente

entones eya tenemso los datos escalados normalizados ya podemos armar la matriz de covarianza con el metodo de numpy con esa libreria

covariance_matrix=np.cov(scaled.T)

covariance_matrix

array([[ 1.00671141, -0.11835884, 0.87760447, 0.82343066],


[-0.11835884, 1.00671141, -0.43131554, -0.36858315],
[ 0.87760447, -0.43131554, 1.00671141, 0.96932762],
[ 0.82343066, -0.36858315, 0.96932762, 1.00671141]])

Empieza a programar o a crear código con IA.

podemos usar un mapa de calor, usando libreria seaborn, para que sea mas agradable visualmente

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'])

CLASE 23 REDUCCION DE DIMENSIONALIDAD CON PCA

como vimos lo que es el analisis de componentes principales nos permite por medio de los vectores y valores propios de la matriz de
covarianza, nos permite identificar esas relaciones especiales mediante las cuales capturamos la mayor cantidad de varianza de los datos,
esto puede implicar que lo que son un conjunto de datos que son de 10, 20 0 30 variables por decir algo podemos reducirlo a una menor
cantidad de variables capturando una cantidad minima suficiente de varianza, por ejemlo estoy dispuesto a sacrificar un cierto porcentjae de
varianza, pero ahi estoy logrando reducir un numero de variables y eso tambien me va a facilitar darle al modelo de machine learing una
cantidad de datos menor para que procese. lo que queremos ahora es evidenciar esto en pyton para entender como es que podemos hacer
esa reduccionalidad de datos.

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 29/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

importamos las librerias necesarias tenemos scalr, importamo el iris aplicasmo escalamiento a las 4 columnas,

Añadir blockquote

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

array([[ 1.00671141, -0.11835884, 0.87760447, 0.82343066],


[-0.11835884, 1.00671141, -0.43131554, -0.36858315],
[ 0.87760447, -0.43131554, 1.00671141, 0.96932762],
[ 0.82343066, -0.36858315, 0.96932762, 1.00671141]])

teneos el esclar z- aplicacmosl escalameit a las 4 counas numeraica }y construimos la matriz de covariranza

ahora vamos a identificar cual es el numero minnimo de variables o coordenadas que necesitamos para describir nuestro data set, esto lo
hacemos basados en las correlaciones primeor queremos ver visualizaremos, aqui evidneicamos longitus de petalo y ancho de petalo, y me
nefoque en dibujar el diagrama de dispersion de esos datos

sns.pairplot(iris)

<seaborn.axisgrid.PairGrid at 0x7e9685f9b490>

podemos observar graficamente las relaciones o correlaciones entre los atributos, por loq ue nos interesaria solo dibujar estos varibale que
estan mas correlacionadas, para ello d

sns.jointplot(x=iris['petal_length'], y=iris['petal_width'])

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 30/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

<seaborn.axisgrid.JointGrid at 0x7e96853b7290>

necesitamos PCA, datos escalados, para ello buscamos valores Z

en la clase anterior el pca calculaba la sombre de los vectores pero considerando que los datos estaban centrados, y esto es mas evidente si
nosotros tenemos un conjunto de datos que tiene nun promedio cero y una desviacion estndar 1, o sea datos estandarizados vemos
eldiagrama con la escla distinta, si bien se aprecia la misma distribucion de los datos, vemos que la escala es difernte

Haz doble clic (o pulsa Intro) para editar

sns.jointplot(x=scaled[:,2], y=scaled[:,3])

<seaborn.axisgrid.JointGrid at 0x7e9681ee4610>

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 31/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab

ahora viene la marte interesante ahora usaremos de numpy el mento eig, que clacula la descomposicion de vectores valores de vectores
propios de una matriz de forma inmediata np.linalg.eig a la cual debo pasarle un valor

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

eig calcula la descoposicio en vectores y valors propios de la matriz, eig en values esta asociado a valore propio, el eig lo aplco sobre la
matriz que voy a descomponer,

Haz doble clic (o pulsa Intro) para editar

vamos como quedron los valores propios

eigen_values

array([2.93808505, 0.9201649 , 0.14774182, 0.02085386])

puedo ver como quedo la matriz, tenemos 4 valores porque la matriz tiene un tamaño de cuatro vectores

puedo ver el valor de los vectores

eigen_vectors

array([[ 0.52106591, -0.37741762, -0.71956635, 0.26128628],


[-0.26934744, -0.92329566, 0.24438178, -0.12350962],
[ 0.5804131 , -0.02449161, 0.14212637, -0.80144925],
[ 0.56485654, -0.06694199, 0.63427274, 0.52359713]])

puedo ver los vectores propioas, esto es la teron de como descomponer las matrices, dijimo que los vectores van a capturar la mayor
cantidad de varianza de los datos, y que cada una de estas direcciones es lo qu ellamamos direccion principal, cada vector propio es una de
las direciones principales, a lo largo de lo cual capturamos varianza

dijimos que los vectores y valores propios van a capturar la mayor cantidad de vairanza de los datos y que cada uno de estas direcciones es
lo quellamamos direccion principal, recordando cada uno de los vectores propio es una diercion principal a lo largo de la cual capturamos
varianza de los datos originales

como podemor ver esto, creamos una lista que se llame variznaexplained, voy a recorrer cada valor propio para calcular la varianza que ellos
explican de acuerdo a la teoria matematica lo que , la variazna que ellos explican se puede calcular proporcinl a la relacion del valor propio
proporcional y la suma de todos los valores propios que estn detnro de esa matrziz i values son los valores propioas asi normalizao el
porcentaje en base a toso los valores propioas

Empieza a programar o a crear código con IA.

Haz doble clic (o pulsa Intro) para editar

###para poder visualizarlso vamos a crear una lista de varianza


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

[72.9624454132999]
[72.9624454132999, 22.850761786701725]
[72.9624454132999, 22.850761786701725, 3.668921889282867]
[72.9624454132999, 22.850761786701725, 3.668921889282867, 0.5178709107155016]

la primer compoente calual el 72 porcienteo de las varianzas, de los vectores, esto quiere decir que una tercenra componente y una cuarta
componente puede ser despreciable,

Empieza a programar o a crear código con IA.

como podemos coger la transformacion que estan en esos datos que estan en 4 dimeniones, y reducirlso e menos dimensiones en base a
esto pasma a usar sllear con esta funcion puedo crear una isntnacio del metodos de composisind e PC a

from sklearn.decomposition import PCA


pca=PCA(n_components=2)

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 32/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
pca.fit(scaled)
pca.explained_variance_ratio_

array([0.72962445, 0.22850762])

utilizao el pcs y reduzcoa 3 componentes, luegoa aplico fit sobre los datos escalados puedo ver el radio de la varizanz explicada por cada
uno de los valores propiios y por cada uno de las direcciones

Empieza a programar o a crear código con IA.

Haz doble clic (o pulsa Intro) para editar

pca.explained_variance_ratio_

array([0.72962445, 0.22850762])

aqui me dice las dos direccioes principales son, la primera captura el 72% de la varianza y la segurnda el 22% esto coindice con los que
hicimos anteriormente, con los dos valores entregado en al vector de 4 compontnees

tambien podemos hacer una reduccion de los datos, tenemos 4 coponentes y llega a 2 aqui lo que se hace es crear nuevas variables,
entonces calclo las vairbles reducidasd de las variebles escalardas previamente

reduced_scaled=pca.transform(scaled)

225 1 of 1 problem

AttributeError: 'PCA' object has no attribute 'transformr'

reduced_scaled

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 33/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
[ 2.04055823, 0.8675206 ],
[ 1.9981471 , 1.04916875],
[ 1.87050329, 0.38696608],
[ 1.56458048, -0.89668681],
[ 1.5211705 , 0.26906914],
[ 1.37278779, 1.01125442],
[ 0.96065603, -0.02433167]])

el metodo transforma, me transforma los valores, el resutlado final, cda data point tiene solo 2 componnte

si coloco los datos originales , vemos los 4 atributos, ancho, largo de petalo y hoja

scaled

[-2.94841818e-01, -5.92373012e-01, 6.49083415e-01,


1.05393502e+00],
[ 2.24968346e+00, -5.92373012e-01, 1.67215710e+00,
1.05393502e+00],
[ 5.53333275e-01, -8.22569778e-01, 6.49083415e-01,
7.90670654e-01],
[ 1.03800476e+00, 5.58610819e-01, 1.10378283e+00,
1.18556721e+00],
[ 1.64384411e+00, 3.28414053e-01, 1.27429511e+00,
7.90670654e-01],
[ 4.32165405e-01, -5.92373012e-01, 5.92245988e-01,
7.90670654e-01],
[ 3.10997534e-01, -1.31979479e-01, 6.49083415e-01,
7.90670654e-01],
[ 6.74501145e-01, -5.92373012e-01, 1.04694540e+00,
1.18556721e+00],
[ 1.64384411e+00, -1.31979479e-01, 1.16062026e+00,
5.27406285e-01],
[ 1.88617985e+00, -5.92373012e-01, 1.33113254e+00,
9.22302838e-01],
[ 2.49201920e+00, 1.70959465e+00, 1.50164482e+00,
1.05393502e+00],
[ 6.74501145e-01, -5.92373012e-01, 1.04694540e+00,
1.31719939e+00],
[ 5.53333275e-01, -5.92373012e-01, 7.62758269e-01,
3.95774101e-01],
[ 3.10997534e-01, -1.05276654e+00, 1.04694540e+00,
2.64141916e-01],
[ 2.24968346e+00, -1.31979479e-01, 1.33113254e+00,
1.44883158e+00],
[ 5.53333275e-01, 7.88807586e-01, 1.04694540e+00,
1.58046376e+00],
[ 6.74501145e-01, 9.82172869e-02, 9.90107977e-01,
7.90670654e-01],
[ 1.89829664e-01, -1.31979479e-01, 5.92245988e-01,
7.90670654e-01],
[ 1.28034050e+00, 9.82172869e-02, 9.33270550e-01,
1.18556721e+00],
[ 1.03800476e+00, 9.82172869e-02, 1.04694540e+00,
1.58046376e+00],
[ 1.28034050e+00, 9.82172869e-02, 7.62758269e-01,
1.44883158e+00],
[-5.25060772e-02, -8.22569778e-01, 7.62758269e-01,
9.22302838e-01],
[ 1.15917263e+00, 3.28414053e-01, 1.21745768e+00,
1.44883158e+00],
[ 1.03800476e+00, 5.58610819e-01, 1.10378283e+00,
1.71209594e+00],
[ 1.03800476e+00, -1.31979479e-01, 8.19595696e-01,
1.44883158e+00],
[ 5.53333275e-01, -1.28296331e+00, 7.05920842e-01,
9.22302838e-01],
[ 7.95669016e-01, -1.31979479e-01, 8.19595696e-01,
1.05393502e+00],
[ 4.32165405e-01, 7.88807586e-01, 9.33270550e-01,
1.44883158e+00],
[ 6.86617933e-02, -1.31979479e-01, 7.62758269e-01,
7.90670654e-01]])

con esto tenemos claro que el pca esta reduciendo los datos, que en total esta capurando la suma de la variana entre 72 y 22 o sea estamos
en la suma de mas del 90% en cual es decente, ahora queremos ver como se evidencia este dataset con respeto de la catgoria de flores
comencemos pensado en un modleo supervisado que este aosciado a la categoria, especie de la flor

por comodidad asigno las componente reducidas, pca1, y pca2, las pongo como componentes adicionales en el dataframe del dataset, le
digo cree un pca1, y que esa igual al elemnto 0 de los datos transformados y luego creo otra columna, y mando la segunda componente

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 34/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
iris['pca_1']=scaled[:,0]
iris['pca_2']=scaled[:,1]
iris

sepal_length sepal_width petal_length petal_width species pca_1 pca_2

0 5.1 3.5 1.4 0.2 setosa -0.900681 1.019004

1 4.9 3.0 1.4 0.2 setosa -1.143017 -0.131979

2 4.7 3.2 1.3 0.2 setosa -1.385353 0.328414

3 4.6 3.1 1.5 0.2 setosa -1.506521 0.098217

4 5.0 3.6 1.4 0.2 setosa -1.021849 1.249201

... ... ... ... ... ... ... ...

145 6.7 3.0 5.2 2.3 virginica 1.038005 -0.131979

146 6.3 2.5 5.0 1.9 virginica 0.553333 -1.282963

147 6.5 3.0 5.2 2.0 virginica 0.795669 -0.131979

148 6.2 3.4 5.4 2.3 virginica 0.432165 0.788808

149 5.9 3.0 5.1 1.8 virginica 0.068662 -0.131979

150
Pasos rows × 7 columns
siguientes: Generar código con iris toggle_off Ver gráficos recomendados New interactive sheet

usando los datos reducidos

iris['pca_1']=reduced_scaled[:,0]
iris['pca 2']=reduced scaled[: 1]
No se ha podido establecer conexión con el servicio reCAPTCHA. Comprueba tu conexión a Internet y vuelve a cargar la página para ver otro reCAPTCHA.

https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 35/35

También podría gustarte