scipy-curve-fit — Claude Code skill: what it does, how to install
scipy-curve-fit guides coding agents to estimate nonlinear model parameters from experimental data with scipy.optimize.curve_fit.
Apache-2.0 2 installs ★ 1,933 updated 2026-10-24
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a claude-codeWhat scipy-curve-fit does
The skill provides reference implementations for nonlinear least squares parameter estimation in Python. It details how to set up scipy.optimize.curve_fit, configure parameter bounds, and choose initial guesses p0 to speed up convergence.
It focuses on fitting first-order step response models. The agent learns how to extract gain K and time constant tau, while evaluating fit quality through R-squared and root mean square error calculations.
Without scipy and numpy in the environment, the generated scripts fail immediately. If input measurements contain NaN values or poor initial guesses, the solver terminates with a RuntimeError.
What it helps with
- Estimate parameters for nonlinear models using experimental test data
- Define parameter bounds and initial guesses for
curve_fit - Fit first-order step response models to identify gain
Kand time constanttau - Evaluate fitting accuracy using R-squared and RMSE metrics
Example prompts for the agent
- Fit a first-order step response to experimental time and output arrays using scipy.optimize.curve_fit
- Set initial guesses p0 and parameter bounds to prevent unrealistic values in curve_fit
- Calculate R-squared and RMSE metrics for my fitted model predictions
How to install scipy-curve-fit
1Skills CLI (Vercel)
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a claude-code2Manually: put the files in place
~/.claude/skills/scipy-curve-fit/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/scipy-curve-fit/
1Skills CLI (Vercel)
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a codex2Manually: put the files in place
.agents/skills/scipy-curve-fit/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a cursor2Manually: put the files in place
.cursor/skills/scipy-curve-fit/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install benchflow-ai/skillsbench tasks/hvac-control/environment/skills/scipy-curve-fit2Manually: put the files in place
.github/skills/scipy-curve-fit/SKILL.md1Skills CLI (Vercel)
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a gemini-cli2Platform CLI
gemini skills install https://github.com/benchflow-ai/skillsbench --path tasks/hvac-control/environment/skills/scipy-curve-fitManually: put the files in place
.devin/skills/scipy-curve-fit/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about scipy-curve-fit
How do I install scipy-curve-fit in Claude Code?
Run npx skills add benchflow-ai/skillsbench --skill scipy-curve-fit -a claude-code in your terminal. This creates the skill file at ~/.claude/skills/scipy-curve-fit/SKILL.md.
What does scipy-curve-fit do?
It teaches coding agents how to perform nonlinear least squares optimization using scipy.optimize.curve_fit. It includes templates for step response identification, constraints, and error metrics.
Why does curve_fit raise a RuntimeError?
This indicates that the optimization algorithm failed to converge. Supply closer initial values p0 and ensure your dataset has no missing or NaN entries.
Source text
SKILL.md · Apache-2.0
---
name: scipy-curve-fit
description: Use scipy.optimize.curve_fit for nonlinear least squares parameter estimation from experimental data.
---
# Using scipy.optimize.curve_fit for Parameter Estimation
## Overview
`scipy.optimize.curve_fit` is a tool for fitting models to experimental data using nonlinear least squares optimization.
## Basic Usage
```python
from scipy.optimize import curve_fit
import numpy as np
# Define your model function
def model(x, param1, param2):
return param1 * (1 - np.exp(-x / param2))
# Fit to data
popt, pcov = curve_fit(model, x_data, y_data)
# popt contains the optimal parameters [param1, param2]
# pcov contains the covariance matrix
```
## Fitting a First-Order Step Response
```python
import numpy as np
from scipy.optimize import curve_fit
# Known values from experiment
y_initial = ... # Initial output value
u = ... # Input magnitude during step test
# Define the step response model
def step_response(t, K, tau):
"""First-order step response with fixed initial value and input."""
return y_initial + K * u * (1 - np.exp(-t / tau))
# Your experimental data
t_data = np.array([...]) # Time points
y_data = np.array([...]) # Output readings
# Perform the fit
popt, pcov = curve_fit(
step_response,
t_data,
y_data,
p0=[K_guess, tau_guess], # Initial guesses
bounds=([K_min, tau_min], [K_max, tau_max]) # Parameter bounds
)
K_estimated, tau_estimated = popt
```
## Setting Initial Guesses (p0)
Good initial guesses speed up convergence:
```python
# Estimate K from steady-state data
K_guess = (y_data[-1] - y_initial) / u
# Estimate tau from 63.2% rise time
y_63 = y_initial + 0.632 * (y_data[-1] - y_initial)
idx_63 = np.argmin(np.abs(y_data - y_63))
tau_guess = t_data[idx_63]
p0 = [K_guess, tau_guess]
```
## Setting Parameter Bounds
Bounds prevent physically impossible solutions:
```python
bounds = (
[lower_K, lower_tau], # Lower bounds
[upper_K, upper_tau] # Upper bounds
)
```
## Calculating Fit Quality
### R-squared (Coefficient of Determination)
```python
# Predicted values from fitted model
y_predicted = step_response(t_data, K_estimated, tau_estimated)
# Calculate R-squared
ss_residuals = np.sum((y_data - y_predicted) ** 2)
ss_total = np.sum((y_data - np.mean(y_data)) ** 2)
r_squared = 1 - (ss_residuals / ss_total)
```
### Root Mean Square Error (RMSE)
```python
residuals = y_data - y_predicted
rmse = np.sqrt(np.mean(residuals ** 2))
```
## Complete Example
```python
import numpy as np
from scipy.optimize import curve_fit
def fit_first_order_model(data, y_initial, input_value):
"""
Fit first-order model to step response data.
Returns dict with K, tau, r_squared, fitting_error
"""
t_data = np.array([d["time"] for d in data])
y_data = np.array([d["output"] for d in data])
def model(t, K, tau):
return y_initial + K * input_value * (1 - np.exp(-t / tau))
# Initial guesses
K_guess = (y_data[-1] - y_initial) / input_value
tau_guess = t_data[len(t_data)//3] # Rough guess
# Fit with bounds
popt, _ = curve_fit(
model, t_data, y_data,
p0=[K_guess, tau_guess],
bounds=([0, 0], [np.inf, np.inf])
)
K, tau = popt
# Calculate quality metrics
y_pred = model(t_data, K, tau)
ss_res = np.sum((y_data - y_pred) ** 2)
ss_tot = np.sum((y_data - np.mean(y_data)) ** 2)
r_squared = 1 - (ss_res / ss_tot)
fitting_error = np.sqrt(np.mean((y_data - y_pred) ** 2))
return {
"K": float(K),
"tau": float(tau),
"r_squared": float(r_squared),
"fitting_error": float(fitting_error)
}
```
## Common Issues
1. **RuntimeError**: Optimal parameters not found
- Try better initial guesses
- Check that data is valid (no NaN, reasonable range)
2. **Poor fit (low R^2)**:
- Data might not be from step response phase
- System might not be first-order
- Too much noise in measurements
3. **Unrealistic parameters**:
- Add bounds to constrain solution
- Check units are consistent
© benchflow-ai · Apache-2.0 · benchflow-ai/skillsbench