ValueError: The requested array has an inhomogeneous shape after 1 dimensions

[KashyapCKotak]

When passing the below bounds to Optimizer and then running it via optimizer.run...

bounds=[(-1.0, 1.0), (-3, -1, 1, 2)]
(here first dimension is real and signifies a range, while the second dimension in categorical)

I get the below error:

ValueError: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.

This error originates in the _check_bounds method on bounds = np.asarray(bounds) line.

As per the docs:

A more elaborate example, minimizing an objective function of three variables: one integral, one real, and one nominal variable.

bounds = [
(0, 100), # From zero to at most roses per day
(.5, 9.), # Price per rose sold
(10, 20, 100), # Advertising budget
]

[kernc]

As per the docs:

A more elaborate example

Note, this is the docs for high-level optimization function minimize(), and it's correct. 👍

For class Optimizer, however, bounds are primitive float ranges:

sambo/sambo/_smbo.py

Lines 41 to 42 in ec782cc

	bounds : list[tuple], optional
	Bounds for the decision variables. A sequence of (min, max) pairs for each dimension.

Function minimize passes bounds through Space, which does the transforming:

sambo/sambo/_space.py

Lines 81 to 131 in ec782cc

	def transform(self, X):
	"""Transofrm X from user's original space to our representation (floats)."""
	if self._encoders:
	X = np.array(X, dtype=object) # Make a copy!
	is_single_row = X.ndim == 1
	X = np.atleast_2d(X)
	for i, encoder in self._encoders.items():
	X[:, i] = encoder.transform(X[:, i])
	if is_single_row:
	X = X[0]
	return X
	def _label_categorical(self, col, value, *tick_pos):
	assert col in self._encoders, (col, self._encoders)
	assert isinstance(value, Integral) or int(value) == value, (col, value)
	return self._encoders[col].inverse_transform(int(value))
	def inverse_transform(self, X: np.ndarray) -> np.ndarray:
	"""Transform our float-only representation to user's original space."""
	if self._is_all_floats: # Fast path for the common case
	return np.clip(X, *self._bounds.T)
	# TODO: Use structured dtype instead?
	# dtype = [(str if dtype is object else dtype).__name__
	# for i, (dtype, values) in enumerate(self._bounds)]
	# X = X.astype(', '.join(dtype))
	X = np.asarray(X, dtype=object)
	is_single_row = X.ndim == 1
	X = np.atleast_2d(X)
	assert X.ndim == 2, X
	# TODO remove all np.clip as no longer required
	for i in self._object_dtypes:
	X[:, i] = self._encoders[i].inverse_transform(self._round_values(X[:, i]))
	if (inds := self._int_dtypes).size:
	bounds = self._bounds[inds].T
	X[:, inds] = self._round_values(np.clip(X[:, inds], *bounds))
	if (inds := self._float_dtypes).size:
	bounds = self._bounds[inds].T
	X[:, inds] = np.clip(X[:, inds], *bounds)
	return X[0] if is_single_row else X
	def inverse_transform_result(self, res: OptimizeResult) -> OptimizeResult:
	return OptimizeResult(
	res,
	x=self.inverse_transform(res.x),
	xv=self.inverse_transform(res.xv),
	)

You could maybe get away with calling Optimizer(bounds=Space(bounds), ...), but notice sambo._space.Space is private API.

Alternatively, you would have to encode your categoricals (-3, -1, 1, 2) into [0, 1, 2, 3] and pass Optimizer(bounds=[(-1.0, 1.0), (0, 4)], ...), and then do the rounding and inverse transform manually. 🤷‍♂️

If stumbled upon, a PR that makes Optimizer additionally support categorical bounds= via Space would be appreciated.

[KashyapCKotak]

@kernc Is rounding needed? will optimizer not generate integer values if bound (0,4) is passed? I am noticing values that it generates are floating point fractions.

Won't it take more iterations for it to reach to the optimal values as it would generate multiple floating point values to explore the result space but those will be mapped to the same integer value. Also the integer values would change in rounding in 3.4 vs 3.5. Not sure if that would effect the overall number of tries taken to reach to the optimal value.

I am not very much experienced in large python projects, but will definitely try to add support for Space in Optimizer.

[kernc]

Won't it take more iterations for it to reach to the optimal values as it would generate multiple floating point values to explore the result space but those will be mapped to the same integer value. Also the integer values would change in rounding in 3.4 vs 3.5. Not sure if that would effect the overall number of tries taken to reach to the optimal value.

That's my intuition too. Sadly, I'm not sure what we can do about it. I personally like the generality of working just with floats since ℕ⊂ℝ. On the other hand, the range (0, 4) can be equidistantly split with about four points. Assuming the initial sampling is sufficiently numerous and balanced, this will cover all our integers. Our optimization results remain competitive. If you look into it and get a better idea, welcome!

large python projects

At ~3.3k lines of Python code, SAMBO is by no means a large project! 😅🙏