Brandon Rohrer

Working examples for redsho hyperparameter optimization

Wed, 30 Sep 2026 04:36:00 EDT

I recently published the redsho package for hyperparameter optimization. More than anything, I want it to be useful. I find it helpful to start with a working example. To this end I created a second repo called redsho-examples that walks through how to do it.

Usage

Start with an evaluation function that takes some hyperparameters as keyword arguments.


def evaluate(*, a, b, c):
    return a * b**3 % c

(The leading * tells Python that everything that follows is a required keyword argument.)

Build a collection of values to try for each parameter.


values = {
    "a": [4, 7, 9],
    "b": [2, 5, 6],
    "c": [5, 8, 11],
}

Call the optimizer.


from redsho.optimizer import optimize

error, params = optimize(evaluate, values)

where error is the lowest error achieved, and params is the collection of parameter values that achieved it.

Examples

As of right now, there are 4 examples, each in their own subdirectory:

sinc: optimizes a 2D variant of the sinc function, sin(x)/x
perf: tests the execution time bottleneck in redsho and helps to streamline it
xgboost_regression: optimizes an XGBoost regression model across a wide variety of hyperparameters and options
xgboost_multiclass: same as the previous example, but with a multiclass classification problem

If you generate any examples of your own that you're comfortable sharing, we can add them to the list. :)

Required keyword args in Python

Tue, 29 Sep 2026 04:36:00 EDT

Cool Python trick I learned: Sometimes you want functions to have keyword arguments, but you also want them to be required. This is especially useful when you're passing required arguments using dictionary expansion, like function(**arg_dict).

I always did this by setting all the parameter keyword defaults to None, then checking for any None values in the function. But there's a better way: using the bare * in the argument list. Everything after the asterisk will be a required keyword argument.

This means that now when I write

def sum(*, a=None, b=None):
	return a + b

I no longer have to check that a and b are not None in the function, and I can call it with

arg_dict = {'a': 4, 'b': 9}
print(sum(**arg_dict))

You can still put positional and optional keywords before the asterisk.


def estimate(a, b, verbose=False, *, method=None, n_iter=None):
    ...

It doesn't matter what default value these required kwargs get because it will always be overwritten.

redsho: a robust hyperparameter optimizer

Mon, 28 Sep 2026 06:36:00 EDT

Optimizing models with lots of hyperparameters or functions with many options is a slog that usually requires a combination community wisdom, obscure blog posts, and tedious trial and error. Automated methods tend to either rely on strong assumptions of smoothness or brute force their way through every permutation. All of these options kind of suck.

I took a swing at an alternative approach called redsho. It takes a middle ground approach for when the effects of parameters and options can be wildly non-linear and exhaustive grid search would take longer than we want to spend. A full description of how it works takes a post of its own, but its distinguishing feature is that it is evolutionary in nature. It looks through the parameter combinations it has tried already and picks one randomly, leaning heavily toward the best performers. Then it chooses one of the parameters in its collection and tries a few random values that it hasn't tried before. This process is reflected in the full name: Robust Evolutionary Direction Set Hyperparameter Optimizer.

Check out the repo).