Ajuste de curvas en Python (con ejemplos)

Actualizado por ultima vez el 11 de agosto de 2022, por Dereck Amesquita.

A menudo, es posible que desee ajustar una curva a algún conjunto de datos en Python.

El siguiente ejemplo paso a paso explica cómo ajustar curvas a datos en Python usando la función numpy.polyfit () y cómo determinar qué curva se ajusta mejor a los datos.

Paso 1: Crear y visualizar datos

Primero, creemos un conjunto de datos falso y luego creemos un diagrama de dispersión para visualizar los datos:

import pandas as pd
import matplotlib.pyplot as plt

#create DataFrame
df = pd.DataFrame({'x': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
                   'y': [3, 14, 23, 25, 23, 15, 9, 5, 9, 13, 17, 24, 32, 36, 46]}))

#crear un diagrama de dispersión de x vs. y
plt.scatter(df.x, df.y)

Paso 2: Ajuste varias curvas

A continuación, ajustemos varios modelos de regresión polinomial a los datos y visualicemos la curva de cada modelo en la misma gráfica:

import numpy como np

# Ajustar modelos polinomiales hasta el grado 5
model1 = np.poly1d(np.polyfit(df.x, df.y, 1))
model2 = np.poly1d(np.polyfit(df.x, df.y, 2))
model3 = np.poly1d(np.polyfit(df.x, df.y, 3))
model4 = np.poly1d(np.polyfit(df.x, df.y, 4))
model5 = np.poly1d(np.polyfit(df.x, df.y, 5))

# Crear polilínea de diagrama de dispersión
polyline = np.linspace(1, 15, 50)
plt.scatter(df.x, df.y)

# Añadir líneas polinomiales ajustadas al diagrama de dispersión 
plt.plot(polyline, model1(polyline), color='green')
plt.plot(polyline, model2(polyline), color='red')
plt.plot(polyline, model3(polyline), color='purple')
plt.plot(polyline, model4(polyline), color='blue')
plt.plot(polyline, model5(polyline), color='orange')
plt.show()

Para determinar qué curva se ajusta mejor a los datos, podemos observar el R cuadrado ajustado de cada modelo.

Este valor nos dice el porcentaje de la variación en la variable de respuesta que se puede explicar por la (s) variable (s) predictoras en el modelo, ajustado por el número de variables predictoras.

#Define la función para calcular el ajuste de la definición de r cuadrado.

def adjR(x, y, degree):
    results = {}
    coeffs = np.polyfit(x, y, degree)
    p = np.poly1d(coeffs)
    yhat = p(x)
    ybar = np.sum(y)/len(y)
    ssreg = np.sum((yhat-ybar)**2)
    sstot = np.sum((y - ybar)**2)
    results['r_squared'] = 1- (((1-(ssreg/sstot))*(len(y)-1))/(len(y)-degree-1))

    return results

# R-cuadrado ajustado calculado de cada modelo
adjR(df.x, df.y, 1)
adjR(df.x, df.y, 2)
adjR(df.x, df.y, 3)
adjR(df.x, df.y, 4)
adjR(df.x, df.y, 5)

{'r_squared': 0.3144819}
{'r_squared': 0.5186706}
{'r_squared': 0.7842864}
{'r_squared': 0.9590276}
{'r_squared': 0.9549709}

De la salida podemos ver que el modelo con el R-cuadrado ajustado más alto es el polinomio de cuarto grado, que tiene un R-cuadrado ajustado de 0.959 .

Paso 3: Visualice la curva final

Por último, podemos crear un diagrama de dispersión con la curva del modelo polinomial de cuarto grado:

 # Fit de modelo polinomial de cuarto grado
model4 = np.poly1d(np.polyfit(df.x, df.y, 4))

# Define el diagrama de dispersión
polyline = np.linspace(1, 15, 50)
plt.scatter(df.x, df.y)

# Añadir curva polinomial ajustada al diagrama de dispersión
plt.plot(polyline, model4(polyline), '--', color='red')
plt.show()

También podemos obtener la ecuación para esta línea usando la función print () :

print(model4)

          4 3 2
-0,01924 x + 0,7081 x - 8,365 x + 35,82 x - 26,52

La ecuación de la curva es la siguiente:

y = -0.01924x ⁴ + 0.7081x ³ – 8.365x ² + 35.82x – 26.52

Podemos usar esta ecuación para predecir el valor de la variable de respuesta en función de las variables predictoras del modelo. Por ejemplo, si x = 4, predeciríamos que y = 23,32 :

y = -0,0192 (4) ⁴ + 0,7081 (4) ³ – 8,365 (4) ² + 35,82 (4) – 26,52 = 23,32

Recursos adicionales

Una introducción a la regresión polinomial
Cómo realizar una regresión polinomial en Python

• https://r-project.org
• https://www.python.org/
• https://www.stata.com/