Entrenamiento del modelo
Contenido del curso
Cómo funciona la regresión lineal
Regresión lineal multivariable
Proyecto práctico
Pasos siguientes
Entrenamiento del modelo
Entrenamiento del modelo
Contenido del curso
Alex Junior Rodriguez Huerta
Diego González Castellanos
Joaquin Romero Flores
Blas Ferreira
George Wang Lee Zevallos Durand
Andres Gutiérrez Castillo
Miguel Angel Herrera Chavez
Jeinfferson Bernal G
Dick Saide Suárez Blanco
Maximiliano Cuesta
Anuar Steven Garcia
jader lopez
Yonatan Efraín Jara Boza
Yonatan Efraín Jara Boza
Cristian Enrique Cuevas Mercado
Santiago Ahumada Lozano
FELIX DAVID CORDOVA GARCIA
Tomas Dale
Natalia Bermudez Calderon
Sebastián José Herrera Monterrosa
Joel Orellana
Gerardo Mayel Fernández Alamilla
Julian Cardenas Peñuela
Richard Eduardo Sailema Medina
Mario Alexander Vargas Celis
GUSTAVO CHIAPPE
Gian HM
Santiago Ahumada Lozano
Santiago Ahumada Lozano
Gerardo Mayel Fernández Alamilla
David Carrillo Castillo
Dario vallejo
Daniel Andres Rojas Paredes
JIMI MARCOS ALTAMIRANO HUAMANI
Luis Fernando Laris Pardo
Este capítulo me dejó unas dudas que resolví investigando un poco.
Yo lo hice de esta manera, es otra opción:
from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split X = data.drop(columns = ['charges']) y = data[['charges']] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25) sc_x = StandardScaler() X_train = sc_x.fit_transform(X_train) X_test = sc_x.transform(x_test) sc_y = StandardScaler() y_train = sc_y.fit_transform(y_train) y_test = sc_y.transform(y_test) model = LinearRegression() model.fit(X_train, y_train) y_pred = model.predict(X_test)
Tenia la duda de la distribución, gracias.
Gracias!
Para mi que se equivocó! La esencia de dividir en train y test es simular cómo se comporta mi modelo bajo datos nunca vistos, por lo que cuando crea los objetos scaler sc_x y sc_y los tiene que entrenar con los datos de train ( X_train e y_train ) solamente. Si creo el scaler con todos los datos que tengo se estaría filtrando información de train hacia test. Estaria haciendo “Trampa” porque en teoría los datos de test nunca los vio el modelo. Me explico?
Creo que lo que mencionas se evita porque justo antes de crear sc_x y sc_y usa train_test_split. Alguien que conozca más del tema y aclare esto.
@Blas Ferreira estas confundiendo el objeto de transformacion (StandardScaler) con el estimador (LinearRegression), si bien ambos son modelos que usan la funcion fit y predict, el primero solo transforma los datos, normalizandolos por ejemplo en un rango de [-1,1], esto preprocesa la data para que el modelo predictivo funcione mejor. Por otro lado el estimador es el modelo predictivo es aquel que realizara las inferencias (vaya, el modelo de ML) este es el modelo que requerira hacer testing y evaluaciones por lo cual este si requiere hacer holdout (split_data ). si haces el split antes del StandardScaler lo unico que conseguiras es crear 2 grupos de datos normalizados usando otra diferente distribucion, en palabras sencillas el paso de evaluacion estara incorrecto ya que las escalas de normalizacion tendran diferentes distribuciones, osea no servira de nada tu testing.
Solo una pequeña corrección. Se menciona a la variable y=charges como variable predictora.
Según la teoría estadística: Las variables predictoras son las variables independientes, en este caso las X's. La variable objetivo es la dependiente en este caso y=charges.
Es correcto. Asi tambien lo entiendo yo!
----->Entrenamiento del modelo<---- σ El objetivo es saber como entrenar un modelo de regresion lineal dentro de machine learning. 1.Crear el modelo. Parecido a lo hecho en el primer ejecicio, lo primero es importar la informacion. Mas ahora usaremos "from", ya que en vez de usar la libreria entera, podemos especificar solo lo que queremos recuperar de ahi.
" from sklearn.preprocessing import StandardScaler " + Luis lo explica asi "De esta parte" importa esto. " from sklearn.linear_model import LinearRegression " " from sklearn.model_selection import train_test_split " + Aqui tenemos una funcion la cual se especifica que queremos que un DataSet se divida entre uno de prueba y otro de entrenamiento. + En el modeo de entrenamiento se va a crear el modelo. + Y en el de entrenamiento se va a verificar si fue bueno o fue malo. 2. Definir las colummnas que van usar para las x-axis, y tambien las columnas que seran para la variable predictora. " X_cols = list(set(df.columns)-set(['charges'])) " + X cols van a ser igual a una lista la cual estara compuesta de todas las columnas que existen menos la variable predictora. + Asi para que el programa revise todas las columnas excepto una. + Nota: Usando la variable " set " se eliminan los duplicados. σ La siguiente es definir la variable predictoria a la cual es asi: " y_col = ['charges'] " 3. Una vez teniendo las columnas, ahora se estableceran las variables a usar.
" X = df[X_cols].values " + X es igual a data frame de todas la columnas de x, piendo solo los valores que tengan. " y = df[y_col].values " 4.Lo siguiente es crear el modelo de " test " and "train"speed:
" X_train, X_test, y_train, y_test = train_test_split(X,y) " + Se establecen las palabras que va a ayuda a entrenar y probar el modelo. 5. Ahora lo que sigue es establacer la informacion de los datos " sc_x = StandardScaler().fit(X) " " sc_y = StandardScaler().fit(y) " + Las variables van a hacer igual al sus repectivas StandardScaler () ----------->Haciendo asi lo msimo con sus debidas funciones para crear el campo de "train" y "test" sobre "x" e "y" " X_train = sc_x.transform(X_train) " " X_test = sc_x.transform(X_test) " " y_train = sc_y.transform(y_train) " " y_test = sc_y.transform(y_test) " 6. Ahora hay que aclarar el modelo a crear, en este caso linaer regression model = LinearRegression() model.fit(X_train,y_train) 7. Y finanlmente se hace uba prediccion de los datos. " y_pred = model.predict(X_test) "
Al final Luis, uso " y_pred.shape " para conocer el numero de colmnas y filas que hay. teniendo asi muchas columnas pero solo una vairblse , lo cual esta correcto.
Haces un gran aporte Dick!!! solo te sugeriría que, estaría bueno que uses lenguaje markdown para que sea mas simple la lectura. saludos!!
aqui les dejo lo que me analiza chatGPT
There does not appear to be any syntax errors in the code you provided. However, there are a few potential issues that could impact the performance or accuracy of the model:
Standardizing the response variable (y) using StandardScaler is generally not recommended, as this can affect the interpretation of the model’s output. It might be more appropriate to standardize the predictors (x) instead.
The code splits the data into training and test sets using train_test_split, but then applies standardization to the entire dataset rather than just the training set. This means that the test set is being transformed using statistics computed from the entire dataset, which could introduce bias. It would be better to fit the standardization transformation on the training set and then apply it to both the training and test sets.
hackeaste el sistema
Amigo, eso es lo que estaba leyendo por otros medios a partir de los aportes en los comentarios, qué practico! Qué le pediste hacer al chatGPT para esa respuesta? pues a mi me dijo que estaba bien y no coincidió con la que tú obtuviste hasta que pregunte especificamente.
A partir de los comentarios y fuentes que aportan @Blas Ferreira, @Fernando Uriel Torres Ramírez, @Anuar Steven Garcia Gutierrez como de otros compañeros que coinciden en algunos puntos, el código debería cambiar de (...) a (...): . Aparece: .
train_test_split() divide al conjunto de datos al no indicarle la proporcion posiblemente la funciona usa el valor por defecto
El tamaño por defecto del conjunto de prueba es 0.25
El entrenamiento del escalador debería ser solo con las variables de entrenamiento, es decir
sc_x.fit(X_train) sc_y.fit(y_train)
Para todos los modelos de ML
defines modelo modelo = LinearRegression()
lo entrenas model.fit( data_train_x, data_target_y)
generas el predictor y_pred = modelo.predict(X_test)
No entiendo muy bien para qué sirve la función de estandarizar. Para qué se requieren los datos estandarizados?
Hay un grave error en esta clase. Uno de los principios del aprendizaje supervidado es que no se estandariza. De hecho si ustedes ejecutan el modelo sin estandarizar les va a dar exactamente igual las predicciones
Entonces cuál es el propósito de estandarizar? 🤔
No es correcto, escalar los datos debe hacerse en la mayoría de los casos, principalmente en el aprendizaje supervisado, escalar o no los datos depende del modelo, es decir si es sensible o no a datos escalados.
Otra manera de crear el modelo con Pipeline
from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split from sklearn.pipeline import Pipeline
X = df.drop('charges', axis='columns') y = df['charges'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) pipeline_lr = Pipeline(steps=[('scaler', StandardScaler()), ('classifier', LinearRegression())]) pipeline_lr.fit(X_train, y_train) y_pred = pipeline_lr.predict(X_test)
El train_test_split() divide al conjunto de datos en 80% para entrenamiento (train) y 20% para prueba (test).
El dataset o conjunto de datos test te va a permitir evaluar tu modelo una vez que lo entranaste aplicando model.fit(Xtrain, y_train).
Entrenar tu modelo significa que l algoritmo está ajustando una línea a tus datos de manera automática.
¡Perfecto! Una vez explorados y preparados los datos, el siguiente paso es entrenar el modelo de regresión lineal. A continuación te explico cómo hacerlo paso a paso con scikit-learn:
✅ Paso 1: Importar librerías necesarias
import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split
✅ Paso 2: Cargar y preparar los datos
# Cargar el dataset df = pd.read_csv('insurance.csv')
# Codificar variables categóricas (por ejemplo: sexo, fumador, región) df_encoded = pd.get_dummies(df, drop_first=True)
# Separar variables independientes (X) y variable objetivo (y) X = df_encoded.drop('charges', axis=1) y = df_encoded['charges']
✅ Paso 3: Dividir el conjunto de datos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
✅ Paso 4: Crear y entrenar el modelo
model = LinearRegression() model.fit(X_train, y_train)
✅ Paso 5: Ver los coeficientes del modelo
# Mostrar los coeficientes junto con los nombres de las variables coeff_df = pd.DataFrame(model.coef_, X.columns, columns=['Coeficiente']) print(coeff_df)
✅ Paso 6: Realizar predicciones
y_pred = model.predict(X_test)
✅ Paso 7: Evaluar el modelo
Puedes usar R² y el Error Cuadrático Medio (MSE):
from sklearn.metrics import r2_score, mean_squared_error
print('R²:', r2_score(y_test, y_pred)) print('MSE:', mean_squared_error(y_test, y_pred))
el tema de
X_cols = list(set(df.columns)-set(['charges']))y_col = ['charges'] X = df[X_cols].valuesy = df[y_col].values
esta de más y medio obsoleto, lo ideal seria :
X = data.drop(columns = ['charges'])
y = data[['charges']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
así conservas el nombre de las columnas. de paso el codigo es mas legible y más limpio.
El profesor hizo mas lineas de las necesarias, talvez para que la clase sea mas entendible, pero siguiendo las buenas practicas el codigo sería el siguiente, y creo que te aclarara muchas dudas y tiempo investigando :)
# Escalar las variables dependientes, primero ajustamos el modelo y luego transformamos ya con la media y desviación estandar que se obtuvo en el fit scaler = StandardScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # Entrenar el modelo model = LinearRegression() model.fit(X_train_scaled, y_train) # Predecir el modelo y_pred = model.predict(X_test_scaled) # Ver resultados results_df = X_test.copy() results_df['Valores reales'] = y_test.values results_df['Valores predichos'] = y_pred results_df ```# Escalar las variables dependientes, primero ajustamos el modelo y luego transformamos ya con la media y desviación estandar que se obtuvo en el fitscaler = StandardScaler()X\_train\_scaled = scaler.fit\_transform(X\_train)X\_test\_scaled = scaler.transform(X\_test) \# Entrenar el modelomodel = LinearRegression()model.fit(X\_train\_scaled, y\_train) \# Predecir el modeloy\_pred = model.predict(X\_test\_scaled) \# Ver resultadosresults\_df = X\_test.copy()results\_df\['Valores reales'] = y\_test.valuesresults\_df\['Valores predichos'] = y\_predresults\_df
Hola, yo pienso que hay un error de ética grave en la creación del modelo. En el video el profesor calculo las desvaciones estandar sobre todo el conjunto de datos cuando la ética en cienca de datos nos obliga a hacer todo el modelamiento sólo con el conjunto de entrenamiento.
El modelo debe ser entrenado con valores que no conozca sin embargo la desviacion estandar sobre todo el conjunto de datos sí le esta dando conocimiento al modelo del conjunto de testeo.
sc_x = StandardScaler().fit(X_train) sc_y = StandardScaler().fit(y_train)
la ética en la ciencia de datos normalmente se refiere a otros temas y nada tiene que ver con errores técnicos al desarrollar un modelo, el modelo fue entrenado con valores que no conoce en este paso model.fit(X_train, y_train), ahora es cierto que cuando hace la evaluación del modelo lo hace con los datos escalados, pero lo menciona, acá dejo una versión con de la evaluación del modelo con datos escalados y sin escalar, mse = metrics.mean_squared_error(sc_y.inverse_transform(y_test), sc_y.inverse_transform(y_pred))
r2 = metrics.r2_score(sc_y.inverse_transform(y_test), sc_y.inverse_transform(y_pred))
mse_sc = metrics.mean_squared_error(y_test ,y_pred)
r2_sc = metrics.r2_score(y_test ,y_pred), observaremos que r2 mantiene su valor sin importar si los datos están o no escalados mientras que mse si sufre un cambio importante.
ESCALADO DE DATOS
Para aplicar un escalado semejante a las diferentes características tenemos dos enfoques diferentes: el escalado y la normalización. El escalado va a transformar los valores de las características de forma que estén confinados en un rango [a, b], típicamente [0, 1] o [-1, 1]. La normalización va a transformar las características de forma que todas compartan un mismo valor medio y una misma desviación media, por ejemplo.
Es importante recordar que el escalador deberá entrenarse solo con los datos de entrenamiento para evitar fugas, y que deberá aplicarse de igual forma tanto a los datos de entrenamiento como a los de validación y prueba.
Scikit-Learn ofrece diferentes escaladores (llamados así con independencia del enfoque aplicado)
Pasos para hacer prediccion y utilizar un modelo por ejemplo LinearR: 1. se separan las columnas en x las variables independientes y Y los dependientes con train_test_split
2. se separan los trining de los tests
3. se hace el preprocessing de los datos
3.1. se crea un fit con standarscaler para guardar la mean and sd for x and y, two models
3.2. con esos dos modelos se pasan los x and Y training y testing por el standar scaler para transformar
4. se crea el modelo de linear regression con los training, .fit
4. se puede sacar el score con los tests
5. se puede sacar la prediccion con los tests
me quede esperando la aplicacion de pca para reducir la dimencionalidad. esta tecnica solo se realiza cuando existen valores de correlacion significativos ?
obtengo este error:
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-63-086b9f3ab7e7> in <module>() 7 X_train,X_test,y_train,y_test=train_test_split(X,y) 8 ----> 9 sc_x=StandardScaler.fit(X) 10 sc_y=StandardScaler.fit(y) 11 TypeError: fit() missing 1 required positional argument: 'X'
Mi codigo es :
X_cols=list(set(df.columns)-set(['charges'])) y_cols=['charges'] X=df[X_cols].values y=df[y_cols].values X_train,X_test,y_train,y_test=train_test_split(X,y) sc_x=StandardScaler.fit(X) sc_y=StandardScaler.fit(y) X_train=sc_x.transform(X_train) X_test=sc_x.transform(X_test) y_train=sc_y.transform(y_train) y_test=sc_y.transform(y_test) model=LinearRegression() model.fit(X_train,y_train)
Esto pasa porque te faltaron los paréntesis en sc_x=StandardScaler.fit(X). Debería de ser
sc_x=StandardScaler().fit(X)
Esto pasa porque cuando no pones los paréntesis usas una referencia a la clase, pero no la instancias (no corres el constructor o el init(). Entonces no sé crea la variable self que es una referencia a la instancia. Espero esto te haya ayudado 😄