Combinate is a sweep-specific Python SDK for teams that already have a model. Validate locally, run a bounded parameter sweep in the cloud, and get structured results back without building your own batch glue.
python -m pip install combinate==0.1.0rc2
from combinate import local_sweep, sweep
from combinate import local_sweep, sweep def simulate(alpha, beta): return {"score": alpha * beta} local = local_sweep( simulate, params={ "alpha": [0.1, 0.2, 0.3], "beta": [4, 8, 16], }, method="grid", )
cloud = sweep( simulate, params={ "alpha": [0.1, 0.2, 0.3], "beta": [4, 8, 16], }, method="grid", ) # same function, same params best = cloud.succeeded_tasks[0] print(best.inline_output)
Then they turn into brittle scripts, ad hoc multiprocessing, overnight runs, and CSV sprawl. Combinate keeps the model in Python while adding governed execution and supportable result retrieval when the study outgrows one machine.
Watch what happens after submission: Combinate validates the run, fans work out to cloud workers, reports progress, and returns structured results without babysitting queues or infrastructure.
from combinate import local_sweep, sweep def simulate_motor(kp, ki, notch_freq): return {"cost": kp * 0.4 + ki * 0.7} params = {"kp": [1.0, 2.0, 3.0], "ki": [0.1, 0.2], "notch_freq": [120, 180]} local = local_sweep(simulate_motor, params=params, method="grid") cloud = sweep(simulate_motor, params=params, method="grid") best = cloud.succeeded_tasks[0].inline_output
Keep the model in Python, scale only when you need to, and get structured results back in the same workflow. Agent-assisted setups fit naturally because execution stays bounded, inspectable, and replayable.
Keep simulation code and analysis logic in normal Python functions. Use local_sweep() to validate shape, outputs, and sweep behavior before scaling up.
Switch to hosted execution when the run is too large, too slow, or too expensive for one machine. Combinate handles fan-out, execution limits, and infrastructure details.
Sweep IDs, task records, and result artifacts come back as Python objects. Inspect, replay, or extend any run from the SDK or dashboard without losing the experimental trail.
One Python interface, three fundamentally different ways to explore a parameter space. Pick the one that fits the problem, then change it with a single field.
sweep( simulate, params={ "lr": [1e-4, 1e-3, 1e-2], "layers": [2, 4, 8], }, sampling_spec={ "method": "grid", }, )
sweep( simulate, params={ "alpha": {"type": "range", "min": 0.01, "max": 10.0, "scale": "log"}, "mode": ["fast", "precise"], }, sampling_spec={ "method": "random", "sampler": "sobol", # or halton, latin_hypercube "samples": 64, "seed": 42, }, )
sweep( simulate, params={ "lr": {"type": "range", "min": 1e-5, "max": 0.1}, "arch": ["resnet", "vit", "mlp"], }, sampling_spec={ "method": "genetic", "objective_metric": "val_acc", "objective_goal": "maximize", "population_size": 8, "max_generations": 5, "mutation_rate": 0.2, }, )
These representative scenarios show where parameter sweeps become painful: nested loops stop being manageable, individual evaluations take too long, or a thousand runs need to finish without tying up one machine overnight.
params = {
"staging_ratio": [0.08, 0.10, 0.12, 0.14, 0.16],
"isp_s1": [280, 296, 312, 328, 344, 360],
"pitch_rate": [1.0, 1.5, 2.0, 2.5],
"payload_fraction": [0.03, 0.035, 0.04, 0.045, 0.05, 0.055],
}
params = {
"vol_shift": {"type": "range", "min": -0.3, "max": 0.3},
"rate_shock_bp": [-100, -50, 0, 50, 100],
"horizon_days": [1, 5, 10],
}
sampling_spec = {
"method": "random",
"sampler": "sobol",
"samples": 80,
"seed": 99,
}
params = {
"kp": [0.5, 2.0, 4.0, 8.0, 12.0],
"ki": [0.0, 0.5, 1.0, 1.5, 2.0],
"kd": [0.0, 0.1, 0.2, 0.4, 0.8],
"damping": [0.6, 0.7, 0.8, 0.9, 1.0],
"notch_freq": [120, 180, 240, 300, 360],
}
sampling_spec = {
"method": "genetic",
"objective_metric": "cost",
"objective_goal": "minimize",
"population_size": 8,
"max_generations": 80,
}
The first cohort is for engineers and analytical teams who already have Python models and want a repeatable path from local studies to cloud sweeps.
Each piece answers one concrete question about where Combinate fits and why a governed sweep is different from generic parallelism.
The exact behavioral difference between a local study and a governed sweep, with real code.
Use a familiar library adjacency to understand where Combinate adds operational value.
See where Combinate fits relative to Ray, Dask, Prefect, Joblib, and optimization libraries without vague platform language.