Fitting custom models in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of custom model fitting with scipy.optimize.curve_fit

What is the output of the following code snippet that fits a custom quadratic model to data?

SciPy

import numpy as np
from scipy.optimize import curve_fit

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

xdata = np.array([0, 1, 2, 3, 4])
ydata = np.array([1, 3, 7, 13, 21])

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

A [1.0, 2.0, 1.0]

B [0.0, 1.0, 1.0]

C [1.0, 1.0, 1.0]

D [1.0, 1.0, 2.0]

💡 Hint

Recall the quadratic formula: y = a*x² + b*x + c. Check the data points to guess coefficients.

The data fits y = x² + 2x + 1 exactly. The curve_fit finds parameters [1.0, 2.0, 1.0].

❓ data_output

intermediate

Number of parameters fitted in a custom exponential model

Given the custom exponential model y = a * exp(b * x) + c, how many parameters does scipy.optimize.curve_fit estimate?

SciPy

import numpy as np
from scipy.optimize import curve_fit

def exp_model(x, a, b, c):
    return a * np.exp(b * x) + c

xdata = np.linspace(0, 4, 5)
ydata = exp_model(xdata, 2, 0.5, 1) + 0.1 * np.random.normal(size=xdata.size)
params, _ = curve_fit(exp_model, xdata, ydata)
print(len(params))

A 4

B 2

C 3

D 1

💡 Hint

Count the number of parameters in the function definition after x.

The model has three parameters: a, b, and c. curve_fit estimates all three.

🔧 Debug

advanced

Identify the error in custom model fitting code

What error does the following code raise when trying to fit a linear model?

SciPy

import numpy as np
from scipy.optimize import curve_fit

def linear_model(x, m, c):
    return m * x + c

xdata = np.array([0, 1, 2, 3])
ydata = np.array([1, 3, 5, 7])

params, _ = curve_fit(linear_model, xdata, ydata, p0=[1])

A ValueError: x and y must have same length

B ValueError: 'p0' must be a list of length 2

C RuntimeError: Optimal parameters not found

D TypeError: linear_model() missing 1 required positional argument

💡 Hint

Check the initial guess p0 length compared to model parameters.

The model has two parameters but p0 provides only one initial guess, causing a ValueError.

❓ visualization

advanced

Plot result of fitting a sinusoidal custom model

Which plot correctly shows the fitted sinusoidal model y = a * sin(b * x + c) to noisy data?

SciPy

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

def sin_model(x, a, b, c):
    return a * np.sin(b * x + c)

xdata = np.linspace(0, 2 * np.pi, 50)
ydata = 3 * np.sin(2 * xdata + 0.5) + 0.3 * np.random.normal(size=xdata.size)
params, _ = curve_fit(sin_model, xdata, ydata, p0=[2, 2, 0])

plt.scatter(xdata, ydata, label='Data')
plt.plot(xdata, sin_model(xdata, *params), color='red', label='Fitted model')
plt.legend()
plt.show()

A Scatter points with a red exponential curve

B Scatter points with a flat red line

C Scatter points with a red linear line

D Scatter points with a red smooth sine curve closely following data

💡 Hint

Think about the shape of a sine wave and how fitting works.

The fitted model is a sine curve that closely matches the noisy data points, shown as scatter.

🧠 Conceptual

expert

Effect of initial parameter guess on fitting convergence

Which statement best describes the effect of the initial parameter guess p0 in scipy.optimize.curve_fit when fitting complex custom models?

A A poor initial guess can cause the algorithm to converge to a local minimum, not the global best fit

B Initial guesses have no effect; curve_fit always finds the global minimum

C Initial guesses only affect the speed but never the final result

D curve_fit ignores initial guesses if the model is nonlinear

💡 Hint

Consider how optimization algorithms work with complex landscapes.

Nonlinear fitting can get stuck in local minima if initial guesses are poor, affecting final fit quality.

Practice

1. What is the main purpose of using scipy.optimize.curve_fit in fitting custom models?

easy

A. To find the best parameters that make the model fit the data

B. To plot the data points automatically

C. To generate random data for testing

D. To calculate the mean of the dataset

Solution

1. Step 1: Understand the role of curve_fit

   curve_fit is used to adjust parameters of a model function so that it best fits the given data points.

2. Step 2: Identify the correct purpose

   It does not plot data, generate random data, or calculate means. Its main job is parameter estimation for fitting.

3. Final Answer:

   To find the best parameters that make the model fit the data -> Option A

4. Quick Check:

   curve_fit finds best parameters [OK]

Hint: Remember: curve_fit adjusts parameters to fit data [OK]

Common Mistakes:

• Thinking curve_fit plots data automatically
• Confusing curve_fit with data generation functions
• Assuming curve_fit calculates statistics like mean

2. Which of the following is the correct way to define a custom model function for curve_fit that fits a line y = m*x + c?

easy

A. def model(m, c, x): return m + c * x

B. def model(x, m, c): return m * x + c

C. def model(x): return m * x + c

D. def model(x, m, c): return m + c / x

Solution

1. Step 1: Check parameter order for curve_fit

   The model function must have the independent variable as the first argument, followed by parameters to fit.

2. Step 2: Verify function matches y = m*x + c

   def model(x, m, c): return m * x + c correctly defines model(x, m, c) returning m * x + c. Others have wrong order or formula.

3. Final Answer:

   def model(x, m, c): return m * x + c -> Option B

4. Quick Check:

   Model args: x first, then parameters [OK]

Hint: Model function: x first, then parameters [OK]

Common Mistakes:

• Swapping parameter and variable order
• Missing parameters in function definition
• Using wrong formula inside the function

3. Given the code below, what will be the output of print(popt)?

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

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

medium

A. [1.0 0.99]

B. [1.0 1.0]

C. [1.0 1.0] but with a runtime error

D. [1.01 1.0]

Solution

1. Step 1: Understand the model and data

   The model is a * exp(b * x). Given ydata roughly follows exponential growth, parameters a and b will be close to 1.

2. Step 2: Check output of curve_fit

   Running the code fits parameters close to a=1.0 and b=0.99 (data approximates e^x but slightly less). Rounded to two decimals, popt is approximately [1.0 0.99].

3. Final Answer:

   [1.0 0.99] -> Option A

4. Quick Check:

   Exponential fit params ~ [1.0, 0.99] [OK]

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

Common Mistakes:

• Misestimating parameters as [1.0 1.0] due to data approximation
• Confusing parameter order
• Expecting runtime errors without cause

4. What is wrong with the following code snippet for fitting a quadratic model using curve_fit?

import numpy as np
from scipy.optimize import curve_fit

def quad(x, a, b, c):
    return a * x**2 + b * x + c

xdata = np.array([1, 2, 3, 4])
ydata = np.array([3, 7, 13, 21])

popt, pcov = curve_fit(quad, ydata, xdata)
print(popt)

medium

A. Missing initial guess for parameters

B. The model function has wrong formula for quadratic

C. The independent and dependent variables are swapped in curve_fit call

D. The print statement is incorrect

Solution

1. Step 1: Check curve_fit arguments

   curve_fit expects the model, xdata (independent), then ydata (dependent). Here, ydata and xdata are swapped.

2. Step 2: Identify the error impact

   Swapping causes wrong fitting or runtime errors because the model expects x values first.

3. Final Answer:

   The independent and dependent variables are swapped in curve_fit call -> Option C

4. Quick Check:

   curve_fit(xdata, ydata) order matters [OK]

Hint: Remember: curve_fit(model, xdata, ydata) [OK]

Common Mistakes:

• Swapping xdata and ydata in curve_fit
• Assuming model formula is incorrect
• Thinking initial guess is always required

5. You want to fit a custom model y = a * sin(b * x) + c to noisy data. Which approach correctly fits the model and plots the result?

hard

A. Plot data first, then call curve_fit without storing parameters

B. Use curve_fit without defining a model function, just pass np.sin

C. Fit the model by manually guessing parameters without curve_fit

D. Define model with def model(x, a, b, c): return a * np.sin(b * x) + c, use curve_fit with data, then plot original and fitted curves

Solution

1. Step 1: Define the correct model function

   Model must be defined as model(x, a, b, c) returning a * np.sin(b * x) + c.

2. Step 2: Use curve_fit and plot results

   Call curve_fit(model, xdata, ydata) to get parameters, then plot original data and fitted curve for comparison.

3. Final Answer:

   Define model with def model(x, a, b, c): return a * np.sin(b * x) + c, use curve_fit with data, then plot original and fitted curves -> Option D

4. Quick Check:

   Model function + curve_fit + plot = correct approach [OK]

Hint: Always define model function before curve_fit and plot results [OK]

Common Mistakes:

• Passing np.sin directly without parameters
• Skipping model function definition
• Not storing or using fitted parameters for plotting