Non-linear curve fitting in SciPy - Mini Project: Build & Apply

Non-linear Curve Fitting with SciPy

📖 Scenario: You are a scientist studying how a plant grows over time. You collected data on the plant's height at different days. You want to find a curve that best fits this growth data to understand the growth pattern.

🎯 Goal: Build a Python program that uses SciPy to fit a non-linear curve to the plant growth data and display the fitted curve parameters.

📋 What You'll Learn

Create a dictionary with days and plant heights

Define a growth model function with parameters

Use SciPy's curve_fit to find the best parameters

Print the fitted parameters

💡 Why This Matters

🌍 Real World

Scientists and engineers often collect data that follows complex patterns. Curve fitting helps find formulas that describe these patterns, making predictions easier.

💼 Career

Data scientists and analysts use curve fitting to model trends in data, which is essential in fields like biology, finance, and engineering.

1

Create the plant growth data

Create a dictionary called growth_data with these exact entries: 1: 2.5, 2: 3.6, 3: 5.1, 4: 7.4, 5: 11.2 representing days and plant heights.

SciPy

# Create the growth_data dictionary with days as keys and heights as values
# Your code here

Hint

Use curly braces to create a dictionary with the exact day-height pairs.

2

Define the growth model function

Define a function called growth_model that takes t, a, and b as inputs and returns a * t ** b.

SciPy

growth_data = {1: 2.5, 2: 3.6, 3: 5.1, 4: 7.4, 5: 11.2}

# Define the growth_model function here
# Your code here

Hint

The function should return the formula a * t ** b where t is time.

3

Fit the curve using SciPy

Import curve_fit from scipy.optimize. Use curve_fit with growth_model, the list of days from growth_data.keys(), and the list of heights from growth_data.values(). Store the output parameters in params.

SciPy

growth_data = {1: 2.5, 2: 3.6, 3: 5.1, 4: 7.4, 5: 11.2}

def growth_model(t, a, b):
    return a * t ** b

# Import curve_fit and fit the curve to get params
# Your code here

Hint

Use list(growth_data.keys()) and list(growth_data.values()) to pass days and heights as lists.

4

Print the fitted parameters

Print the string "Fitted parameters: a = {params[0]:.2f}, b = {params[1]:.2f}" using an f-string to show the fitted values rounded to two decimals.

SciPy

from scipy.optimize import curve_fit

growth_data = {1: 2.5, 2: 3.6, 3: 5.1, 4: 7.4, 5: 11.2}

def growth_model(t, a, b):
    return a * t ** b

params, _ = curve_fit(growth_model, list(growth_data.keys()), list(growth_data.values()))

# Print the fitted parameters with two decimals
# Your code here

Hint

Use print(f"Fitted parameters: a = {params[0]:.2f}, b = {params[1]:.2f}") to show the results.

Practice

1. What is the main purpose of using scipy.optimize.curve_fit in data analysis?

easy

A. To sort data points in ascending order

B. To find the best-fitting curve for data when the relationship is non-linear

C. To calculate the mean of a dataset

D. To generate random numbers for simulations

Solution

1. Step 1: Understand the function's purpose

   scipy.optimize.curve_fit is designed to fit a curve to data points, especially when the relationship is not a straight line.

2. Step 2: Compare options with the function's goal

   Options B, C, and D describe unrelated tasks like sorting, averaging, or random number generation, which are not the purpose of curve fitting.

3. Final Answer:

   To find the best-fitting curve for data when the relationship is non-linear -> Option B

4. Quick Check:

   Curve fitting = best-fitting curve [OK]

Hint: Curve fitting finds best curve, not sorting or averaging [OK]

Common Mistakes:

• Confusing curve fitting with data sorting
• Thinking curve_fit calculates averages
• Assuming curve_fit generates random data

2. Which of the following is the correct way to import the curve_fit function from SciPy?

easy

A. import curve_fit from scipy.optimize

B. import scipy.curve_fit

C. from scipy import curve_fit

D. from scipy.optimize import curve_fit

Solution

1. Step 1: Recall correct import syntax in Python

   To import a specific function from a module, use from module import function syntax.

2. Step 2: Match syntax with options

   from scipy.optimize import curve_fit matches the correct syntax: from scipy.optimize import curve_fit. Options B, C, and D use incorrect syntax or wrong module paths.

3. Final Answer:

   from scipy.optimize import curve_fit -> Option D

4. Quick Check:

   Correct import = from module import function [OK]

Hint: Use 'from module import function' to import specific functions [OK]

Common Mistakes:

• Using 'import scipy.curve_fit' which is invalid
• Trying 'from scipy import curve_fit' when it's in optimize submodule
• Incorrect order like 'import curve_fit from ...'

3. What will be the output of the following code snippet?

import numpy as np
from scipy.optimize import curve_fit

def model(x, a, b):
    return a * np.exp(b * x)

xdata = np.array([0, 1, 2, 3])
ydata = np.array([1, 2.7, 7.4, 20.1])

params, _ = curve_fit(model, xdata, ydata)
print(np.round(params, 2))

medium

A. [1.00 1.00]

B. [1.02 1.00]

C. [1.00 0.99]

D. [0.99 1.00]

Solution

1. Step 1: Understand the model and data

   The model is an exponential function: a * exp(b * x). The ydata roughly follows this pattern with a near 1 for a and about 1 for b.

2. Step 2: Run curve_fit and round parameters

   Using curve_fit on given data returns parameters close to [1.00, 0.99]. Rounding to two decimals gives [1.00 0.99].

3. Final Answer:

   [1.00 0.99] -> Option C

4. Quick Check:

   Fitted params ≈ [1.00, 0.99] [OK]

Hint: Run curve_fit and round parameters to check values [OK]

Common Mistakes:

• Assuming parameters are exactly 1.00 and 1.00
• Confusing parameter order or values
• Ignoring rounding effects

4. Identify the error in the following code snippet for non-linear curve fitting:

import numpy as np
from scipy.optimize import curve_fit

def model(x, a, b):
    return a * np.exp(b * x)

xdata = np.array([0, 1, 2, 3])
ydata = np.array([1, 2.7, 7.4, 20.1])

params = curve_fit(model, xdata, ydata)
print(params)

medium

A. Missing unpacking of the tuple returned by curve_fit

B. Model function has wrong parameters

C. xdata and ydata have different lengths

D. curve_fit is not imported correctly

Solution

1. Step 1: Check the return value of curve_fit

   curve_fit returns a tuple: (parameters, covariance). The code assigns this tuple to a single variable without unpacking.

2. Step 2: Identify the correct usage

   Correct usage unpacks the tuple: params, _ = curve_fit(...). Without unpacking, printing params shows the tuple, not just parameters.

3. Final Answer:

   Missing unpacking of the tuple returned by curve_fit -> Option A

4. Quick Check:

   curve_fit returns tuple, unpack it [OK]

Hint: Always unpack curve_fit output: params, _ = curve_fit(...) [OK]

Common Mistakes:

• Assigning curve_fit output to one variable without unpacking
• Assuming curve_fit returns only parameters
• Ignoring the covariance matrix returned

5. You want to fit a non-linear model y = a * x / (b + x) to data using curve_fit. Which of the following code snippets correctly defines the model and fits the data?

import numpy as np
from scipy.optimize import curve_fit

def model(x, a, b):
    return a * x / (b + x)

xdata = np.array([1, 2, 3, 4, 5])
ydata = np.array([0.5, 1.2, 1.8, 2.4, 2.9])

params, covariance = curve_fit(model, xdata, ydata)
print(np.round(params, 2))

hard

A. Correctly defines model and fits data using curve_fit

B. Model function should use addition instead of division

C. curve_fit requires initial guess parameters to work

D. xdata and ydata lengths must be different for curve_fit

Solution

1. Step 1: Check model function correctness

   The model y = a * x / (b + x) is correctly implemented as return a * x / (b + x).

2. Step 2: Verify curve_fit usage

   The code calls curve_fit(model, xdata, ydata) and unpacks parameters and covariance correctly. Initial guesses are optional here.

3. Final Answer:

   Correctly defines model and fits data using curve_fit -> Option A

4. Quick Check:

   Model and curve_fit usage correct [OK]

Hint: Define model exactly, call curve_fit with data and unpack results [OK]

Common Mistakes:

• Changing division to addition in model
• Thinking initial guesses are always required
• Using different lengths for xdata and ydata