Introduction

MEALPY is the largest python library in the world for most of the cutting-edge meta-heuristic algorithms (nature-inspired algorithms, black-box optimization, global search optimizers, iterative learning algorithms, continuous optimization, derivative free optimization, gradient free optimization, zeroth order optimization, stochastic search optimization, random search optimization). These algorithms belong to population-based algorithms (PMA), which are the most popular algorithms in the field of approximate optimization.

• Free software: GNU General Public License (GPL) V3 license
• Total algorithms: 215 (190 official (original, hybrid, variants), 25 developed)
• Documentation: https://mealpy.readthedocs.io/en/latest/
• Python versions: >=3.7x
• Dependencies: numpy, scipy, pandas, matplotlib

Citation Request

Please include these citations if you plan to use this library:

@article{van2023mealpy,
  title={MEALPY: An open-source library for latest meta-heuristic algorithms in Python},
  author={Van Thieu, Nguyen and Mirjalili, Seyedali},
  journal={Journal of Systems Architecture},
  year={2023},
  publisher={Elsevier},
  doi={10.1016/j.sysarc.2023.102871}
}

@article{van2023groundwater,
  title={Groundwater level modeling using Augmented Artificial Ecosystem Optimization},
  author={Van Thieu, Nguyen and Barma, Surajit Deb and Van Lam, To and Kisi, Ozgur and Mahesha, Amai},
  journal={Journal of Hydrology},
  volume={617},
  pages={129034},
  year={2023},
  publisher={Elsevier},
  doi={https://doi.org/10.1016/j.jhydrol.2022.129034}
}

@article{ahmed2021comprehensive,
  title={A comprehensive comparison of recent developed meta-heuristic algorithms for streamflow time series forecasting problem},
  author={Ahmed, Ali Najah and Van Lam, To and Hung, Nguyen Duy and Van Thieu, Nguyen and Kisi, Ozgur and El-Shafie, Ahmed},
  journal={Applied Soft Computing},
  volume={105},
  pages={107282},
  year={2021},
  publisher={Elsevier},
  doi={10.1016/j.asoc.2021.107282}
}

Usage

Examples

Before dive into some examples, let me ask you a question. What type of problem are you trying to solve? Additionally, what would be the solution for your specific problem? Based on the table below, you can select an appropriate type of decision variables to use.

Let's go through a basic and advanced example.

Simple Benchmark Function

Using Problem dict

from mealpy import FloatVar, SMA
import numpy as np

def objective_function(solution):
    return np.sum(solution**2)

problem = {
    "obj_func": objective_function,
    "bounds": FloatVar(lb=(-100., )*30, ub=(100., )*30),
    "minmax": "min",
    "log_to": None,
}

## Run the algorithm
model = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)
g_best = model.solve(problem)
print(f"Best solution: {g_best.solution}, Best fitness: {g_best.target.fitness}")

Define a custom Problem class

Please note that, there is no more generate_position, amend_solution, and fitness_function in Problem class. We take care everything under the DataType Class above. Just choose which one fit for your problem. We recommend you define a custom class that inherit Problem class if your decision variable is not FloatVar

from mealpy import Problem, FloatVar, BBO 
import numpy as np

# Our custom problem class
class Squared(Problem):
    def __init__(self, bounds=None, minmax="min", data=None, **kwargs):
        self.data = data 
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, solution):
        x = self.decode_solution(solution)["my_var"]
        return np.sum(x ** 2)

## Now, we define an algorithm, and pass an instance of our *Squared* class as the problem argument. 
bound = FloatVar(lb=(-10., )*20, ub=(10., )*20, name="my_var")
problem = Squared(bounds=bound, minmax="min", name="Squared", data="Amazing")
model = BBO.OriginalBBO(epoch=100, pop_size=20)
g_best = model.solve(problem)

Set Seed for Optimizer (So many people asking for this feature)

You can set random seed number for each run of single optimizer.

model = SMA.OriginalSMA(epoch=100, pop_size=50, pr=0.03)
g_best = model.solve(problem=problem, seed=10)  # Default seed=None

Large-Scale Optimization

from mealpy import FloatVar, SHADE
import numpy as np

def objective_function(solution):
    return np.sum(solution**2)

problem = {
    "obj_func": objective_function,
    "bounds": FloatVar(lb=(-1000., )*10000, ub=(1000.,)*10000),     # 10000 dimensions
    "minmax": "min",
    "log_to": "console",
}

## Run the algorithm
optimizer = SHADE.OriginalSHADE(epoch=10000, pop_size=100)
g_best = optimizer.solve(problem)
print(f"Best solution: {g_best.solution}, Best fitness: {g_best.target.fitness}")

Distributed Optimization / Parallelization Optimization

Please read the article titled MEALPY: An open-source library for latest meta-heuristic algorithms in Python to gain a clear understanding of the concept of parallelization (distributed optimization) in metaheuristics. Not all metaheuristics can be run in parallel.

from mealpy import FloatVar, SMA
import numpy as np

def objective_function(solution):
    return np.sum(solution**2)

problem = {
    "obj_func": objective_function,
    "bounds": FloatVar(lb=(-100., )*100, ub=(100., )*100),
    "minmax": "min",
    "log_to": "console",
}

## Run distributed SMA algorithm using 10 threads
optimizer = SMA.OriginalSMA(epoch=10000, pop_size=100, pr=0.03)
optimizer.solve(problem, mode="thread", n_workers=10)        # Distributed to 10 threads
print(f"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}")

## Run distributed SMA algorithm using 8 CPUs (cores)
optimizer.solve(problem, mode="process", n_workers=8)        # Distributed to 8 cores
print(f"Best solution: {optimizer.g_best.solution}, Best fitness: {optimizer.g_best.target.fitness}")

The Benefit Of Using Custom Problem Class (BEST PRACTICE)

Optimize Machine Learning model

In this example, we use SMA optimize to optimize the hyper-parameters of SVC model.

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn import datasets, metrics

from mealpy import FloatVar, StringVar, IntegerVar, BoolVar, MixedSetVar, SMA, Problem

# Load the data set; In this example, the breast cancer dataset is loaded.
X, y = datasets.load_breast_cancer(return_X_y=True)

# Create training and test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)

sc = StandardScaler()
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.transform(X_test)

data = {
    "X_train": X_train_std,
    "X_test": X_test_std,
    "y_train": y_train,
    "y_test": y_test
}

class SvmOptimizedProblem(Problem):
    def __init__(self, bounds=None, minmax="max", data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        C_paras, kernel_paras = x_decoded["C_paras"], x_decoded["kernel_paras"]
        degree, gamma, probability = x_decoded["degree_paras"], x_decoded["gamma_paras"], x_decoded["probability_paras"]

        svc = SVC(C=C_paras, kernel=kernel_paras, degree=degree, 
                  gamma=gamma, probability=probability, random_state=1)
        # Fit the model
        svc.fit(self.data["X_train"], self.data["y_train"])
        # Make the predictions
        y_predict = svc.predict(self.data["X_test"])
        # Measure the performance
        return metrics.accuracy_score(self.data["y_test"], y_predict)

my_bounds = [
    FloatVar(lb=0.01, ub=1000., name="C_paras"),
    StringVar(valid_sets=('linear', 'poly', 'rbf', 'sigmoid'), name="kernel_paras"),
    IntegerVar(lb=1, ub=5, name="degree_paras"),
    MixedSetVar(valid_sets=('scale', 'auto', 0.01, 0.05, 0.1, 0.5, 1.0), name="gamma_paras"),
    BoolVar(n_vars=1, name="probability_paras"),
]
problem = SvmOptimizedProblem(bounds=my_bounds, minmax="max", data=data)
model = SMA.OriginalSMA(epoch=100, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")
print(f"Best solution: {model.g_best.solution}")
print(f"Best accuracy: {model.g_best.target.fitness}")
print(f"Best parameters: {model.problem.decode_solution(model.g_best.solution)}")

Solving Combinatorial Problems

Traveling Salesman Problem (TSP)

In the context of the Mealpy for the Traveling Salesman Problem (TSP), a solution is a possible route that represents a tour of visiting all the cities exactly once and returning to the starting city. The solution is typically represented as a permutation of the cities, where each city appears exactly once in the permutation.

For example, let's consider a TSP instance with 5 cities labeled as A, B, C, D, and E. A possible solution could be represented as the permutation [A, B, D, E, C], which indicates the order in which the cities are visited. This solution suggests that the tour starts at city A, then moves to city B, then D, E, and finally C before returning to city A.

import numpy as np
from mealpy import PermutationVar, WOA, Problem

# Define the positions of the cities
city_positions = np.array([[60, 200], [180, 200], [80, 180], [140, 180], [20, 160],
                           [100, 160], [200, 160], [140, 140], [40, 120], [100, 120],
                           [180, 100], [60, 80], [120, 80], [180, 60], [20, 40],
                           [100, 40], [200, 40], [20, 20], [60, 20], [160, 20]])
num_cities = len(city_positions)
data = {
    "city_positions": city_positions,
    "num_cities": num_cities,
}

class TspProblem(Problem):
    def __init__(self, bounds=None, minmax="min", data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    @staticmethod
    def calculate_distance(city_a, city_b):
        # Calculate Euclidean distance between two cities
        return np.linalg.norm(city_a - city_b)

    @staticmethod
    def calculate_total_distance(route, city_positions):
        # Calculate total distance of a route
        total_distance = 0
        num_cities = len(route)
        for idx in range(num_cities):
            current_city = route[idx]
            next_city = route[(idx + 1) % num_cities]  # Wrap around to the first city
            total_distance += TspProblem.calculate_distance(city_positions[current_city], city_positions[next_city])
        return total_distance

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        route = x_decoded["per_var"]
        fitness = self.calculate_total_distance(route, self.data["city_positions"])
        return fitness

bounds = PermutationVar(valid_set=list(range(0, num_cities)), name="per_var")
problem = TspProblem(bounds=bounds, minmax="min", data=data)

model = WOA.OriginalWOA(epoch=100, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}")      # Decoded (Real) solution

Job Shop Scheduling Problem Using Woa Optimizer

Note that this implementation assumes that the job times and machine times are provided as 2D lists, where job_times[i][j] represents the processing time of job i on machine j.

Keep in mind that this is a simplified implementation, and you may need to modify it according to the specific requirements and constraints of your Job Shop Scheduling problem.

import numpy as np
from mealpy import PermutationVar, WOA, Problem

job_times = [[2, 1, 3], [4, 2, 1], [3, 3, 2]]
machine_times = [[3, 2, 1], [1, 4, 2], [2, 3, 2]]

n_jobs = len(job_times)
n_machines = len(machine_times)

data = {
    "job_times": job_times,
    "machine_times": machine_times,
    "n_jobs": n_jobs,
    "n_machines": n_machines
}

class JobShopProblem(Problem):
    def __init__(self, bounds=None, minmax="min", data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["per_var"]
        makespan = np.zeros((self.data["n_jobs"], self.data["n_machines"]))
        for gene in x:
            job_idx = gene // self.data["n_machines"]
            machine_idx = gene % self.data["n_machines"]
            if job_idx == 0 and machine_idx == 0:
                makespan[job_idx][machine_idx] = job_times[job_idx][machine_idx]
            elif job_idx == 0:
                makespan[job_idx][machine_idx] = makespan[job_idx][machine_idx - 1] + job_times[job_idx][machine_idx]
            elif machine_idx == 0:
                makespan[job_idx][machine_idx] = makespan[job_idx - 1][machine_idx] + job_times[job_idx][machine_idx]
            else:
                makespan[job_idx][machine_idx] = max(makespan[job_idx][machine_idx - 1], makespan[job_idx - 1][machine_idx]) + job_times[job_idx][machine_idx]
        return np.max(makespan)

bounds = PermutationVar(valid_set=list(range(0, n_jobs*n_machines)), name="per_var")
problem = JobShopProblem(bounds=bounds, minmax="min", data=data)

model = WOA.OriginalWOA(epoch=100, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}")      # Decoded (Real) solution

Shortest Path Problem

In this example, the graph is represented as a NumPy array where each element represents the cost or distance between two nodes.

Note that this implementation assumes that the graph is represented by a symmetric matrix, where graph[i,j] represents the distance between nodes i and j. If your graph representation is different, you may need to modify the code accordingly.

Please keep in mind that this implementation is a basic example and may not be optimized for large-scale problems. Further modifications and optimizations may be required depending on your specific use case.

import numpy as np
from mealpy import PermutationVar, WOA, Problem

# Define the graph representation
graph = np.array([
    [0, 2, 4, 0, 7, 9],
    [2, 0, 1, 4, 2, 8],
    [4, 1, 0, 1, 3, 0],
    [6, 4, 5, 0, 3, 2],
    [0, 2, 3, 3, 0, 2],
    [9, 0, 4, 2, 2, 0]
])

class ShortestPathProblem(Problem):
    def __init__(self, bounds=None, minmax="min", data=None, **kwargs):
        self.data = data
        self.eps = 1e10         # Penalty function for vertex with 0 connection
        super().__init__(bounds, minmax, **kwargs)

    # Calculate the fitness of an individual
    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        individual = x_decoded["path"]

        total_distance = 0
        for idx in range(len(individual) - 1):
            start_node = individual[idx]
            end_node = individual[idx + 1]
            weight = self.data[start_node, end_node]
            if weight == 0:
                return self.eps
            total_distance += weight
        return total_distance

num_nodes = len(graph)
bounds = PermutationVar(valid_set=list(range(0, num_nodes)), name="path")
problem = ShortestPathProblem(bounds=bounds, minmax="min", data=graph)

model = WOA.OriginalWOA(epoch=100, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}")      # Decoded (Real) solution

Location Optimization

Let's consider an example of location optimization in the context of a retail company that wants to open a certain number of new stores in a region to maximize market coverage while minimizing operational costs.

A company wants to open five new stores in a region with several potential locations. The objective is to determine the optimal locations for these stores while considering factors such as population density and transportation costs. The goal is to maximize market coverage by locating stores in areas with high demand while minimizing the overall transportation costs required to serve customers.

By applying location optimization techniques, the retail company can make informed decisions about where to open new stores, considering factors such as population density and transportation costs. This approach allows the company to maximize market coverage, make efficient use of resources, and ultimately improve customer service and profitability.

Note that this example is a simplified illustration, and in real-world scenarios, location optimization problems can involve more complex constraints, additional factors, and larger datasets. However, the general process remains similar, involving data analysis, mathematical modeling, and optimization techniques to determine the optimal locations for facilities.

import numpy as np
from mealpy import BinaryVar, WOA, Problem

# Define the coordinates of potential store locations
locations = np.array([
    [2, 4],
    [5, 6],
    [9, 3],
    [7, 8],
    [1, 10],
    [3, 2],
    [5, 5],
    [8, 2],
    [7, 6],
    [1, 9]
])
# Define the transportation costs matrix based on the Euclidean distance between locations
distance_matrix = np.linalg.norm(locations[:, np.newaxis] - locations, axis=2)

# Define the number of stores to open
num_stores = 5

# Define the maximum distance a customer should travel to reach a store
max_distance = 10

data = {
    "num_stores": num_stores,
    "max_distance": max_distance,
    "penalty": 1e10
}

class LocationOptProblem(Problem):
    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):
        self.data = data
        self.eps = 1e10
        super().__init__(bounds, minmax, **kwargs)

    # Define the fitness evaluation function
    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["placement_var"]
        total_coverage = np.sum(x)
        total_dist = np.sum(x[:, np.newaxis] * distance_matrix)
        if total_dist == 0:                 # Penalize solutions with fewer stores
            return self.eps
        if total_coverage < self.data["num_stores"]:    # Penalize solutions with fewer stores
            return self.eps
        return total_dist

bounds = BinaryVar(n_vars=len(locations), name="placement_var")
problem = LocationOptProblem(bounds=bounds, minmax="min", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}")      # Decoded (Real) solution

Supply Chain Optimization

Let's assume we have a supply chain network with 5 distribution centers (DC1, DC2, DC3, DC4, DC5) and 10 products (P1, P2, P3, ..., P10). Our goal is to determine the optimal allocation of products to the distribution centers in a way that minimizes the total transportation cost.

Each solution represents an allocation of products to distribution centers. We can use a binary matrix with dimensions (10, 5) where each element (i, j) represents whether product i is allocated to distribution center j. For example, a chromosome [1, 0, 1, 0, 1] would mean that product 1 is allocated to DC1, DC3, DC5.

We can add the maximum capacity of each distribution center, therefor we need penalty term to the fitness evaluation function to penalize solutions that violate this constraint. The penalty can be based on the degree of violation or a fixed penalty value.

import numpy as np
from mealpy import BinaryVar, WOA, Problem

# Define the problem parameters
num_products = 10
num_distribution_centers = 5

# Define the transportation cost matrix (randomly generated for the example)
transportation_cost = np.random.randint(1, 10, size=(num_products, num_distribution_centers))

data = {
    "num_products": num_products,
    "num_distribution_centers": num_distribution_centers,
    "transportation_cost": transportation_cost,
    "max_capacity": 4,      # Maximum capacity of each distribution center
    "penalty": 1e10         # Define a penalty value for maximum capacity of each distribution center
}

class SupplyChainProblem(Problem):
    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["placement_var"].reshape((self.data["num_products"], self.data["num_distribution_centers"]))

        if np.any(np.all(x==0, axis=1)):    
        # If any row has all 0 value, it indicates that this product is not allocated to any distribution center.
            return 0

        total_cost = np.sum(self.data["transportation_cost"] * x)
        # Penalty for violating maximum capacity constraint
        excess_capacity = np.maximum(np.sum(x, axis=0) - self.data["max_capacity"], 0)
        penalty = np.sum(excess_capacity)
        # Calculate fitness value as the inverse of the total cost plus the penalty
        fitness = 1 / (total_cost + penalty)
        return fitness

bounds = BinaryVar(n_vars=num_products * num_distribution_centers, name="placement_var")
problem = SupplyChainProblem(bounds=bounds, minmax="max", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_products, num_distribution_centers))}")

Healthcare Workflow Optimization Problem

Define a chromosome representation that encodes the allocation of resources and patient flow in the emergency department. This could be a binary matrix where each row represents a patient and each column represents a resource (room). If the element is 1, it means the patient is assigned to that particular room, and if the element is 0, it means the patient is not assigned to that room

Please note that this implementation is a basic template and may require further customization based on the specific objectives, constraints, and evaluation criteria of your healthcare workflow optimization problem. You'll need to define the specific fitness function and optimization objectives based on the factors you want to optimize, such as patient waiting times, resource utilization, and other relevant metrics in the healthcare workflow context.

import numpy as np
from mealpy import BinaryVar, WOA, Problem

# Define the problem parameters
num_patients = 50  # Number of patients
num_resources = 10  # Number of resources (room)

# Define the patient waiting time matrix (randomly generated for the example)
# Why? May be, doctors need time to prepare tools,...
waiting_matrix = np.random.randint(1, 10, size=(num_patients, num_resources))

data = {
    "num_patients": num_patients,
    "num_resources": num_resources,
    "waiting_matrix": waiting_matrix,
    "max_resource_capacity": 10,        # Maximum capacity of each room
    "max_waiting_time": 60,             # Maximum waiting time
    "penalty_value": 1e2,         # Define a penalty value
    "penalty_patient": 1e10
}

class SupplyChainProblem(Problem):
    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["placement_var"].reshape(self.data["num_patients"], self.data["num_resources"])

        # If any row has all 0 value, it indicates that this patient is not allocated to any room.
        # If a patient a assigned to more than 3 room, not allow
        if np.any(np.all(x==0, axis=1)) or np.any(np.sum(x>3, axis=1)):
            return self.data["penalty_patient"]

        # Calculate fitness based on optimization objectives
        room_used = np.sum(x, axis=0)
        wait_time = np.sum(x * self.data["waiting_matrix"], axis=1)
        violated_constraints = np.sum(room_used > self.data["max_resource_capacity"]) + np.sum(wait_time > self.data["max_waiting_time"])

        # Calculate the fitness value based on the objectives
        resource_utilization_fitness = 1 - np.mean(room_used) / self.data["max_resource_capacity"]
        waiting_time_fitness = 1 - np.mean(wait_time) / self.data["max_waiting_time"]

        fitness = resource_utilization_fitness + waiting_time_fitness + self.data['penalty_value'] * violated_constraints
        return fitness

bounds = BinaryVar(n_vars=num_patients * num_resources, name="placement_var")
problem = SupplyChainProblem(bounds=bounds, minmax="min", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_patients, num_resources))}")

Production Optimization Problem

Let's consider a simplified example of production optimization in the context of a manufacturing company that produces electronic devices, such as smartphones. The objective is to maximize production output while minimizing production costs.

This example uses binary representations for production configurations, assuming each task can be assigned to a resource (1) or not (0). You may need to adapt the representation and operators to suit your specific production optimization problem.

import numpy as np
from mealpy import BinaryVar, WOA, Problem

# Define the problem parameters
num_tasks = 10
num_resources = 5

# Example task processing times
task_processing_times = np.array([2, 3, 4, 2, 3, 2, 3, 4, 2, 3])

# Example resource capacity
resource_capacity = np.array([10, 8, 6, 12, 15])

# Example production costs and outputs
production_costs = np.array([5, 6, 4, 7, 8, 9, 5, 6, 7, 8])
production_outputs = np.array([20, 18, 16, 22, 25, 24, 20, 18, 19, 21])

# Example maximum total production time
max_total_time = 50

# Example maximum defect rate
max_defect_rate = 0.2

# Penalty for invalid solution
penalty = -1000

data = {
    "num_tasks": num_tasks,
    "num_resources": num_resources,
    "task_processing_times": task_processing_times,
    "resource_capacity": resource_capacity,
    "production_costs": production_costs,
    "production_outputs": production_outputs,
    "max_defect_rate": max_defect_rate,
    "penalty": penalty
}

class SupplyChainProblem(Problem):
    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["placement_var"].reshape((self.data["num_tasks"], self.data["num_resources"]))

        # If any row has all 0 value, it indicates that this task is not allocated to any resource
        if np.any(np.all(x==0, axis=1)) or np.any(np.all(x==0, axis=0)):
            return self.data["penalty"]

        # Check violated constraints
        violated_constraints = 0

        # Calculate resource utilization
        resource_utilization = np.sum(x, axis=0)
        # Resource capacity constraint
        if np.any(resource_utilization > self.data["resource_capacity"]):
            violated_constraints += 1

        # Time constraint
        total_time = np.sum(np.dot(self.data["task_processing_times"].reshape(1, -1), x))
        if total_time > max_total_time:
            violated_constraints += 1

        # Quality constraint
        defect_rate = np.dot(self.data["production_costs"].reshape(1, -1), x) / np.dot(self.data["production_outputs"], x)
        if np.any(defect_rate > max_defect_rate):
            violated_constraints += 1

        # Calculate the fitness value based on the objectives and constraints
        profit = np.sum(np.dot(self.data["production_outputs"].reshape(1, -1), x)) - np.sum(np.dot(self.data["production_costs"].reshape(1, -1), x))
        if violated_constraints > 0:
            return profit + self.data["penalty"] * violated_constraints       # Penalize solutions with violated constraints
        return profit

bounds = BinaryVar(n_vars=num_tasks * num_resources, name="placement_var")
problem = SupplyChainProblem(bounds=bounds, minmax="max", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)['placement_var'].reshape((num_tasks, num_resources))}")

Employee Rostering Problem Using Woa Optimizer

The goal is to create an optimal schedule that assigns employees to shifts while satisfying various constraints and objectives. Note that this implementation assumes that shift_requirements array has dimensions (num_employees, num_shifts), and shift_costs is a 1D array of length num_shifts.

Please keep in mind that this is a simplified implementation, and you may need to modify it according to the specific requirements and constraints of your employee rostering problem. Additionally, you might want to introduce additional mechanisms or constraints such as fairness, employee preferences, or shift dependencies to enhance the model's effectiveness in real-world scenarios.

For example, if you have 5 employees and 3 shifts, a chromosome could be represented as [2, 1, 0, 2, 0], where employee 0 is assigned to shift 2, employee 1 is assigned to shift 1, employee 2 is assigned to shift 0, and so on.

import numpy as np
from mealpy import IntegerVar, WOA, Problem

shift_requirements = np.array([[2, 1, 3], [4, 2, 1], [3, 3, 2]])
shift_costs = np.array([10, 8, 12])

num_employees = shift_requirements.shape[0]
num_shifts = shift_requirements.shape[1]

data = {
    "shift_requirements": shift_requirements,
    "shift_costs": shift_costs,
    "num_employees": num_employees,
    "num_shifts": num_shifts
}

class EmployeeRosteringProblem(Problem):
    def __init__(self, bounds=None, minmax="min", data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["shift_var"]

        shifts_covered = np.zeros(self.data["num_shifts"])
        total_cost = 0
        for idx in range(self.data["num_employees"]):
            shift_idx = x[idx]
            shifts_covered[shift_idx] += 1
            total_cost += self.data["shift_costs"][shift_idx]
        coverage_diff = self.data["shift_requirements"] - shifts_covered
        coverage_penalty = np.sum(np.abs(coverage_diff))
        return total_cost + coverage_penalty

bounds = IntegerVar(lb=[0, ]*num_employees, ub=[num_shifts-1, ]*num_employees, name="shift_var")
problem = EmployeeRosteringProblem(bounds=bounds, minmax="min", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution)}")      # Decoded (Real) solution

Maintenance Scheduling

In maintenance scheduling, the goal is to optimize the schedule for performing maintenance tasks on various assets or equipment. The objective is to minimize downtime and maximize the utilization of assets while considering various constraints such as resource availability, task dependencies, and time constraints.

Each element in the solution represents whether a task is assigned to an asset (1) or not (0). The schedule specifies when each task should start and which asset it is assigned to, aiming to minimize the total downtime.

By using the Mealpy, you can find an efficient maintenance schedule that minimizes downtime, maximizes asset utilization, and satisfies various constraints, ultimately optimizing the maintenance operations for improved reliability and productivity.

import numpy as np
from mealpy import BinaryVar, WOA, Problem

num_tasks = 10
num_assets = 5
task_durations = np.random.randint(1, 10, size=(num_tasks, num_assets))

data = {
    "num_tasks": num_tasks,
    "num_assets": num_assets,
    "task_durations": task_durations,
    "unassigned_penalty": -100         # Define a penalty value for no task is assigned to asset
}

class MaintenanceSchedulingProblem(Problem):
    def __init__(self, bounds=None, minmax=None, data=None, **kwargs):
        self.data = data
        super().__init__(bounds, minmax, **kwargs)

    def obj_func(self, x):
        x_decoded = self.decode_solution(x)
        x = x_decoded["task_var"]
        downtime = -np.sum(x.reshape((self.data["num_tasks"], self.data["num_assets"])) * self.data["task_durations"])
        if np.sum(x) == 0:
            downtime += self.data["unassigned_penalty"]
        return downtime

bounds = BinaryVar(n_vars=num_tasks * num_assets, name="task_var")
problem = MaintenanceSchedulingProblem(bounds=bounds, minmax="max", data=data)

model = WOA.OriginalWOA(epoch=50, pop_size=20)
model.solve(problem)

print(f"Best agent: {model.g_best}")                    # Encoded solution
print(f"Best solution: {model.g_best.solution}")        # Encoded solution
print(f"Best fitness: {model.g_best.target.fitness}")
print(f"Best real scheduling: {model.problem.decode_solution(model.g_best.solution).reshape((num_tasks, num_assets))}")      # Decoded (Real) solution

Documents

Official Channels (questions, problems)

• Official source code repo: https://github.com/thieu1995/mealpy

• Official document: https://mealpy.readthedocs.io/

• Download releases: https://pypi.org/project/mealpy/

• Issue tracker: https://github.com/thieu1995/mealpy/issues

• Notable changes log: https://github.com/thieu1995/mealpy/blob/master/ChangeLog.md

• Examples with different meapy version: https://github.com/thieu1995/mealpy/blob/master/EXAMPLES.md

• Official chat/support group: https://t.me/+fRVCJGuGJg1mNDg1

• This project also related to our another projects which are optimization and machine learning. Check it here:

  • https://github.com/thieu1995/opfunu
  • https://github.com/thieu1995/metaheuristics
  • https://github.com/mafese
  • https://github.com/permetrics
  • https://github.com/pfevaluator
  • https://github.com/MetaCluster
  • https://github.com/enoppy
  • https://github.com/aiir-team

My Comments

• Meta-heuristic Categories: (Based on this article: link)

  • Evolutionary-based: Idea from Darwin's law of natural selection, evolutionary computing
  • Swarm-based: Idea from movement, interaction of birds, organization of social ...
  • Physics-based: Idea from physics law such as Newton's law of universal gravitation, black hole, multiverse
  • Human-based: Idea from human interaction such as queuing search, teaching learning, ...
  • Biology-based: Idea from biology creature (or microorganism),...
  • System-based: Idea from eco-system, immune-system, network-system, ...
  • Math-based: Idea from mathematical form or mathematical law such as sin-cosin
  • Music-based: Idea from music instrument

• Difficulty - Difficulty Level (Personal Opinion): Objective observation from author. Depend on the number of parameters, number of equations, the original ideas, time spend for coding, source lines of code (SLOC).

  • Easy: A few paras, few equations, SLOC very short
  • Medium: more equations than Easy level, SLOC longer than Easy level
  • Hard: Lots of equations, SLOC longer than Medium level, the paper hard to read.
  • Hard* - Very hard: Lots of equations, SLOC too long, the paper is very hard to read.

** For newbie, we recommend to read the paper of algorithms which difficulty is "easy" or "medium" difficulty level.