def ub(self, ub):
if not isinstance(ub, np.ndarray):
raise e.TypeError('`ub` should be a numpy array')
if ub.shape[0] != self.n_variables:
raise e.SizeError('`ub` should be the same size as `n_variables`')
self._ub = ub
def test_exception_size_error():
new_exception = exception.SizeError("error")
try:
raise new_exception
except exception.SizeError:
pass
def lb(self, lb):
if not isinstance(lb, np.ndarray):
raise e.TypeError('`lb` should be a numpy array')
if lb.shape[0] != self.n_variables:
raise e.SizeError('`lb` should be the same size as `n_variables`')
self._lb = lb
def get(self, key, index):
"""Gets the desired key based on the input index.
Args:
key (str): Key's name to be retrieved.
index (tuple): A tuple indicating which indexes should be retrieved.
Returns:
All key's values based on the input index.
Note that this method returns all records, i.e., all values from the `t` iterations.
"""
# Checks if index is a tuple
if not isinstance(index, tuple):
raise e.TypeError('`index` should be a tuple')
# Gathers the numpy array from the attribute
attr = np.asarray(getattr(self, key))
# Checks if attribute's dimensions are equal to the length of input index
# We use `- 1` as the method retrieves values from all iterations
if attr.ndim - 1 != len(index):
raise e.SizeError(
f'`index` = {len(index)} should have one less dimension than `key` = {attr.ndim}')
# Slices the array based on the input index
# Again, slice(None) will retrieve values from all iterations
attr = attr[(slice(None),) + index]
# We use hstack to horizontally concatenate the axis,
# allowing an easier input to the visualization package
attr = np.hstack(attr)
return attr
def test_size_error():
new_exception = exception.SizeError('error')
try:
raise new_exception
except exception.SizeError:
pass
def weights(self, weights):
if not isinstance(weights, list):
raise e.TypeError('`weights` should be a list')
if len(weights) != len(self.functions):
raise e.SizeError(
'`weights` should have the same size of `functions`')
self._weights = weights
def weights(self, weights: List[float]) -> None:
if not isinstance(weights, list):
raise e.TypeError("`weights` should be a list")
if len(weights) != len(self.functions):
raise e.SizeError(
"`weights` should have the same size of `functions`")
self._weights = weights
def plot(
*args,
labels: Optional[List[str]] = None,
title: Optional[str] = "",
subtitle: Optional[str] = "",
xlabel: Optional[str] = "iteration",
ylabel: Optional[str] = "value",
grid: Optional[bool] = True,
legend: Optional[bool] = True,
) -> None:
"""Plots the convergence graph of desired variables.
Essentially, each variable is a list or numpy array
with size equals to `n_iterations`.
Args:
labels: Labels to be applied for each plot in legend.
title: Title of the plot.
subtitle: Subtitle of the plot.
xlabel: Axis `x` label.
ylabel: Axis `y` label.
grid: If grid should be used or not.
legend: If legend should be displayed or not.
"""
# Creates the figure and axis subplots
_, ax = plt.subplots(figsize=(7, 5))
# Defines some properties, such as labels, title and subtitle
ax.set(xlabel=xlabel, ylabel=ylabel)
ax.set_title(title, loc="left", fontsize=14)
ax.set_title(subtitle, loc="right", fontsize=8, color="grey")
if grid:
ax.grid()
if labels:
# Checks a set of pre-defined `labels` conditions
if not isinstance(labels, list):
raise e.TypeError("`labels` should be a list")
if len(labels) != len(args):
raise e.SizeError("`args` and `labels` should have the same size")
else:
# Creates pre-defined `labels`
labels = [f"variable_{i}" for i in range(len(args))]
# Plots every argument
for (arg, label) in zip(args, labels):
ax.plot(arg, label=label)
if legend:
ax.legend()
# Displays the plot
plt.show()
def ub(self, ub: np.ndarray) -> None:
if not isinstance(ub, np.ndarray):
raise e.TypeError("`ub` should be a numpy array")
if not ub.shape:
ub = np.expand_dims(ub, -1)
if not ub.shape or ub.shape[0] != self.n_variables:
raise e.SizeError("`ub` should be the same size as `n_variables`")
self._ub = ub
def lb(self, lb: np.ndarray) -> None:
if not isinstance(lb, np.ndarray):
raise e.TypeError("`lb` should be a numpy array")
if not lb.shape:
lb = np.expand_dims(lb, -1)
if lb.shape[0] != self.n_variables:
raise e.SizeError("`lb` should be the same size as `n_variables`")
self._lb = lb
def mapping(self, mapping: List[str]) -> None:
if mapping is not None:
if not isinstance(mapping, list):
raise e.TypeError("`mapping` should be a list")
if len(mapping) != self.n_variables:
raise e.SizeError("`mapping` should be the same size as `n_variables`")
self._mapping = mapping
else:
self._mapping = [f"x{i}" for i in range(self.n_variables)]
def plot(*args, labels=None, title='', subtitle='', grid=True, legend=True):
"""Plots the convergence graph of desired variables.
Essentially, each variable is a list or numpy array
with size equals to (iterations x 1).
Args:
labels (list): Labels to be applied for each plot in legend.
title (str): The title of the plot.
subtitle (str): The subtitle of the plot.
grid (bool): If grid should be used or not.
legend (bool): If legend should be displayed or not.
"""
# Creating figure and axis subplots
fig, ax = plt.subplots(figsize=(7, 5))
# Defining some properties, such as axis labels
ax.set(xlabel='iteration', ylabel='value')
# Setting both title and subtitles
ax.set_title(title, loc='left', fontsize=14)
ax.set_title(subtitle, loc='right', fontsize=8, color='grey')
# If grid usage is true
if grid:
# Adds the grid property to the axis
ax.grid()
# Check if labels argument exists
if labels:
# Also check if it is a list
if not isinstance(labels, list):
raise e.TypeError('`labels` should be a list')
# And check if it has the same size of arguments
if len(labels) != len(args):
raise e.SizeError('`args` and `labels` should have the same size')
# If labels argument does not exists
else:
# Creates a list with indicators
labels = [f'variable_{i}' for i in range(len(args))]
# Plotting the axis
for (arg, label) in zip(args, labels):
ax.plot(arg, label=label)
# If legend usage is true
if legend:
# Adds the legend property to the axis
ax.legend()
# Displaying the plot
plt.show()
def plot(*args, labels=None, title='', subtitle='', xlabel='iteration', ylabel='value',
grid=True, legend=True):
"""Plots the convergence graph of desired variables.
Essentially, each variable is a list or numpy array
with size equals to `n_iterations`.
Args:
labels (list): Labels to be applied for each plot in legend.
title (str): Title of the plot.
subtitle (str): Subtitle of the plot.
xlabel (str): Axis `x` label.
ylabel (str): Axis `y` label.
grid (bool): If grid should be used or not.
legend (bool): If legend should be displayed or not.
"""
# Creates the figure and axis subplots
_, ax = plt.subplots(figsize=(7, 5))
# Defines some properties, such as labels, title and subtitle
ax.set(xlabel=xlabel, ylabel=ylabel)
ax.set_title(title, loc='left', fontsize=14)
ax.set_title(subtitle, loc='right', fontsize=8, color='grey')
# If grid usage is `True`
if grid:
# Adds the grid property to the axis
ax.grid()
# Checks if `labels` really exists
if labels:
# Checks a set of pre-defined `labels` conditions
if not isinstance(labels, list):
raise e.TypeError('`labels` should be a list')
if len(labels) != len(args):
raise e.SizeError('`args` and `labels` should have the same size')
# If `labels` do not exists
else:
# Creates pre-defined `labels`
labels = [f'variable_{i}' for i in range(len(args))]
# Plots every argument
for (arg, label) in zip(args, labels):
ax.plot(arg, label=label)
# If legend usage is `True`
if legend:
# Adds the legend property to the axis
ax.legend()
# Displays the plot
plt.show()
def step(self, step: np.ndarray) -> None:
if not isinstance(step, np.ndarray):
raise e.TypeError("`step` should be a numpy array")
if not step.shape:
step = np.expand_dims(step, -1)
if step.shape[0] != self.n_variables:
raise e.SizeError(
"`step` should be the same size as `n_variables`")
self._step = step
def compile(self, space):
"""Compiles additional information that is used by this optimizer.
Args:
space (Space): A Space object containing meta-information.
"""
# Checks if supplied number of agents has a perfect square
if not np.sqrt(space.n_agents).is_integer():
raise e.SizeError('`n_agents` should have a perfect square')
def fill_with_static(self, values: np.ndarray) -> None:
"""Fills the agent's decision variables with static values. Note that this
method ignore the agent's bounds, so use it carefully.
Args:
values: Values to be filled.
"""
# Makes sure that `values` is a numpy array
# and has the same size of `n_variables`
values = np.asarray(values)
if not values.shape:
values = np.expand_dims(values, -1)
if values.shape[0] != self.n_variables:
raise e.SizeError("`values` should be the same size as `n_variables`")
# Iterates through all the decision variables
for j, value in enumerate(values):
# Fills the array based on a static value
self.position[j] = value
