No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Procesamiento de datos numéricos en Python

16/25
Recursos

Aportes 92

Preguntas 35

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

La transformación: raw = X[:, None, 2]

Esta transformación puede crear un poco de confusión si no conoces algunos detalles sobre NumPy. Para las dudas te detallo un poco que hizo en esta línea de código.


Note: X tiene un shape de (442, 10) para nuestro estudio solo necesitamos una columna, buscamos tener un raw con shape (442, 1)


  1. : toma todas las columnas y filas.
  2. None indica la transformación del arreglo (newaxis)
  3. 2 Selecciona la 3ra columna de X.

Más información sobre Numpy Newaxis


Debería explicar mejorar cada línea de código.

Para tener un contexto de qué son los datos con los que estamos trabajando.

Tenemos un set de datos de 442 pacientes de diabetes. Se tienen 10 columas con los datos de “age, sex, body mass index, average blood pressure, and six blood serum measurements”. Estos datos corresponde a las variable que llamamos “X”. La variable “y” corresponde a “a quantitative measure of disease progression one year after baseline”.

https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset

al ejecutar la linea

raw = X[:, None, 2]

estamos tomando solo la columna del índice de masa corporal.

Los datos del dataset ya vienen pre-escalados y centrados en la media.

Si graficamos los datos con un Scatterplot vemos que hay cierta relación entre el índice de masa corporal y la progresión de la enfermedad, por eso es que realizamos una regresión lineal, para predecir que tan avanzada está la enfermedad a partir del índice de masa corporal.

reto

para lograr la estandarización con z score encontré tres formas:
la primera aplicando la formula directamente a los datos

z_score=(raw -np.mean(raw))/np.std(raw)  #zcore aplicando la formula

la segunda usando la libreria de scipy

import scipy.stats as stats
zz_score=stats.zscore(raw)            #zscore usando scipy stats

la tercera usando preprocessing de sklearn, para este caso hay que primero asignar el modelo y después “entrenarlo”

from sklearn import preprocessing
z_sc=preprocessing.StandardScaler()
zzz_score=z_sc.fit_transform(raw)        #zscore usando sklearn preprocessing

con todos los casos obtuve el mismo resultado

los tiempos para cada caso

Para los que no entiendan porque X está definida con mayúscula e y con minúscula, es porque esta convención viene del álgebra, donde X es una matriz, y a las matrices se la denominan con mayúsculas, e y es un vector, y los vectores se lo denominan en minúsculas.

Leyendo la documentación del dataset que se usa para la clase encontré que el dataset ya ha sido escaldo previamente.
.

.
Por esta razón me empecé a preguntar si realmente los escalamientos realizados en la clase eran útiles sobre data que ha sido escalada previamente. Así que descargué el dataset original, el cual se pude encontrar aquí.
.
Para importar la información, pasé los datos a un archivo csv y lo importé en deepnote usando Pandas. En ese momento vi claramente la diferencia entre los datos del dataset que nos ofrece scikitLearn y el original. La variable del dataset que se usa en la clase es el índice de masa corporal (o BMI por sus siglas en inglés).

Aquí se puede ver claramente que los datos de SciKitLearn tienen un tratamiento previo.
.
Lo siguiente que hice fue volver a hacer el proceso de tratamiento de datos para los datos originales.
Aquí se puede ver cómo efectivamente los datos de un rango mayor es reducido y centrado en 0, tanto por el escalamiento min_max como por el z-score.
.
Posteriormente hice la comparación en el entrenamiento con estos nuevos datos y los resultados son evidentes:

.
Mi conclusión personal, es que hay que ser más críticos con los datos que estamos tratando y siempre verificar las fuentes y la documentación 😃

Me sigue pareciendo extraña la fórmula de escalamiento min-max. Según los libros de estadística y la misma función de Sklearn, la fórmula es (x-min(x))/(max(x)-min(x)).

genial la clase, tuve que verla 2 veces por que me sentia confundido pero ya pude entender el ejemplo!

Vengo yo al rescate:

Hay un poco de confusion respecto a que fue lo que se realizo con las siguientes dos lineas de codigo:

X, y = datasets.load_diabetes(return_X_y=True)
raw = X[:, None, 2]

Con la primera como ya han explicado, se uso una notacion del algebra en que se dispone que la X sea mayuscula y la y sea minuscula, esto por que se realizo de esta manera? solo por convencion. Que es una convencion? es un metodo de hacer las cosa que es aceptado por todos y que aunque puede no realizarse asi, aun se realiza de este modo para que todos podamos entender (en este caso el codigo hecho por los demas), un ejemplo de una convencion es no cruzar la calle cuando el semaforo esta en rojo. Tambien recuerden que en python igualmente asi se coloque una variable con mayuscula/as esta no se vuelve una constante como sucede en otros lenguajes, sino que igualmente por convencion se asume que es una constante, pero si se modifica su valor este cambiara sin problema alguno. Puede que de alli provenga la confusion de algunos al haberse usado esta notacion.
Puede tambien que al ver la “coma” luego de esta “X” mayuscula, y ver representada la variable “y” se confundan aun mas, pero en python puede realizarse la asignacion de variables de esta manera,

Si yo coloco:
a, b = 1, 2 ### 1,2 = (1, 2), es decir pasamos una tupla
print(f’Valor de a es {a} y Valor de b es {b}’)

Visualizaran que de salida arroja esto:
Valor de a es 1 y Valor de b es 2

Cuidadito con esas bases de python de algunos.

Ahora veamos que a la variable ‘X’ e ‘y’ se le asignaron valores de esta tabla que fue la que usamos:
https://www4.stat.ncsu.edu/~boos/var.select/diabetes.tab.txt

“X” toma el valor de lo que parece ser un array de arrays, esto por la notacion array ([[ con que comienza y el ]]) con que termina. Algunos diran, oye pero dentro de este array de array hay unos datos bien raros que son:
array([[ 0.06169621],
[-0.05147406],
[ 0.04445121]… etc … ]]])
Esto es porque alguien ya trato los datos de donde los estamos obteniendo y aplico los procesos que hemos venido haciendo, no mentire, esta tarde y no me acuerdo como se llama este proceso, pero si tengo la nocion de lo que se le aplico, si alguien se lo recuerda que diga en nombre en las respuestas. En fin, por esto es que esos datos no se parecen a los que tenemos en el dataset que yo les pase yque vuuelvo a pasarles: https://www4.stat.ncsu.edu/~boos/var.select/diabetes.tab.txt

“y” toma el valor de la columna 11 que es una medida cuantitativa de la progresión de la enfermedad un año después del inicio, para esto ejecuten la variable y comparen los datos con los presentes en esta tabla, porque sucede esto, creo que es porque esta columna es el indice de la tabla, porque creo esto, porque vean que el dataset no posee un indice con numeros, y un dataset siempre debe tener un indice a modo de referencia, igualmente al no estar tratados los valores de esta variable “y”, esto pueden verificarlo, esto me da a entender que la columna 11 es el indice, ya que el indice no debe tratarse con estos procesos.

luego la variable raw es usada para colocarle los valores ya tratados de la fila numero 2, que es la de BMI.

Todo lo demas fue comparar la relacion que tiene el indice de masa corporal y por ende el estado de forma con respecto a la progresión de la enfermedad un año después del inicio.

Para la parte matematica les dejo este tutorial:
https://www.statisticshowto.com/probability-and-statistics/z-score/

Con ese yo termine de entender lo que aplicamos al z-score, aunque el spoiler es que las variables:
scaled se calculo usando escalamiento por el metodo del max-min

z_scaled se calculo usando normalización por el metodo del Z-score

pero en teoria estas dos variables son la misma a efectos practicos, solo que se grafico cada una por separado para evaluar cual metodo se habia adaptado mejor a este caso en particular.

Escalamiento Z-Score

#Reglas de escalamiento

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

mu = np.mean(raw)
sigma = np.std(raw)

scaled_z = (raw - mu) / sigma

fig, axs = plt.subplots(3, 1, sharex=True)
axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(scaled_z)
#Modelos de entrenamiento
def train_raw():
    linear_model.LinearRegression().fit(raw, y)

def train_scaled():
    linear_model.LinearRegression().fit(scaled, y)

def train_scaled_z():
    linear_model.LinearRegression().fit(scaled_z, y)


raw_time = timeit.timeit(train_raw, number=100)
scaled_time = timeit.timeit(train_scaled, number=100)
scaled_z_time = timeit.timeit(train_scaled_z, number=100)
print('Trained Raw: {}'.format(raw_time))
print('Trained Scaled: {}'.format(scaled_time))
print('Trained Scaled_z: {}'.format(scaled_z_time))

Este curso en general, ha sido bien confuso (por lo menos para mi), siento que se podría explicar de una manera mas detallada cada proceso y así no quedamos con tantas dudas, para todas las clases he tenido que buscar clases de otros profesores en internet para poder comprender lo que se dice acá.

El profe creo que explica esta visualización de esta manera (rápida) porque este no es un curso de visualizaicón sino de matemáticas. No te preocupes por la forma, lo importante es el fondo, eso si ve complementando de forma inmediata con los cursos de python y las librerías pandas y numpy respectivamente y al final nadie se sabe todos los métodos, lo importante es tener claro que se quiere hacer y para todo lo demás amigos mios existe Google.

Debería explicar cada linea de código, no logro seguir la clase.

Para ser un curso básico me parece que dejan muchas dudas. No se entiende la mayoría de las cosas, al menos en esta clase.

Hola, leyendo un poco la doc logre normalizar la data usando la transformación “box-cox”

Claramente se necesitan más términos, conocimientos y práctica para entender el código visto. Aquí tienen un área de oportunidad el platzi team. Igual que a muchos, no lo entendí del todo, los tiempos (a veces) me salen muchos más rápidos en el raw y el reto para el z scaling no me sale dentro de un rango de -1 a 1.

a esta clase le falta explicar el dataset por que no se entiende de que es y que variables está analizando

HIba excelente hasta que llegue a esta clase que se puso a escribir codigo a diestra y siniestra que en mi vida habia visto (y que no estan las clases de python basico, intermedio ni avanzado). Deben haces esatas cosas pensando que no somos programadores!, tambien dice mucho que no puede explicar porque no alcanza en la clase, lo cual es ridiculo, debe explicar todo, para eso estamos pagando, da igual si estamos un año en el curso mientras aprendamos. Intento entender los link que ponen, pero los siento en chino, no se comprende, y justamente por eso estamos tomando clases, para que nos ayuden a entender, no para que nos manden a leer lo que podriamos leer sin pagar el curso.

De esta clase literalmente no entendi nada. Me toco con Chat GPT para entender lo que hace.

Mi primera pregunta era sobre el porqué usó :

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

en vez de utilizar df = pd.read_csv(“file”) .

Y es que la primera se utiliza para importar el database como un Bunch object, el cual contiene los features y los targets como dos atributos separados.

De aqui viene otra pregunta, que carajo es un Bunch. Un Bunch es escencialemente un dictionary pero que permite accesar sus datos por la key. Esto lo hace ser de uso en machine learning ya que lo hace ser una herramienta para pasar de un dataset a otro de una manera sencilla.

Ahora, con este concepto es mas sencillo entender el uso de X,y. X son los features y Y es el target, en la misma documentaciòn se habla de Y que es la coñlumna 11.

Target:
Column 11 is a quantitative measure of disease progression one year after baseline

https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset

Espero que les haya sido de ayuda para entender el porque se usa eso, respecto a la siguiente linea :

raw=X[:,None,2]

Raw es la variable, X se refiere a los features como se menciona anteriormente, de esos features tomará todas las columnas y filas pero sólo selecccionará la fila que está en el indice 2, que para los curiosos es la columna de BMI,

Lo unico que aun no cuadra seria el uso del None, pero este none tal como se explica mas abajo se utiliza para que la variable Raw tenga el mismo numero de dimensiones que X. X es una matriz 2x2 de tamaño ( 442,10)y Raw sin el uso del none seria solamente una matriz de 1x1 (442) pero no se podrian hacer los calculos que se necesitan.

https://ichi.pro/es/pruebas-de-normalidad-en-python-230280637680359
Acá pueden ver algunas pruebas de normalidad que entregan un coeficiente que nos permite definir si una distribución si se puede considerar como normal.

A nadie le pareción interesante que el valor mínimo de los precios de carros usados es USD$1.00? Jajaj que ofertón

Nuestro conjunto de datos tiene forma de una distribucion Lognormal, teniendo de referencia la documentacion para mapear datos, y viendo los tipos de resultados, haremos la prueba de escalar los datos con el metodo Box-Cox y Yeo Johnson para conseguir una distribucion gaussiana

from sklearn.preprocessing import PowerTransformer
from sklearn.model_selection import train_test_split

price = df.price_usd

bc = PowerTransformer(method='box-cox')
yj = PowerTransformer(method='yeo-johnson')
tanh = price.apply(lambda x: np.tanh(x/10000))


def map_data(method):
    x = price.to_numpy()
    x = np.reshape(x,(len(x),1))
    x_train, x_test = train_test_split(x,test_size=0.5)

    x_trans = method.fit(x_train).transform(x_test)
    return x_trans



fig, axs = plt.subplots(nrows=1,ncols=5, figsize=(20,6))

axs[0].hist(price,bins=50)
axs[0].set_title('Raw price usd')

axs[1].hist(map_data(bc),bins=50, color='green')
axs[1].set_title('Method Box-Cox')

axs[2].hist(map_data(yj),bins=50, color='pink')
axs[2].set_title('Method Yeo-johnson')

axs[3].hist(map_data(bc),bins=50, color='green')
axs[3].hist(map_data(yj),bins=50, color='pink')
axs[3].set_title('Comparasion Box-Cox and Yeo-Johnson')

axs[4].hist(tanh,bins=50);
axs[4].set_title('Method TanH');

Alguien me podría explicar esta parte del código, que representa y? Por favor 😖

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

Hay que aclarar que el codigo visto en esta clase y lo que se hablo de el, es solo introductorio, lo importante es copiarlo y entender el resto de conceptos que se hablaron (Escalamiento, Transformaciones y Eficiencia), ya que en futuro cursos se veran a detalle y explicado con mayor claridad el codigo que se mostró.

normalización z_score
[]

modelo de entrenamiento
[]

sklearn preprocessing
[]

#Normalizacion Z

scaled_z = (raw - raw.mean()) / raw.std()

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

Una pregunta que me tiene pensando:

¿Si la media es igual a la mediana y a la moda, podría decir que la distribución es normal?

Reto


# normalización Z-score

avg = np.average(raw)
std = np.std(raw)
z_scaled = (raw - avg)/std

fig, axs = plt.subplots(3, 1, sharex=True, tight_layout=True)

axs[2].hist(z_scaled)

def train_z_scaled():
    linear_model.LinearRegression().fit(z_scaled, y)

z_scaled_time = timeit.timeit(train_raw, number = 100)

print('trainning time for z_scaled data : {}'.format(z_scaled_time))



oye oye despacio cerebrito

En esta clase se ve un poco la confusión del comando

raw = X[:, None, 2]

otra forma de verse, aunque un poco mas larga es que de esta matriz de forma (442, 10) solo quiero los datos de la columna dos y convertirlos en un vector columna de dimensión (442,1), podría usar este comando que es mas largo, pero un poco mas claro para interpretar:

leo el dataset

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

selecciono los datos de todas las filas, en la columna 2
y se convierten en un vector de dimension 2 (1,442)

raw = np.array(x[:,2], ndmin=2)

como es vector fila, hago la traspuesta para un vector
columna

raw = raw.T

igual, el principio de Python es realizar programación con la menor cantidad de código, pero a veces hay que hacer el ejercicio un poco largo para entender los trucos de este lenguaje y que siempre hay una manera practica de hacer las cosas.

X, y = datasets.load_diabetes(return_X_y=True), segun chat GPT:
El código que has proporcionado carga el conjunto de datos de diabetes disponible en scikit-learn, una biblioteca de aprendizaje automático en Python. La función load_diabetes carga el conjunto de datos y devuelve dos matrices NumPy, X e y.

X contiene las características (o variables independientes) que se utilizarán para predecir la variable de salida (o variable dependiente), y, que representa la progresión de la enfermedad un año después del diagnóstico en un conjunto de pacientes.

El argumento return_X_y=True le indica a la función que devuelva tanto X como y en lugar de devolver un solo objeto que contenga ambos conjuntos de datos.

En resumen, el código carga el conjunto de datos de diabetes en dos matrices NumPy, X e y, que luego se pueden utilizar para entrenar un modelo de aprendizaje automático para predecir la progresión de la enfermedad en pacientes con diabetes.

Explicación de las primeras lineas:

X_y = datasets.load_diabetes(return_X_y=True)

Esta línea carga el conjunto de datos “diabetes” de la biblioteca “scikit-learn” y separa los datos en dos objetos diferentes, “X” y “y”, al igual que mencioné anteriormente.

“X” es una matriz que contiene las características de cada paciente, como la edad, el índice de masa corporal, la presión arterial, etc. Cada fila de la matriz representa un paciente, y cada columna representa una característica diferente.

“y” es un vector que contiene la medida de progresión de la diabetes para cada paciente. Cada elemento del vector corresponde a un paciente diferente.

En resumen, la primera línea de código carga el conjunto de datos “diabetes” y almacena las características de cada paciente en la matriz “X” y las medidas de progresión de la diabetes en el vector “y”.

Linea 2:
raw=X[:,None,2]

Aquí, estamos seleccionando una sola columna de la matriz “X” que acabamos de cargar en la línea anterior. Específicamente, estamos seleccionando la tercera columna de “X”, que corresponde a la tercera característica de cada paciente en el conjunto de datos “diabetes”.

La sintaxis “[:, None, 2]” es una forma de seleccionar una columna específica de una matriz. El primer símbolo “:” significa que queremos seleccionar todas las filas de la matriz “X”. El segundo símbolo “None” significa que queremos agregar una nueva dimensión a la matriz, en este caso, una dimensión adicional que corresponde a una sola columna. Finalmente, “2” significa que queremos seleccionar la tercera columna de la matriz “X”.

Después de seleccionar la tercera columna de “X” de esta manera, la almacenamos en una nueva variable llamada “raw”. “raw” ahora contiene una matriz de una sola columna que representa la tercera característica de cada paciente en el conjunto de datos “diabetes”.

Ojo porque en el notebook en timeit.timeit no el train\_raw no está modificado a train\_scaled ni a train\_z\_score en las sucesivas líneas. Entonces para correrlo hay que corregir esa parte.

Escalamiento Z-Score:

  • Aplicar la formula
std_raw = np.std(raw)
mean_raw = np.mean(raw)
# Regla de escalamiento
scaled_z_score = (raw - mean_raw) / std_raw
  • Graficar los datos crudos y escalados:
fig, axs = plt.subplots(1, 2, sharex=True)
axs[0].hist(raw)
axs[1].hist(scaled_z_score);
  • Modelo de entrenamiento:
def train_z_score():
  linear_model.LinearRegression().fit(scaled_z_score, y)
  • Calcular los tiempos de ejeción de los modelos:
z_score_time = timeit.timeit(train_z_score, number=100)
print("trainning time for raw data: {}".format(raw_time))
print("trainning time for scaled data: {}".format(scaled_time))
print("trainning time for z-score data: {}".format(z_score_time))

trainning time for raw data: 0.31426309799996943
trainning time for scaled data: 0.1602864320000208
trainning time for z-score data: 0.2240328140001111

# normalizacion Z
z_scaled = (raw - raw.mean())/raw.std()

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

Información resumida de esta clase
#EstudiantesDePlatzi

  • Con la librería timeit podemos medir los tiempos de ejecución que tienen nuestros modelos

  • La librería sklearn nos permite descargar data sets y hacer regresiones lineales sencillas

  • En Python es muy fácil ver estas funciones y aplicarlas

  • Cuando hacemos una regla de escalamiento es importante entender y ver como quedo la distribución de los datos

  • Aprender a utilizar la librería de Matplotlib es bien importante

  • Para evidenciar que tan rápido funcionan nuestros modelos, debemos pedir que esta función se ejecute 100 veces

  • Es buena idea buscar reducir los tiempos de ejecución de nuestros modelos

  • Utilizamos Mx - Mix cuando tenemos datos uniformemente distribuidos

  • Utiliamos Z-Score cuando tenemos datos distribuidos en forma de campana

  • La función apply de pantas toma todos los elementos de cierta columna y les aplica una función para transformarlos

  • Tener claro que con la gráfica del histograma podemos ver como va quedando nuestra distribución

Nota

  • Generalmente aplicamos el escalamiento max-min a datos uniformemente distribuidos y Z-score a datos normalmente distribuidos

Encontré este video cortito y útil para comprender mejor este tema:

https://youtu.be/ro2UjY8dLWw

Holaaaa chicos! para cualquier que no comprenda al 100% varios ejemplos o términos, les dejo está pagina que me ayuda un montón a concluir con la interpretación de las visualizaciones, y todo lo que el profe estuvo explicando. Hay casos donde me re costo entender conceptos, y como está clase, asique para eso busco refuerzooss! en fin este es el link

https://support.minitab.com/es-mx/minitab/19/

Uno mas que se perdio al llegar a esta clase!

es importante leer la informacion y los parametros del dataset, tendran todas las soluciones ahi

escale x usando

from sklearn import preprocessing
scaler = preprocessing.StandardScaler().fit(raw)
X_scaled = scaler.transform(raw)

Reto de Z Score:

mean = np.mean(raw)
std = np.std(raw)

z_scaled = (raw-mean)/(std)

fig, axs = plt.subplots(3,1, sharex = True)


axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(z_scaled)

raw_time = timeit.timeit(train_raw,number= 100)
scaled_time = timeit.timeit(train_scaled,number= 100)
z_scaled_time = timeit.timeit(train_z_scaled,number= 100)



Asi es como relice el reto de esta clase.

# mean
mean_z = raw.mean()
# std
std_z = raw.std()
# z-score
z_score = (raw - mean_z)/std_z

fig, axs = plt.subplots(2, 1, sharex=True)

axs[0].hist(raw)
axs[1].hist(z_score)
Acá si se dificultó mucho la cosa
Una aclaración es que se está aplicando un escalamiento lineal antes de aplicar la función tanh() usar el número o es igual a dividir toda la data antes de pasarlo por la función. El 10 000 no es un número al azar, el profesor intuye que es buen número porque el precio de los carros llega hasta 50k así que al dividir por 10 000 los número quedan en un rango mas cercano al cero que es cuando tanh() si hace efecto. Para numero muy grandes el resultado será 1 que es lo que pasó en el primer intento. Espero que se entienda, es complicado articular ese detalle
**¿Sabías que con solo unas líneas de código en Python puedes analizar grandes volúmenes de datos numéricos en segundos? 🚀** Con la librería **Pandas**, puedes organizar y manipular datos de manera súper eficiente. Por ejemplo, en un *DataFrame*, puedes calcular la media, mediana y desviación estándar de tus datos con simples comandos. ¡Ideal para empezar con la estadística descriptiva! 📊✨ **Tip:** Usa gráficos como histogramas y boxplots para visualizar rápidamente la distribución de tus datos. ¡La visualización es clave para detectar patrones y outliers!
``` import numpy as np x = np.random.randint(1,100, (420,10)) print(x) print(x\[:,None,2]) print(x\[:]) #Sin None imprime un arreglo de 1 dimensión ``` Sin no usaramos el None = np.extradim, resultaria en un arreglo de una dimesión con todos lo valores de la 3 columna, en una sola fila, en cambio con el None agregados, nos entrega el mismo arreglo pero en formato de columna.
* ![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202024-07-17%20a%20la%28s%29%201.11.05a.m.-cb32ada6-e76b-4d55-b2c0-14484868db2b.jpg)
Si que estaba algo extensa la clase, porque algunas cosas no las entendia del todo. A pesar de haber estudiado algunas cosas antes. Estaría genial que explique un poco más en detalle algunas cosas de codigo porque encajaría mejor la teoria con la practica. Y con ello disminuir el tiempo invertido en buscar o despejar dudas. No es un comentario de queja, me agrada estudiar y pongo de mi parte para hacerlo. Entonces aqui va lo que obtuve de la clase: Aplicando Z-Score ![](https://static.platzi.com/media/user_upload/image-0b2d71d2-d820-43ff-9d5e-f0c6d7c5ce05.jpg) También obtuve una comparacion de tiempos en las normalizaciones ![](https://static.platzi.com/media/user_upload/image-ad411da8-f9ba-4a37-a7e4-67aa1f354b06.jpg) Al igual que otras personas, me surgió la duda de como se obtuvo la ecuación de Max-Min, así que la obtuve sustituyendo los parametros en: ![](https://static.platzi.com/media/user_upload/image-c62b6d10-b00a-4ec5-a804-007a686235ab.jpg) Si te interesa ver en profundidad puedes checarlo en mi notebook: <https://github.com/DensLopez/Estadistica_descriptiva/blob/main/codes/code015.ipynb>
lo hice con la formula normal ![](https://static.platzi.com/media/user_upload/image-33062e66-c628-4c21-9077-b280792de72a.jpg) lo que no entiendo es por que mis tiempos son mayores que el raw ![](https://static.platzi.com/media/user_upload/image-463fc5cf-922d-450e-8d4b-135e8719293c.jpg)
Tenía una duda sobre, si estaba alterando de alguna manera la estructura y distribución de los datos en el modelo, ¿para qué me sirve si yo lo que quiero es aplicar el modelo a datos reales no transformados? La respuesta creo que es muy sencilla pero es útil tenerla a la mano A cada dato nuevo que te llegue, antes de pasárselo al modelo, vas a aplicarle la misma transformación. Esto puede ser un cuello de botella si la transformación que usamos es muy compleja matemáticamente, pero precisamente por eso vemos que se usan fórmulas matemáticas sencillas para ello. Les dejo una explicación más directa de lo que acabo de decir por si quieren copiarlo en su libreta de apuntes: Cuando entrenas un modelo con datos que han sido transformados mediante una función específica, como la tangente hiperbólica dividida por ( P ), es crucial que apliques la misma transformación a los nuevos datos antes de hacer predicciones con el modelo. Esto asegura que los nuevos datos tengan la misma escala y distribución que los datos con los que se entrenó el modelo, permitiendo que las predicciones sean precisas y consistentes.
Hola! Para quienes estén utilizando Visual Studio Code. Recueren que es necesario instalar la biblioteca sklearn por medio de Power Shell en su PC por medio del comando **pip install -U scikit-learn** Una vez hecho esto podrán seguir la clase sin problema: ![](https://static.platzi.com/media/user_upload/image-84c52816-332c-4ad2-807d-38e24fcf8eb4.jpg) ![](https://static.platzi.com/media/user_upload/image-bac9221e-0a96-4f92-b502-6b749d655fb6.jpg)
Según mis datos: ![](https://static.platzi.com/media/user_upload/image-673d7040-6de9-473c-8534-efd116d3fcf2.jpg)Raw : 0.8467703940004867 min-max: 0.7754223440024361 Reducción: 8.425902759893788 % Z-score: 0.8046826839999994 Reducción: 4.970380435911068 % ```js Raw : 0.8467703940004867 min-max: 0.7754223440024361 Reducción: 8.425902759893788 % Z-score: 0.8046826839999994 Reducción: 4.970380435911068 % ```

Me gusto el desarrollo de estos elementos usando el scikit learn y como estos nos pueden beneficiar en su uso. Las transformaciones lineales y no lineales nos ayudan mucho a su uso.

Dice que el max-min son para los datos uniforme y el z-score para los distribuidos normalmente. Alguien me explica cual es la diferencia entre ambos? Habia entendido que eran terminos similares. Mucha gracias
Yo creo que media hora mas de curso, alargando alguna clases como esta para afinar mejor las explicaciones no vendrian mal y seria muy agradecido. Si fuese por mi les pediria que alargasen este curso 2 horas mas incluso, por la verdad es que esta buenisimo es increible y es conocimiento sumamente entretenido e increible. La verdad muy buen curso, pero se queda corto con el tiempo y se salta en explicar algunas cosas.

intente agregar la linea
fig, axs = plt.subplots(2, 1, sharex = True)
axs[0].hist(raw)
axs[1].hist(scaled)

NO ME FUNCIONO, encontre en la libreria de matplotlib

que ya no se utiliza “plt.subplots” si no “matplotlib.pyplot.subplots”

RESULTADO:
fig, axs = plt.pyplot.subplots(2, 1, sharex = True)
axs[0].hist(raw)
axs[1].hist(scaled)

Amigos, entontré un video muy bueno por si quieren entender desde otras palabras lo que es el escalamiento de z-score 😃

Comparación entre los 3 diferentes escalamientos lineales

Entiendo que existe una correlación en el avance de las clases. Pero la confusión que me está agarrando respecto a la normalización, estandarización y escalamiento es absoluta.

Si algún platzinauta/plaztistaff quisiera sugerirme cómo abordar este tema un poco menos rebuscada sería mi deseo. Muchas gracias!

Seria bueno que explique sobre sklearn antes de continuar.

En vez de utilizar

timeit.timeit(train_raw, number = 100)

Pueden utilizar el magic command de ipython

%timeit -n100 train_raw()

cuando uno entrena el modelo por mas tiempo se vaa acrecentando la diferencia, yo creo que cuando llegue al minuto ya se habrá ahorrado un segundo

Buena clase.

Normalización Z

RETO

# timeit: para medir el tiempo de ejecución de los modelos o performance de los modelos
import timeit 

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#datasets para descargar un modelo y linear_model para hacer una regresión lineal
from sklearn import datasets, linear_model 

X, y = datasets.load_diabetes(return_X_y=True) #carga el dataset

print(f'El shape de X es: {X.shape}', )
print(f'El shape de y es: {y.shape}')

#transformación en las dimensiones para que se ajuste al formato de entrada del preprocesamiento
# La columna con indice 2 corresponde a body mass index (índice de masa corporal)
raw_data = X[:, None, 2] 

print(f'El shape de raw es: {raw_data.shape} ')
print('Se hizo un transformación de 10 columnas a 1 columa')

Salida:
El shape de X es: (442, 10)
El shape de y es: (442,)
El shape de raw es: (442, 1)
Se hizo un transformación de 10 columnas a 1 columa

#

df_scaled_data = pd.DataFrame(raw_data)
scaled_data = df_scaled_data.apply(lambda x: (x - raw_data.mean())/raw_data.std())

import scipy.stats as stats
scaled_data_scipy_z_score = stats.zscore(raw_data)

from sklearn import preprocessing
scaler = preprocessing.StandardScaler()
scaled_data_sklearn_z_score = scaler.fit_transform(raw_data)
# 

fig, axs = plt.subplots(4, 1, sharex=True)
axs[0].hist(raw_data)
axs[1].hist(scaled_data)
axs[2].hist(scaled_data_scipy_z_score)
axs[3].hist(scaled_data_sklearn_z_score)
# modelos para entrenamiento
def train_raw_data():
    linear_model.LinearRegression().fit(raw_data, y)

def train_scaled_data_0():
    linear_model.LinearRegression().fit(scaled_data, y)

def train_scaled_data_1():
    linear_model.LinearRegression().fit(scaled_data_scipy_z_score, y)

def train_scaled_data_2():
    linear_model.LinearRegression().fit(scaled_data_sklearn_z_score, y)
#repite la ejecución del código 100 veces y sobre eso calcula el tiempo
raw_time = timeit.timeit(train_raw_data, number=100)
scaled_time_0 = timeit.timeit(train_scaled_data_0, number=100)
scaled_time_1 = timeit.timeit(train_scaled_data_1, number=100)
scaled_time_2 = timeit.timeit(train_scaled_data_2, number=100)

print(f'train raw: {raw_time}')
print(f'train scaled: {scaled_time_0}')
print(f'train scaled: {scaled_time_1}')
print(f'train scaled: {scaled_time_2}')

scaled_time_list = [scaled_time_0, scaled_time_1, scaled_time_2]

for i in scaled_time_list:
    time_diff = (raw_time - i) * 1000
    round(time_diff, 2)
    print(f'time difference is: {time_diff} ms.')

Salida:
train raw: 0.06021869699998206
train scaled: 0.19325598500017804
train scaled: 0.05951958300011029
train scaled: 0.0624253129999488
time difference is: -133.03728800019599 ms.
time difference is: 0.6991139998717699 ms.
time difference is: -2.2066159999667434 ms.

Los que tienen dudas, pueden buscar información en este libro

https://link.springer.com/book/10.1007/978-0-387-84858-7

Lo pueden descargar gratis

# modelos para entrenamiento
def train_raw():
    linear_model.LinearRegression().fit(raw, y)

def train_scaled():
    linear_model.LinearRegression().fit(scaled, y)

def train_z_scaled():
    linear_model.LinearRegression().fit(z_scaled, y)
raw_time = timeit.timeit(train_raw, number = 100)
scaled_time = timeit.timeit(train_raw, number = 100)
z_scaled_time = timeit.timeit(train_raw, number = 100)
print('trainning time for raw data : {} '.format(raw_time))
print('trainning time for scaled data : {}'.format(scaled_time))
print('trainning time for z_scaled data : {}'.format(z_scaled_time))
trainning time for raw data : 0.035223129999849334 
trainning time for scaled data : 0.03181928100002551
trainning time for z_scaled data : 0.03271591400016405

El reto:

#Normalizacion z-score
desv = raw.std()
mean = raw.mean()
scaled_2 = (raw-mean)/desv

fig, axs = plt.subplots(3,1, sharex=True)
axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(scaled_2)
plt.show()  
def train_raw():
    linear_model.LinearRegression().fit(raw, y)

def train_scaled():
    linear_model.LinearRegression().fit(scaled, y)

def train_scaled_2():
    linear_model.LinearRegression().fit(scaled_2, y)

raw_time = timeit.timeit(train_raw, number=100)
scaled_time = timeit.timeit(train_scaled, number=100)
scaled_time_2 = timeit.timeit(train_scaled_2, number=100)
print(f'Train raw: {raw_time}')
print(f'Train scaled: {scaled_time}')
print(f'Train scaled Z: {scaled_time_2}')

Train raw: 0.04859847300031106
Train scaled: 0.03262850499959313
Train scaled Z: 0.02613312900029996

Para entender la asignación:

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

Cuando es True asigna a ‘X’ un ndarray en este caso de 442 x 10
y a ‘y’ las filas en este caso las 442

(data, target)tuple if return_X_y is True
Returns a tuple of two ndarray of shape (n_samples, n_features) A 2D array with each row representing one sample and each column representing the features and/or target of a given sample.

Muy útil la información adquirida en esta clase 🥇

Este curso cada vez se pone mejor 😎🚀

Aplicando box-cox de https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.power_transform.html

a = np.zeros(shape=(1,38531))
a[0]=df['price_usd']
plt.hist(np.transpose(a), bins = 10)
plt.show()
from sklearn.preprocessing import power_transform
plt.hist(power_transform(np.transpose(a), method='box-cox'), bins = 10)
plt.show()

Creo que si no te vas a dedicar a machine learning y estas en la escuela de Analista de Datos esta clase sobra.

Hola, mencionar que el proceso de transformación se aprecia mejor si no se aplica el sharedx para el gráfico que mencionan.

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

De esta manera podrán ver que el gráfico solía moverse de -0.10 hasta un poco arriba de 0.15, mientras que los datos escalados efectivamente oscilan entre -1 y 1.

Cabe mencionar que el sesgo se mantiene ya que el punto de este ejercicio es hacer el escalamiento, no realizar una corrección en el comportamiento de los datos.

Dejo mi reto completado

Gracias, buen contenido

En mi ejecucion dieron tiempos proporcionalmente distintos:
trainning time for raw data : 0.18143760000003795
trainning time for scaled data : 0.05085100000002285
trainning time for z_scaled data : 0.059124199999985194

Mi aporte:

MaxMin se utiliza para datos que se distribuyen de manera similar a la normal (Gaussiana).
Z-score se utiliza cuando tenemos datos distribuidos normalmente.
Supongo que si no estamos seguros si es o no gaussiana, podemos aplicar una prueba de normalidad.

Transformaciones no lineales.

Un poco más de información del dataset usado en la documentación de Sklearn: https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html

Reto: Encontrando el Z score

# Z score
mean_raw = np.mean(raw)
std_raw = np.std(raw)

score_raw = (raw - mean_raw) / (std_raw)

fig, axs = plt.subplots(2, 1, sharex= True)

axs[0].hist(raw)
axs[1].hist(score_raw)

Siguiendo el código ya sea usando la librearía de numpy o las funciones mean() y std()

#avg_raw = raw.mean()
#std_raw = raw.std()
avg_raw = np.average(raw)
std_raw = np.std(raw)

scaled_z = (raw - avg_raw) / std_raw
fig, axs = plt.subplots(3, 1, sharex=True)
axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(scaled_z)

He obtenido casi siempre en cada prueba un resultado más rápido en scaled min-max que en z-score

X, y = datasets.load_diabetes(return_X_y=True) 
raw= X[:, None, 2]

scaled = (2*raw - max_raw - min_raw)/(max_raw - min_raw)
z_score = (raw - np.mean(raw))/np.std(raw)

fig, axs = plt.subplots(3, 1, sharex=True) #2 gráficos y permitir que compartan el eje X.
axs[0].hist(raw)
axs[1].hist(scaled)
axs[2].hist(z_score)


Train raw: 0.07569159300328465
Train scaled: 0.06584178400225937
Train scaled: 0.05747606500517577

Muy buen articulo para comprender el z-score: https://www.statisticshowto.com/probability-and-statistics/z-score/

Adjunto una liga con un deepnote con los 3 métodos de normalización, lo aplico al mismo dataset que vimos en clase:

https://deepnote.com/project/Estadistica-Descriptiva-1mRhwIyiR7mxbfpPcZ2_vA/%2Fnormalization_3_methods.ipynb