Entrenamiento del modelo

Clase 13 de 18 • Curso de Regresión Lineal con Python y scikit-learn

Alex Junior Rodriguez Huerta

student•

Este capítulo me dejó unas dudas que resolví investigando un poco.

Al no colocar un test_size, se asume que toma un 75% para train y 25% para test
El .fit lo que haría es obtener la media y la desviación estandar para luego aplicarlo al usar la transformación.
Al hacer un fit de X, y es para sacar los valores que describo en 2) y aplicarlos al X_train, X_test, y_train, y_test
No siempre es necesario aplicar un fit_transform al target
En caso uses el método que coloco abajo, debes saber que .fit_transform se aplica a X_train, y_train, y .transform solo se aplica a X_test, y_test

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)

Diego González Castellanos

student•

Tenia la duda de la distribución, gracias.

Joaquin Romero Flores

student•

Gracias!

Blas Ferreira

student•

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?

George Wang Lee Zevallos Durand

student•

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.

Andres Gutiérrez Castillo

student•

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

Miguel Angel Herrera Chavez

student•

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.

Jeinfferson Bernal G

student•

Es correcto. Asi tambien lo entiendo yo!

Dick Saide Suárez Blanco

student•

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

Maximiliano Cuesta

student•

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

Anuar Steven Garcia

student•

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.

jader lopez

student•

hackeaste el sistema

Yonatan Efraín Jara Boza

student•

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.

Yonatan Efraín Jara Boza

student•

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

. Debería ser: .

Cristian Enrique Cuevas Mercado

student•

train_test_split() divide al conjunto de datos al no indicarle la proporcion posiblemente la funciona usa el valor por defecto

Santiago Ahumada Lozano

student•

El tamaño por defecto del conjunto de prueba es 0.25

FELIX DAVID CORDOVA GARCIA

student•

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)

Tomas Dale

student•

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)

Natalia Bermudez Calderon

student•

No entiendo muy bien para qué sirve la función de estandarizar. Para qué se requieren los datos estandarizados?

Sebastián José Herrera Monterrosa

student•

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

Joel Orellana

student•

Entonces cuál es el propósito de estandarizar? 🤔

Gerardo Mayel Fernández Alamilla

student•

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.

Julian Cardenas Peñuela

student•

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)

Richard Eduardo Sailema Medina

student•

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.

Mario Alexander Vargas Celis

student•

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

GUSTAVO CHIAPPE

student•

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.

Gian HM

student•

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

Santiago Ahumada Lozano

student•

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.

Santiago Ahumada Lozano

student•

sc_x = StandardScaler().fit(X_train)
sc_y = StandardScaler().fit(y_train)

Gerardo Mayel Fernández Alamilla

student•

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.

David Carrillo Castillo

student•

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)

Dario vallejo

student•

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

Daniel Andres Rojas Paredes

student•

me quede esperando la aplicacion de pca para reducir la dimencionalidad. esta tecnica solo se realiza cuando existen valores de correlacion significativos ?

JIMI MARCOS ALTAMIRANO HUAMANI

student•

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)

Luis Fernando Laris Pardo

student•

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 😄

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)

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)

# 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

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

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)

Entrenamiento del modelo

Introducción al curso

Tu primera regresión lineal con scikit-learn

Análisis de datos para tu primera regresión lineal

Entrenando un modelo de regresión lineal con scikit-learn

Cómo funciona la regresión lineal

¿Qué es la regresión lineal?

Cuándo utilizar un modelo de regresión lineal

Función de pérdida y optimización: mínimos cuadrados

Evaluando el modelo: R^2 y MSE

Regresión lineal multivariable

Regresión lineal multivariable

Análisis de regresión multivariable

Proyecto práctico

Regresión lineal para predecir los gastos médicos de pacientes

Exploración y preparación de datos

Análisis de correlación de los datos

Entrenamiento del modelo

Evaluando el modelo

Mejorando el modelo

Pasos siguientes

¿Qué hay más allá de la linealidad?

Siguientes pasos en modelos de inteligencia artificial

Comparte tu proyecto de regresión lineal y certifícate