Function Parameter Fitting

Description

This post presents a simple python program to do Function Parameter Fitting, including linear fitting, polynomial fitting. For more complex fitting, such as with integral functions or differential functions, please consult to leonbreur77@gmail.com

Linear Fitting

Here is the code to define the linear function and use curve_fit to run the parameter fitting

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit


# Define the linear model function
def linear_func(x, a, b):
    return a * x + b


# Perform linear fitting
linear_y_data = 3.0 * x_data + 1.0 + 0.1 * np.random.normal(size=len(x_data))
linear_initial_guess = [1.0, 1.0]  # Initial guesses for a, b
linear_params, linear_params_covariance = curve_fit(linear_func, x_data, linear_y_data, p0=linear_initial_guess)


plt.scatter(x_data, linear_y_data, label="Data (linear)", color="green")
plt.plot(x_data, linear_func(x_data, *linear_params), label="Fitted function (linear)", color="orange")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Linear Curve Fitting")

Quadratic/Cubic/Quartic Fitting

Here is the code to define the quadratic/cubic/quartic function and use curve_fit to run the parameter fitting

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Define the linear model function
def linear_func(x, a, b):
    return a * x + b

# Define the quadratic model function
def quadratic_func(x, a, b, c):
    return a * x**2 + b * x + c

# Define the cubic model function
def cubic_func(x, a, b, c, d):
    return a * x**3 + b * x**2 + c * x + d

# Define the quartic model function
def quartic_func(x, a, b, c, d, e):
    return a * x**4 + b * x**3 + c * x**2 + d * x + e

# Perform linear fitting
linear_y_data = 3.0 * x_data + 1.0 + 0.1 * np.random.normal(size=len(x_data))
linear_initial_guess = [1.0, 1.0]  # Initial guesses for a, b
linear_params, linear_params_covariance = curve_fit(linear_func, x_data, linear_y_data, p0=linear_initial_guess)

# Print the optimal parameters for the linear model
print("Optimal parameters (linear):", linear_params)
print("Covariance of parameters (linear):", linear_params_covariance)

# Perform quadratic fitting
quadratic_y_data = 2.0 * x_data**2 - 1.0 * x_data + 0.5 + 0.1 * np.random.normal(size=len(x_data))
quadratic_initial_guess = [1.0, 1.0, 1.0]
quadratic_params, quadratic_params_covariance = curve_fit(quadratic_func, x_data, quadratic_y_data, p0=quadratic_initial_guess)

# Perform cubic fitting
cubic_y_data = 1.0 * x_data**3 - 0.5 * x_data**2 + 2.0 * x_data + 1.0 + 0.1 * np.random.normal(size=len(x_data))
cubic_initial_guess = [1.0, 1.0, 1.0, 1.0]
cubic_params, cubic_params_covariance = curve_fit(cubic_func, x_data, cubic_y_data, p0=cubic_initial_guess)

# Perform quartic fitting
quartic_y_data = 0.5 * x_data**4 - x_data**3 + x_data**2 + 2.0 * x_data + 1.0 + 0.1 * np.random.normal(size=len(x_data))
quartic_initial_guess = [1.0, 1.0, 1.0, 1.0, 1.0]
quartic_params, quartic_params_covariance = curve_fit(quartic_func, x_data, quartic_y_data, p0=quartic_initial_guess)

# Print the optimal parameters for polynomial models
print("Optimal parameters (quadratic):", quadratic_params)
print("Optimal parameters (cubic):", cubic_params)
print("Optimal parameters (quartic):", quartic_params)

# Plot the data and the fitted curves
plt.figure(figsize=(12, 12))

# Linear fit
plt.subplot(2, 2, 1)
plt.scatter(x_data, linear_y_data, label="Data (linear)", color="green")
plt.plot(x_data, linear_func(x_data, *linear_params), label="Fitted function (linear)", color="orange")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Linear Curve Fitting")

# Quadratic fit
plt.subplot(2, 2, 2)
plt.scatter(x_data, quadratic_y_data, label="Data (quadratic)", color="purple")
plt.plot(x_data, quadratic_func(x_data, *quadratic_params), label="Fitted function (quadratic)", color="brown")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Quadratic Curve Fitting")

# Cubic fit
plt.subplot(2, 2, 3)
plt.scatter(x_data, cubic_y_data, label="Data (cubic)", color="cyan")
plt.plot(x_data, cubic_func(x_data, *cubic_params), label="Fitted function (cubic)", color="magenta")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Cubic Curve Fitting")


# Quartic fit
plt.subplot(2, 2, 4)
plt.scatter(x_data, quartic_y_data, label="Data (quartic)", color="yellow", alpha=0.6)
plt.plot(x_data, quartic_func(x_data, *quartic_params), label="Fitted function (quartic)", color="black")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Quartic Curve Fitting")

plt.tight_layout()
plt.show()

Model function

Here is the code to define the a non-linear model function and use curve_fit to run the parameter fitting. In this example, we define y=a*exp(-b*x)+c.

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Define the model function (e.g., a Gaussian function)
def model_func(x, a, b, c):
    return a * np.exp(-b * x) + c


# Generate some synthetic data for demonstration
np.random.seed(42)  # For reproducibility
x_data = np.linspace(0, 4, 50)
y_data = model_func(x_data, 2.5, 1.3, 0.5) + 0.2 * np.random.normal(size=len(x_data))

# Perform curve fitting for the non-linear model
initial_guess = [1.0, 1.0, 1.0]  # Initial guesses for a, b, c
params, params_covariance = curve_fit(model_func, x_data, y_data, p0=initial_guess)

# Print the optimal parameters for the non-linear model
print("Optimal parameters (non-linear):", params)
print("Covariance of parameters (non-linear):", params_covariance)


# Plot the data and the fitted curves
plt.figure(figsize=(12, 12))

plt.scatter(x_data, y_data, label="Data (non-linear)", color="blue")
plt.plot(x_data, model_func(x_data, *params), label="Fitted function (non-linear)", color="red")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.title("Non-linear Curve Fitting")


plt.tight_layout()
plt.show()

Error analysis

Here is the error analysis code

# Error analysis function
def calculate_errors(y_data, y_fit):
    residuals = y_data - y_fit
    mse = np.mean(residuals**2)
    rmse = np.sqrt(mse)
    mae = np.mean(np.abs(residuals))
    return {
        "Residuals": residuals,
        "MSE": mse,
        "RMSE": rmse,
        "MAE": mae
    }

More complex function

For more complex curve fitting, such as below functions which is a blood kinetic model function,

please consult leonbreur77@gmail.com.

Get stephan breuer’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

The above code can be run on https://colab.research.google.com/