Descriptiva Con Python.ipynb - Colab
Descriptiva Con Python.ipynb - Colab
ipynb - Colab
import pandas as pd
df=pd.read_csv('cars.csv')
df
df.dtypes
df.describe()
Distributions
2-d distributions
Values
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
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'>
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
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,
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
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>
<seaborn.axisgrid.FacetGrid at 0x7bdca52f4390>
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>
<seaborn.axisgrid.FacetGrid at 0x7bdca533bf90>
df.groupby('engine_type').count()
engine_type
electric 10 10 10 10 10 10 10 10
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??
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.
tener cuidado al escribir con los espacios, y los argumentos, porque tuve que corregir con asistente
Q7_df
... ... ... ... ... ... ... ... ... ...
79 rows × 30 columns
sns.histplot(Q7_df['price_usd'])
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
sns.histplot(Q7_df,x='price_usd', hue='year_produced')
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
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.
plt.show():
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.
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).
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.
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.
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')
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).
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.
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.
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.
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
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.
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: >
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)
irq=Q3-Q1
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
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'>
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.
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,
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()
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.
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.
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
vamos a usar al joinplot, para realizar el diagrama de dispersion junto al diagrama o histograma asociadao a cada varibble, para visualizar
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.
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
# 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.
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
Propósito: Crea gráficos de dispersión simples.
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
# 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.
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
Diferencias Clave:
Simplicidad: scatterplot es más simple y se centra solo en la relación entre dos variables.
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
https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 18/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
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:
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>
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
['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.
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.
. 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.
.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.
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)
https://colab.research.google.com/drive/1PHM3nLeFKJlPtjZTZgM4YvKfTXQpBFvd#scrollTo=o2gglfajZKt3 22/35
24/2/25, 12:34 p.m. descriptiva con python.ipynb - Colab
#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[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
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.
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().
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'])
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.
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()
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,
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.
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.
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
scaled.T
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
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'])
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
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>
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
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,
eigen_values
puedo ver como quedo la matriz, tenemos 4 valores porque la matriz tiene un tamaño de cuatro vectores
eigen_vectors
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
[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,
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
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
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
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
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
150
Pasos rows × 7 columns
siguientes: Generar código con iris toggle_off Ver gráficos recomendados New interactive sheet
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