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 77

Preguntas 35

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渁ge, sex, body mass index, average blood pressure, and six blood serum measurements鈥. Estos datos corresponde a las variable que llamamos 鈥淴鈥. La variable 鈥測鈥 corresponde 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 鈥渆ntrenarlo鈥

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!

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

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 鈥渃oma鈥 luego de esta 鈥淴鈥 mayuscula, y ver representada la variable 鈥測鈥 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鈥橵alor 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 鈥榅鈥 e 鈥榶鈥 se le asignaron valores de esta tabla que fue la que usamos:
https://www4.stat.ncsu.edu/~boos/var.select/diabetes.tab.txt

鈥淴鈥 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

鈥測鈥 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 鈥測鈥, 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.

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.

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.

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 鈥渂ox-cox鈥

Alguien me podr铆a explicar esta parte del c贸digo, que representa y? Por favor 馃槚

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

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

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



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)

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(鈥渇ile鈥) .

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.

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)

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.

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)

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贸.

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 鈥減lt.subplots鈥 si no 鈥渕atplotlib.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!

Explicaci贸n de las primeras lineas:

X_y = datasets.load_diabetes(return_X_y=True)

Esta l铆nea carga el conjunto de datos 鈥渄iabetes鈥 de la biblioteca 鈥渟cikit-learn鈥 y separa los datos en dos objetos diferentes, 鈥淴鈥 y 鈥測鈥, al igual que mencion茅 anteriormente.

鈥淴鈥 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.

鈥測鈥 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 鈥渄iabetes鈥 y almacena las caracter铆sticas de cada paciente en la matriz 鈥淴鈥 y las medidas de progresi贸n de la diabetes en el vector 鈥測鈥.

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

Aqu铆, estamos seleccionando una sola columna de la matriz 鈥淴鈥 que acabamos de cargar en la l铆nea anterior. Espec铆ficamente, estamos seleccionando la tercera columna de 鈥淴鈥, que corresponde a la tercera caracter铆stica de cada paciente en el conjunto de datos 鈥渄iabetes鈥.

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 鈥淴鈥. El segundo s铆mbolo 鈥淣one鈥 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 鈥淴鈥.

Despu茅s de seleccionar la tercera columna de 鈥淴鈥 de esta manera, la almacenamos en una nueva variable llamada 鈥渞aw鈥. 鈥渞aw鈥 ahora contiene una matriz de una sola columna que representa la tercera caracter铆stica de cada paciente en el conjunto de datos 鈥渄iabetes鈥.

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.

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

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.

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 鈥榅鈥 un ndarray en este caso de 442 x 10
y a 鈥榶鈥 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 馃槑馃殌

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

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