Sim_Raccing_Eng_Challenge_lectura_csv

December 1, 2024

1 Sim-Racing 25
1.1 Librerias
• Para la lectura de csv estamos usando Pandas y CSV.
• Para la representación gáfica Matplotlib.

2 Leer los csv

[12]: import pandas as pd
import csv

#df1 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪charlotte_motor_speedway_&_ks_mazda_mx5_cup_&_05-VIGO-VALIÑAS_&_stint_2.

↪csv', header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

#df2 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪charlotte_motor_speedway_&_ks_mazda_mx5_cup_&_05-VIGO-VALIÑAS_&_stint_3.

↪csv', header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

#df3 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪charlotte_motor_speedway_&_ks_mazda_mx5_cup_&_05-VIGO-VALIÑAS_&_stint_4.

↪csv', header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

#df4 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪ks_barcelona_&_rss_formula_rss_2_v8_&_EC-40-VIGO-JAVI_&_stint_32.csv',␣

↪header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

#df5 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪charlotte_motor_speedway_&_ks_mazda_mx5_cup_&_05-VIGO-VALIÑAS_&_stint_5.

↪csv', header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

#df6 = pd.read_csv('~/UM25/SimRacEngChallenge/
↪charlotte_motor_speedway_&_ks_mazda_mx5_cup_&_05-VIGO-VALIÑAS_&_stint_6.

↪csv', header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

# Concatenar los DataFrames en uno solo

#df_combinado = pd.concat([df1, df2, df3, df4], ignore_index=True)

# Guardar el DataFrame combinado en un nuevo archivo CSV

#df_combinado.to_csv('~/UM25/SimRacEngChallenge//archivo_combinado.csv',␣
↪index=False)

1
#df = pd.read_csv('~/UM25/SimRacEngChallenge//archivo_combinado.csv',␣
↪header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

df = pd.read_csv('~/UM25/SimRacEngChallenge/
↪ks_barcelona_&_rss_formula_rss_2_v8_&_EC-40-VIGO-JAVI_&_stint_32.csv',␣

↪header=None, skiprows=16, quoting=csv.QUOTE_ALL, encoding='utf-8')

# Extraer las columnas de interés

altura_delantera_izquierda = df.iloc[:, 92] # Columna 93 (índice 92)
altura_delantera_derecha = df.iloc[:, 93]
altura_trasera_izquierda = df.iloc[:, 94]
altura_trasera_derecha = df.iloc[:, 95]
#mejor_vuelta = df.iloc[-1,17] # Última fila de la columna 18
mejor_vuelta = df.iloc[:,17]
lap_time = df.iloc[:,75] # Tiempo en esa vuelta, esto es lo que cambia al␣
↪variar los parametros

ballast = df.iloc[:,15]

# Crear un nuevo DataFrame con los datos relevantes

df_resumen = pd.DataFrame({
'Altura_DI': altura_delantera_izquierda,
'Altura_DD': altura_delantera_derecha,
'Altura_TI': altura_trasera_izquierda,
'Altura_TD': altura_trasera_derecha,
'Mejor_Vuelta': mejor_vuelta,
'Lap_time': lap_time,
'Ballast': ballast
})

# Mostrar el DataFrame resultante

print(df_resumen)

Altura_DI Altura_DD Altura_TI Altura_TD Mejor_Vuelta Lap_time \

0 29.0 29.0 53.5 53.5 89.044 540.24
1 29.1 29.1 53.3 53.3 89.044 540.29
2 29.0 29.0 52.9 52.9 89.044 540.35
3 25.5 25.5 53.9 53.9 89.044 540.40
4 26.9 26.9 52.1 52.1 89.044 540.45
.. … … … … … …
826 16.5 16.5 42.6 42.6 89.044 581.55
827 16.3 16.3 41.7 41.7 89.044 581.60
828 16.9 16.9 43.1 43.1 89.044 581.64
829 17.3 17.3 42.4 42.4 89.044 581.69
830 18.4 18.4 45.8 45.8 89.044 581.74

Ballast
0 0.0
1 0.0
2 0.0

2
 3 0.0
4 0.0
.. …
826 0.0
827 0.0
828 0.0
829 0.0
830 0.0

[831 rows x 7 columns]

2.1 Filtrar los datos

Ordenar los datos para observar como afecta cada parámetro de forma indiviual al tiempo de vuelta
### Filtar por columnas

[13]: import pandas as pd

df_resumen = pd.DataFrame({
'Altura_DI': altura_delantera_izquierda,
'Altura_DD': altura_delantera_derecha,
'Altura_TI': altura_trasera_izquierda,
'Altura_TD': altura_trasera_derecha,
'Mejor_Vuelta': mejor_vuelta,
'Lap_time': lap_time,
'Ballast': ballast
})

time_altura_atras = df_resumen.groupby(['Altura_DD','Ballast']).
↪agg(list)[['Altura_TD', 'Lap_time']]

time_ballast = df_resumen.groupby(['Altura_TD','Altura_DD']).
↪agg(list)[['Ballast','Lap_time' ]]

time_altura_delante = df_resumen.groupby(['Altura_TD', 'Ballast']).

↪agg(list)[['Altura_DD','Lap_time']]

print(time_altura_atras)
print(time_altura_delante)
print(time_ballast)

Altura_TD Lap_time
Altura_DD Ballast
10.3 0.0 [39.7] [559.09]
10.5 0.0 [36.6] [558.59]
10.6 0.0 [39.4] [558.9]
11.1 0.0 [39.6] [558.69]
11.5 0.0 [33.9] [558.29]
… … …
30.6 0.0 [51.3] [564.84]

3
 30.7 0.0 [52.2] [564.89]
30.8 0.0 [53.0] [564.54]
31.0 0.0 [52.0] [565.1]
31.1 0.0 [50.2] [565.99]

[180 rows x 2 columns]

Altura_DD Lap_time
Altura_TD Ballast
31.7 0.0 [18.7] [556.94]
31.9 0.0 [15.9] [557.99]
32.8 0.0 [14.4] [557.34]
32.9 0.0 [16.2] [555.64]
33.1 0.0 [15.8] [556.7]
… … …
54.4 0.0 [27.8] [564.75]
54.7 0.0 [25.1, 26.0] [566.24, 566.29]
55.1 0.0 [26.3] [566.15]
55.3 0.0 [29.7] [564.59]
57.2 0.0 [22.5] [563.19]

[200 rows x 2 columns]

Ballast Lap_time
Altura_TD Altura_DD
31.7 18.7 [0.0] [556.94]
31.9 15.9 [0.0] [557.99]
32.8 14.4 [0.0] [557.34]
32.9 16.2 [0.0] [555.64]
33.1 15.8 [0.0] [556.7]
… … …
54.7 25.1 [0.0] [566.24]
26.0 [0.0] [566.29]
55.1 26.3 [0.0] [566.15]
55.3 29.7 [0.0] [564.59]
57.2 22.5 [0.0] [563.19]

[710 rows x 2 columns]

2.2 Representación gráfica de los datos

2.2.1 Altura
2.2.2 Altura atras
[14]: import seaborn as sns
import matplotlib.pyplot as plt
# Con los datos separados
# Desempaquetar las listas para crear un DataFrame adecuado para graficar

4
 time_altura_atras_exploded = time_altura_atras.explode('Altura_TD').
↪explode('Lap_time')

# Crear la gráfica con Seaborn

plt.figure(figsize=(10, 6))
sns.lineplot(data=time_altura_atras_exploded, x='Altura_TD', y='Lap_time',␣
↪marker='o')

# Etiquetas y título
plt.xlabel('Altura_TD')
plt.ylabel('Lap_time')
plt.title('Tiempo (Lap_time) vs Altura_TD')

# Mostrar la gráfica
plt.grid(True)
plt.show()

Valores promedio
[15]: import pandas as pd

# Ahora agrupamos solo por 'Altura_TD' y calculamos la media de 'Lap_time'

media_por_altura_td = time_altura_atras_exploded.groupby('Altura_TD').agg({
'Lap_time': 'mean' # Calcular la media de 'Lap_time' por 'Altura_TD'

5
 }).reset_index()

# Ver el resultado
print(media_por_altura_td)

Altura_TD Lap_time
0 31.7 571.356667
1 31.9 558.158571
2 32.8 557.765
3 32.9 555.88
4 33.1 556.91
.. … …
195 54.4 562.022222
196 54.7 561.824118
197 55.1 565.823
198 55.3 564.59
199 57.2 569.148571

[200 rows x 2 columns]

[16]: import seaborn as sns

import matplotlib.pyplot as plt

# Crear la gráfica de líneas con Seaborn

plt.figure(figsize=(10, 6)) # Tamaño de la figura
sns.lineplot(x='Altura_TD', y='Lap_time', data=media_por_altura_td, marker='o',␣
↪color='r')

# Etiquetas y título
plt.xlabel('Altura_TD')
plt.ylabel('Promedio de Lap_time')
plt.title('Promedio de Lap_time por Altura_TD')

# Mostrar la gráfica
plt.grid(True)
plt.show()

6
 2.2.3 Altura delante
[17]: import seaborn as sns
import matplotlib.pyplot as plt
# Con los datos separados
# Desempaquetar las listas para crear un DataFrame adecuado para graficar
time_altura_delante_exploded = time_altura_delante.explode('Altura_DD').
↪explode('Lap_time')

# Crear la gráfica con Seaborn

plt.figure(figsize=(10, 6))
sns.lineplot(data=time_altura_atras_exploded, x='Altura_DD', y='Lap_time',␣
↪marker='o')

# Etiquetas y título
plt.xlabel('Altura_DD')
plt.ylabel('Lap_time')
plt.title('Tiempo (Lap_time) vs Altura_DD')

# Mostrar la gráfica
plt.grid(True)
plt.show()

7
 Valores promedio
[18]: import pandas as pd

# Ahora agrupamos solo por 'Altura_TD' y calculamos la media de 'Lap_time'

media_por_altura_dd = time_altura_delante_exploded.groupby('Altura_DD').agg({
'Lap_time': 'mean' # Calcular la media de 'Lap_time' por 'Altura_TD'
}).reset_index()

# Ver el resultado
print(media_por_altura_dd)

Altura_DD Lap_time
0 10.3 556.606667
1 10.5 561.772
2 10.6 568.395
3 11.1 556.24
4 11.5 557.29
.. … …
175 30.6 548.73
176 30.7 562.32875
177 30.8 550.405625
178 31.0 558.078333
179 31.1 564.562

8
 [180 rows x 2 columns]

[19]: import seaborn as sns

import matplotlib.pyplot as plt

# Crear la gráfica de líneas con Seaborn

plt.figure(figsize=(10, 6)) # Tamaño de la figura
sns.lineplot(x='Altura_DD', y='Lap_time', data=media_por_altura_dd, marker='o',␣
↪color='r')

# Etiquetas y título
plt.xlabel('Altura_DD')
plt.ylabel('Promedio de Lap_time')
plt.title('Promedio de Lap_time por Altura_DD')

# Mostrar la gráfica
plt.grid(True)
plt.show()

9
 2.2.4 Peso
[20]: import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# Con los datos separados
# Desempaquetar las listas para crear un DataFrame adecuado para graficar
data = {
'Ballast': [50, 38, 25], # Peso en kg
'Lap_time': [91.781, 91.739, 91.673] # Tiempo en segundos
}
time_ballast_fixed = pd.DataFrame(data)

time_ballast_exploded = time_ballast_fixed.explode('Ballast').
↪explode('Lap_time')

# Crear la gráfica con Seaborn

plt.figure(figsize=(10, 6))
sns.lineplot(data=time_ballast_exploded, x='Ballast', y='Lap_time', marker='o')

# Etiquetas y título
plt.xlabel('Ballast')
plt.ylabel('Lap_time')
plt.title('Tiempo (Lap_time) vs Ballast')

# Mostrar la gráfica
plt.grid(True)
plt.show()

10
 2.2.5 Valores promedio

[21]: import pandas as pd

# Ahora agrupamos solo por 'Altura_TD' y calculamos la media de 'Lap_time'

media_por_ballast = time_ballast_exploded.groupby('Ballast').agg({
'Lap_time': 'mean' # Calcular la media de 'Lap_time' por 'Altura_TD'
}).reset_index()

# Ver el resultado
print(media_por_ballast)

Ballast Lap_time
0 25 91.673
1 38 91.739
2 50 91.781

[22]: import seaborn as sns

import matplotlib.pyplot as plt

# Crear la gráfica de líneas con Seaborn

plt.figure(figsize=(10, 6)) # Tamaño de la figura
sns.lineplot(x='Ballast', y='Lap_time', data= media_por_ballast, marker='o',␣
↪color='r')

11
 # Etiquetas y título
plt.xlabel('Ballast')
plt.ylabel('Promedio de Lap_time')
plt.title('Promedio de Lap_time por Ballast')

# Mostrar la gráfica
plt.grid(True)
plt.show()

3 Regresiones
Para el peso en principio se usa una lineal y otra no lineal, para las alturas no lineales ## Regre-
siones no lineales

3.0.1 Altura delantera

[23]: import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

12
#Separar las variables independientes (X) y dependientes (y)
X = media_por_altura_dd[['Altura_DD']] # Variable independiente
y = media_por_altura_dd['Lap_time'] # Variable dependiente

# Transformar X para agregar términos polinómicos

poly = PolynomialFeatures(degree=3) # Grado del polinomio, puedes ajustarlo␣
↪según tus datos

X_poly = poly.fit_transform(X)

# Dividir los datos en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_poly, y, test_size=0.2,␣
↪random_state=42)

# Crear el modelo de regresión lineal

model = LinearRegression()

# Entrenar el modelo con los datos de entrenamiento

model.fit(X_train, y_train)

# Realizar predicciones
y_pred = model.predict(X_test)

# Paso 9: Evaluar el modelo

print(f'Coeficiente de determinación (R^2): {r2_score(y_test, y_pred):.2f}')
print(f'Error cuadrático medio (MSE): {mean_squared_error(y_test, y_pred):.2f}')

# Visualizar los resultados

# Graficamos los puntos originales y la curva ajustada
plt.scatter(X, y, color='blue') # Puntos originales
plt.plot(X, model.predict(poly.transform(X)), color='red') # Curva de regresión
plt.title('Regresión Polinómica: Altura_TD vs. Lap_time')
plt.xlabel('Altura_TD')
plt.ylabel('Lap_time')
plt.show()

#Obtener los coeficientes del modelo polinómico

coeficientes = model.coef_ # Coeficientes del modelo
intercepto = model.intercept_ # Intercepto (ordenada al origen)

# Para una regresión polinómica, también necesitamos los coeficientes de los␣

↪términos polinómicos

# 'poly.transform(X)' transforma X a su forma polinómica, así que podemos␣

↪obtener los coeficientes de cada grado

print("Intercepto:", intercepto)
print("Coeficientes:", coeficientes)

13
 # Crear la fórmula de la curva
formula = f'Lap_time = {intercepto:.3f}'
for i in range(1, len(coeficientes)):
formula += f' + ({coeficientes[i]:.3f}) * (Altura_TD^{i})'

print("\nFórmula de la regresión polinómica:")

print(formula)

Coeficiente de determinación (R^2): 0.36

Error cuadrático medio (MSE): 25.41

Intercepto: 490.7921883337176
Coeficientes: [ 0.00000000e+00 9.54491296e+00 -3.69780302e-01 4.05257336e-03]

Fórmula de la regresión polinómica:

Lap_time = 490.792 + (9.545) * (Altura_TD^1) + (-0.370) * (Altura_TD^2) +
(0.004) * (Altura_TD^3)

[24]: ### Altura trasera

14
[25]: import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

#Separar las variables independientes (X) y dependientes (y)

X = media_por_altura_td[['Altura_TD']] # Variable independiente
y = media_por_altura_td['Lap_time'] # Variable dependiente

# Transformar X para agregar términos polinómicos

poly = PolynomialFeatures(degree=3) # Grado del polinomio, puedes ajustarlo␣
↪según tus datos

X_poly = poly.fit_transform(X)

# Dividir los datos en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_poly, y, test_size=0.2,␣
↪random_state=42)

# Crear el modelo de regresión lineal

model = LinearRegression()

# Entrenar el modelo con los datos de entrenamiento

model.fit(X_train, y_train)

# Realizar predicciones
y_pred = model.predict(X_test)

# Paso 9: Evaluar el modelo

print(f'Coeficiente de determinación (R^2): {r2_score(y_test, y_pred):.2f}')
print(f'Error cuadrático medio (MSE): {mean_squared_error(y_test, y_pred):.2f}')

# Visualizar los resultados

# Graficamos los puntos originales y la curva ajustada
plt.scatter(X, y, color='blue') # Puntos originales
plt.plot(X, model.predict(poly.transform(X)), color='red') # Curva de regresión
plt.title('Regresión Polinómica: Altura_DD vs. Lap_time')
plt.xlabel('Altura_DD')
plt.ylabel('Lap_time')
plt.show()

#Obtener los coeficientes del modelo polinómico

coeficientes = model.coef_ # Coeficientes del modelo
intercepto = model.intercept_ # Intercepto (ordenada al origen)

15
# Para una regresión polinómica, también necesitamos los coeficientes de los␣
↪términos polinómicos

# 'poly.transform(X)' transforma X a su forma polinómica, así que podemos␣

↪obtener los coeficientes de cada grado

print("Intercepto:", intercepto)
print("Coeficientes:", coeficientes)

# Crear la fórmula de la curva

formula = f'Lap_time = {intercepto:.3f}'
for i in range(1, len(coeficientes)):
formula += f' + ({coeficientes[i]:.3f}) * (Altura_DD^{i})'

print("\nFórmula de la regresión polinómica:")

print(formula)

Coeficiente de determinación (R^2): 0.46

Error cuadrático medio (MSE): 20.57

Intercepto: 225.2807509583784
Coeficientes: [ 0.00000000e+00 1.97583598e+01 -3.64300644e-01 2.07298260e-03]

16
 Fórmula de la regresión polinómica:
Lap_time = 225.281 + (19.758) * (Altura_DD^1) + (-0.364) * (Altura_DD^2) +
(0.002) * (Altura_DD^3)

Resumen de las regresiuones

• Variables:
– 𝑡𝑣𝑢𝑒𝑙𝑡𝑎 :Lap_time
– 𝑎𝑙𝑡𝑢𝑟𝑎𝑑𝑒𝑙𝑎𝑛𝑡𝑒𝑟𝑎 : Altura_DD
– 𝑎𝑙𝑡𝑢𝑟𝑎𝑡𝑟𝑎𝑠𝑒𝑟𝑎 :Altura_TD
• Altura delantera: 𝑡𝑣𝑢𝑒𝑙𝑡𝑎 = 225.281+(19.758)∗(𝑎𝑙𝑡𝑢𝑟𝑎1𝑑𝑒𝑙𝑎𝑛𝑡𝑒𝑟𝑎 )+(−0.364)∗(𝑎𝑙𝑡𝑢𝑟𝑎2𝑑𝑒𝑙𝑎𝑛𝑡𝑒𝑟𝑎 )+
(0.002) ∗ (𝑎𝑙𝑡𝑢𝑟𝑎3𝑑𝑒𝑙𝑎𝑛𝑡𝑒𝑟𝑎 )
• Altura trasera: 𝑡𝑣𝑢𝑒𝑙𝑡𝑎 = 225.281 + (19.758) ∗ (𝑎𝑙𝑡𝑢𝑟𝑎1𝑡𝑟𝑎𝑠𝑒𝑟𝑎 ) + (−0.364) ∗ (𝑎𝑙𝑡𝑢𝑟𝑎2𝑡𝑟𝑎𝑠𝑒𝑟𝑎 ) +
(0.002) ∗ (𝑎𝑙𝑡𝑢𝑟𝑎3𝑡𝑟𝑎𝑠𝑒𝑟𝑎 )

3.0.2 Peso
[26]: import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Separar las variables independientes (X) y dependientes (y)

X = media_por_ballast[['Ballast']] # Variable independiente (cambiado de␣
↪'Altura_DD' a 'Ballast')

y = media_por_ballast['Lap_time'] # Variable dependiente

# Transformar X para agregar términos polinómicos

poly = PolynomialFeatures(degree=3) # Grado del polinomio, puedes ajustarlo␣
↪según tus datos

X_poly = poly.fit_transform(X)

# Dividir los datos en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_poly, y, test_size=0.2,␣
↪random_state=42)

# Crear el modelo de regresión lineal

model = LinearRegression()

# Entrenar el modelo con los datos de entrenamiento

model.fit(X_train, y_train)

17
# Realizar predicciones
y_pred = model.predict(X_test)

# Paso 9: Evaluar el modelo

print(f'Coeficiente de determinación (R^2): {r2_score(y_test, y_pred):.2f}')
print(f'Error cuadrático medio (MSE): {mean_squared_error(y_test, y_pred):.2f}')

# Visualizar los resultados

# Graficamos los puntos originales y la curva ajustada
plt.scatter(X, y, color='blue') # Puntos originales
plt.plot(X, model.predict(poly.transform(X)), color='red') # Curva de regresión
plt.title('Regresión Polinómica: Ballast vs. Lap_time') # Cambiado el título␣
↪para reflejar Ballast

plt.xlabel('Ballast') # Cambiado el eje X para reflejar Ballast

plt.ylabel('Lap_time')
plt.show()

# Obtener los coeficientes del modelo polinómico

coeficientes = model.coef_ # Coeficientes del modelo
intercepto = model.intercept_ # Intercepto (ordenada al origen)

# Para una regresión polinómica, también necesitamos los coeficientes de los␣

↪términos polinómicos

# 'poly.transform(X)' transforma X a su forma polinómica, así que podemos␣

↪obtener los coeficientes de cada grado

print("Intercepto:", intercepto)
print("Coeficientes:", coeficientes)

# Crear la fórmula de la curva

formula = f'Lap_time = {intercepto:.3f}'
for i in range(1, len(coeficientes)):
formula += f' + ({coeficientes[i]:.3f}) * (Ballast^{i})' # Cambiado de␣
↪'Altura_TD' a 'Ballast'

print("\nFórmula de la regresión polinómica:")

print(formula)

Coeficiente de determinación (R^2): nan

Error cuadrático medio (MSE): 0.00
/home/eva/.local/lib/python3.13/site-
packages/sklearn/metrics/_regression.py:1211: UndefinedMetricWarning: R^2 score
is not well-defined with less than two samples.
warnings.warn(msg, UndefinedMetricWarning)

18
 Intercepto: 91.70613131994622
Coeficientes: [0.00000000e+00 1.02458773e-10 9.01637206e-09 5.98769072e-07]

Fórmula de la regresión polinómica:

Lap_time = 91.706 + (0.000) * (Ballast^1) + (0.000) * (Ballast^2) + (0.000) *
(Ballast^3)

3.1 Regresión lineal

3.1.1 Peso
[27]: import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score

# Separar las variables independientes (X) y dependientes (y)

X = media_por_ballast[['Ballast']] # Variable independiente
y = media_por_ballast['Lap_time'] # Variable dependiente

19
# Dividir los datos en conjunto de entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,␣
↪random_state=42)

# Crear el modelo de regresión lineal

regresion_lineal = LinearRegression()

# Ajustar el modelo de regresión lineal a los datos de entrenamiento

regresion_lineal.fit(X_train, y_train)

# Realizar predicciones
y_pred = regresion_lineal.predict(X_test)

# Evaluar el modelo
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Imprimir métricas
print(f'Mean Squared Error (MSE): {mse:.4f}')
print(f'Coeficiente de determinación (R²): {r2:.4f}')

# Mostrar la fórmula del modelo

print("\nFórmula de la regresión lineal:")
coef = regresion_lineal.coef_
intercept = regresion_lineal.intercept_
print(f"y = {intercept:.4f} + ({coef[0]:.4f}) * X")

# Visualizar los resultados (gráfico de regresión)

plt.scatter(X, y, color='blue', label='Datos reales')
# Graficar la regresión lineal
plt.plot(X, regresion_lineal.predict(X), color='red', label='Regresión lineal')

# Títulos y etiquetas
plt.title('Regresión Lineal de Lap Time vs Ballast')
plt.xlabel('Ballast')
plt.ylabel('Lap Time')
plt.legend()
plt.show()

# Mostrar la fórmula del modelo

print("\nFórmula de la regresión lineal:")
coef = regresion_lineal.coef_
intercept = regresion_lineal.intercept_
print(f"y = {intercept:.4f} + ({coef[0]:.4f}) * X")

Mean Squared Error (MSE): 0.0004

Coeficiente de determinación (R²): nan

20
Fórmula de la regresión lineal:
y = 91.6060 + (0.0035) * X
/home/eva/.local/lib/python3.13/site-
packages/sklearn/metrics/_regression.py:1211: UndefinedMetricWarning: R^2 score
is not well-defined with less than two samples.
warnings.warn(msg, UndefinedMetricWarning)

Fórmula de la regresión lineal:

y = 91.6060 + (0.0035) * X

Resumen de las regresiuones

• Variables:
– 𝑡𝑣𝑢𝑒𝑙𝑡𝑎 :Lap_time
– 𝑏𝑎𝑙𝑙𝑎𝑠𝑡: Ballast
• 𝑦 = 0.1234 + 2.5678 ⋅ 𝑋

21