modules.applications.optimization.salbp.salbp.SALBP

class SALBP

Bases: Optimization

The Simple Assembly Line Balancing Problem (SALBP) is a special bin packing problem with precedence relations among the items. Given a set of tasks, each with a processing time, precedence relations among those tasks, and a cycle time, this problem's goal is to assign every task to a station s.t. the total number of stations is minimized while the cycle time per station and the task precedences are respected. This version of the SALBP is commonly referred to as version 1 (SALBP-1) in the literature.

The SALBP-1 finds applications in manufacturing, logistics, and industrial automation, where optimizing assembly line operations can significantly enhance efficiency and cost-effectiveness. By balancing workloads across stations, industries can minimize idle time, reduce bottlenecks, and improve overall productivity.

This problem is especially relevant in automobile production, electronics assembly, and large-scale manufacturing, where tasks must follow strict precedence relations, meaning some tasks must be completed before others can begin.

__init__()

Constructor method

Methods

__init__()	Constructor method
evaluate(solution)	Determine objective value of the solution, i.e., the number of used stations.
generate_problem(config, **kwargs)	Generate an SALBP-1 instance using the input configuration.
get_application()	Gets the application.
get_available_submodule_options()	Gets the list of available options.
get_available_submodules(option)	If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.
get_default_submodule(option)	Returns the default submodule based on the provided option.
get_depending_parameters(option, config)	If the module has parameters depending on certain options, this method should return the parameters for the given option.
get_parameter_options()	Return the configurable settings for this application.
get_requirements()	Returns the required pip packages for this module.
get_solution_quality_unit()	Return the measurement unit for solution quality.
get_submodule(option)	Submodule is instantiated according to the information given in self.sub_options.
postprocess(input_data, config, **kwargs)	For optimization problems, we process the solution here, then validate and evaluate it.
preprocess(input_data, config, **kwargs)	For optimization problems, we generate the actual problem instance in the preprocess function.
process_solution(solution)	Most of the time the solution has to be processed before it can be validated and evaluated.
save(path, iter_count)	Saves the concrete problem.
validate(solution)	Validate if a given solution is feasible for the problem instance.
visualize_solution(processed_solution, path)	Creates visualizations of a processed and validated solution and writes them to disk.

class Config

Bases: TypedDict

Attributes of a valid config.

clear() → None.  Remove all items from D.

copy() → a shallow copy of D

fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values

evaluate(solution: dict[int, list[Task]]) → tuple[float, float]

Determine objective value of the solution, i.e., the number of used stations.

Parameters:

solution -- The task assignment

Returns:

Objective value, time it took to evaluate

generate_problem(config: Config, **kwargs) → SALBPInstance

Generate an SALBP-1 instance using the input configuration.

Parameters:

config -- Configuration settings

Returns:

Generated SALBP-1 instance

get_application() → any

Gets the application.

Returns:

self.application

get_available_submodule_options() → list

Gets the list of available options.

Returns:

List of module options

get_available_submodules(option: list) → list

If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.

Parameters:

option -- List of chosen options

Returns:

List of available submodules

get_default_submodule(option: str) → Core

Returns the default submodule based on the provided option.

Parameters:

option -- The submodule option.

Returns:

The corresponding submodule instance.

Raises:

NotImplementedError -- If the option is not recognized.

get_depending_parameters(option: str, config: dict) → dict

If the module has parameters depending on certain options, this method should return the parameters for the given option.

Parameters:

• option -- The chosen option

• config -- Current config dictionary

Returns:

The parameters for the given option

get_parameter_options() → dict

Return the configurable settings for this application.

Returns:

Dictionary containing parameter options

return {
    "instance": {
        "values": list(
            [
                "example_instance_n=3.alb",
                "example_instance_n=5.alb",
                "example_instance_n=10.alb",
                "example_instance_n=20.alb",
            ]
        ),
        "description": "Which SALBP-1 instance do you want to solve?",
    },
}

static get_requirements() → list

Returns the required pip packages for this module. Optionally, version requirements can be added.

Returns:

List of dictionaries

get_solution_quality_unit() → str

Return the measurement unit for solution quality.

Returns:

The unit as a string

get_submodule(option: str) → Core

Submodule is instantiated according to the information given in self.sub_options. If self.sub_options is None, get_default_submodule is called as a fallback.

Parameters:

option -- String with the options

Returns:

Instance of a module

postprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

For optimization problems, we process the solution here, then validate and evaluate it.

Parameters:

• input_data -- Data which should be evaluated for this optimization problem

• config -- Config for the problem creation

• kwargs -- Optional additional arguments

Returns:

Tuple with results and the postprocessing time

preprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

For optimization problems, we generate the actual problem instance in the preprocess function.

Parameters:

• input_data -- Input data (usually not used in this method)

• config -- Config for the problem creation

• kwargs -- Optional additional arguments

Returns:

Tuple with output and the preprocessing time

process_solution(solution: any) → tuple[any, float]

Most of the time the solution has to be processed before it can be validated and evaluated. This might not be necessary in all cases, so the default is to return the original solution.

Parameters:

solution -- Proposed solution

Returns:

Tuple with processed solution and the execution time to process it

save(path: str, iter_count: int) → None

Saves the concrete problem.

Parameters:

• path -- Path of the experiment directory for this run

• iter_count -- The iteration count

validate(solution: dict[int, list[Task]]) → tuple[bool, float]

Validate if a given solution is feasible for the problem instance.

Parameters:

solution -- The task assignment

Returns:

Whether the solution is valid, time it took to validate

visualize_solution(processed_solution: any, path: str) → None

Creates visualizations of a processed and validated solution and writes them to disk. Override if applicable. Default is to do nothing.

Parameters:

• processed_solution -- A solution that was already processed by process_solution()

• path -- File path for the plot

Returns:

None