This notebook explores a question posed on OR Stack Exchange about grouping machines so as to make the group productivity values approximately equal.

As always, the first step is to load libraries.

library(GA, quietly = TRUE)                # for running GAs
  ____    _    
 / ___|  / \     Genetic 
| |  _  / _ \    Algorithms
| |_| |/ ___ \   
 \____/_/   \_\  version 3.2.2
Type 'citation("GA")' for citing this R package in publications.

Attaching package: ‘GA’

The following object is masked from ‘package:utils’:

    de
library(ROI, quietly = TRUE)               # general solver interface
ROI: R Optimization Infrastructure
Registered solver plugins: nlminb, cplex.
Default solver: auto.
library(ROI.plugin.cplex, quietly = TRUE)  # connects the ROI package to CPLEX
library(ompr, quietly = TRUE)              # MIP modeling package
Registered S3 method overwritten by 'data.table':
  method           from
  print.data.table     
library(ompr.roi, quietly = TRUE)          # connects OMPR to ROI
library(dplyr, quietly = TRUE)             # for data frame operations

Attaching package: ‘dplyr’

The following objects are masked from ‘package:stats’:

    filter, lag

The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union
library(ggplot2, quietly = TRUE)           # to plot results

Data

We start by generating some random data, using dimensions from the original post.

M <- 21        # number of machines
G <- 7         # number of groups
S <- M / G     # size of a group
set.seed(246)  # seed the random number generator
productivity <- runif(M, min = 0, max = 10)  # productivity values
pAvg <- S * mean(productivity)               # mean group productivity

Solutions

A solution will be a permutation of the sequence \(1,\dots,M\), where the first \(S\) elements will form the first machine group, the next \(S\) elements will form the second group, etc.

For convenience, we will create an index vector indicating the group for each element in a permutation.

gIndex <- rep(1:G, each = S)

Criteria

We will seek to minimize either the range or the mean absolute deviation (MAD) of the group productivity levels. Other possible criteria include minimizing the mean squared deviation (MSD, which is likely to produce results similar but not necessarily identical to those using MAD), minimizing the highest group productivity and maximizing the lowest group productivity.

We first define a helper function that converts a solution into a vector of group productivity values.

# Input: a permutation of the machine indices 1,...,M
# Output: a vector of dimension G, where each entry is the productivity of a group
groupVals <- function(x) {
  productivity[x] |> rowsum(group = gIndex, reorder = F)
}

Next, we define functions that calculate the range and mean absolute deviation of a solution.

# Input: a permutation of the machine indices 1,...,M
# Output: the range of the group scores
pRange <- function(x) x |> groupVals() |> range() |> diff()

# Input: a permutation of the machine indices 1,...,M
# Output: the mean absolute deviation of group scores from the overall mean
pMAD <- function(x) {
  # Calculate the group values.
  y <- x |> groupVals()
  # Subtract the overall average, take absolute values and sum.
  (y - pAvg) |> abs() |> sum() / length(x)
}

We will use a data frame to store the group productivity values obtained in each solution, and another data frame to store the range and MAD for each solution.

results <- data.frame("Method" = NA, "Criterion" = NA, "Group" = NA, "Productivity" = NA)
metrics <- data.frame("Method" = NA, "Criterion" = NA, "Range" = NA, "MAD" = NA)

Author’s heuristic

The author suggests a greedy heuristic in which the \(G\) most productive machines are assigned to groups of size 1 and thereafter machines are assigned to the least productive group with space available.

author <- function() {
  p <- rep(0, G)   # group productivity values
  s <- rep(0, G)   # group sizes
  y <- rep(NA, M)  # y[i] is group index for machine i
  # Process machines in decreasing productivity order.
  for (i in sort(productivity, decreasing = T, index.return = T)$ix) {
    # Find the least productive group.
    g <- which.min(p)
    # Assign machine i to group g.
    y[i] <- g
    # Update the group size and productivity.
    s[g] <- s[g] + 1
    p[g] <- p[g] + productivity[i]
    # If the group is full, set its productivity to NA, preventing it from further selection.
    if (s[g] == S) {
      p[g] <- NA
    }
  }
  # Translate the group index vector into a permutation.
  (1:M)[sort(y, index.return = T)$ix]
}

We test the heuristic on the sample data.

sol <- author()
r <- pRange(sol)
m <- pMAD(sol)
results <- results |> add_row(Method = "Author", Criterion = "None", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "Author", Criterion = "None", Range = r, MAD = m)
# Summarize it.
cat("Author's heuristic solution has range = ", r, " and  MAD = ", m, ".")
Author's heuristic solution has range =  2.034865  and  MAD =  0.256263 .

Genetic algorithms

As one comparison, we try a genetic algorithms. Since the GA is designed to maximize rather than minimize, we use as fitness value the difference between an upper bound on either range or MAD and the actual range or MAD. The upper bound for range is simply range in machine productivity values multiplied by the group size. The upper bound for MAD is the product of group size with the larger of the absolute difference between the overall average and either the highest or lowest productivity of any machine.

rangeUB <-  productivity |> range() |> diff() * S
madUB <- S * max(max(productivity) - pAvg, pAvg - min(productivity))

The first GA minimizes range. We will use default values for some parameters, but increase the iteration limit and population size.

ga <- ga(type = "permutation",
         fitness = function(x) rangeUB - pRange(x),
         lower = rep.int(1, M),
         upper = rep.int(M, M),
         popSize = 200,
         maxiter = 500,
         monitor = FALSE)
# Extract the solution.
sol <- ga@solution[1,]
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "GA", Criterion = "Range", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "GA", Criterion = "Range", Range = r, MAD = m)
# Summarize it.
cat("The GA solution for minimizing range has range = ", r, " and MAD = ", m, ".")
The GA solution for minimizing range has range =  0.6431715  and MAD =  0.05772201 .

The second GA minimizes MAD.

ga <- ga(type = "permutation",
         fitness = function(x) madUB - pMAD(x),
         lower = rep.int(1, M),
         upper = rep.int(M, M),
         popSize = 200,
         maxiter = 500,
         monitor = FALSE)
# Extract the solution.
sol <- ga@solution[1,]
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "GA", Criterion = "MAD", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "GA", Criterion = "MAD", Range = r, MAD = m)
# Summarize it.
cat("The GA solution for minimizing MAD has range = ", r, " and MAD = ", m, ".")
The GA solution for minimizing MAD has range =  0.6639519  and MAD =  0.06434813 .

MIP models

We can find a provably optimal solution using MIP models, which we will code using the ompr package and solve with CPLEX. We start with a model for minimizing range.

mip <- MIPModel() |>
          # Use an indicator variable for each combination of machine and group.
          add_variable(x[m, g], m = 1:M, g = 1:G, type = "binary") |>
          # Use a nonnegative variable for the production level of each group.
          add_variable(p[g], g = 1:G, type = "continuous", lb = 0) |>
          # Use nonnegative variables for the smallest and largest group productivity levels.
          add_variable(zlo, type = "continuous", lb = 0) |>
          add_variable(zhi, type = "continuous", lb = 0) |>
          # Limit every machine to a single group.
          add_constraint(sum_expr(x[m, g], g = 1:G) == 1, m = 1:M) |>
          # Limit every group to S machines.
          add_constraint(sum_expr(x[m, g], m = 1:M) == S, g = 1:G) |>
          # Define the group production levels.
          add_constraint(sum_expr(productivity[m] * x[m, g], m = 1:M) - p[g] == 0
                         , g = 1:G) |>
          # Define the range limit variables.
          add_constraint(p[g] - zhi <= 0, g = 1:G) |>
          add_constraint(p[g] - zlo >= 0, g = 1:G) |>
          # Set the objective.
          set_objective(zhi - zlo, sense = "min")
# Solve the MIP.
mipsol <- mip |> solve_model(with_ROI(solver = "cplex"))
CPLEX environment opened
Closed CPLEX environment
# Decode the solution.
sol <- mipsol |> get_solution(x[m, g]) |> filter(value > 0.9) |> arrange(g) |>
                 select(m) |> as.vector()
# Change from tibble to vector.
sol <- sol$m
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "MIP", Criterion = "Range", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "MIP", Criterion = "Range", Range = r, MAD = m)
# Summarize it.
cat("The MILP solution for minimizing range has range = ", r, " and MAD = ", m, ".")
The MILP solution for minimizing range has range =  0.4230259  and MAD =  0.03940527 .

Now we try a MIP model to minimize the sum of absolute deviations (which will minimize MAD, since they differ by a constant factor.)

mip <- MIPModel() |>
          # Use an indicator variable for each combination of machine and group.
          add_variable(x[m, g], m = 1:M, g = 1:G, type = "binary") |>
          # Use a nonnegative variable for the production level of each group.
          add_variable(p[g], g = 1:G, type = "continuous", lb = 0) |>
          # Use a nonnegative variable for the absolute deviation of each group's productivity from the overall mean.
          add_variable(z[g], g = 1:G, type = "continuous", lb = 0) |>
          # Limit every machine to a single group.
          add_constraint(sum_expr(x[m, g], g = 1:G) == 1, m = 1:M) |>
          # Limit every group to S machines.
          add_constraint(sum_expr(x[m, g], m = 1:M) == S, g = 1:G) |>
          # Define the group production levels.
          add_constraint(sum_expr(productivity[m] * x[m, g], m = 1:M) - p[g] == 0
                         , g = 1:G) |>
          # Define the absolute value variables.
          add_constraint(p[g] - pAvg - z[g] <= 0, g = 1:G) |>
          add_constraint(p[g] - pAvg + z[g] >= 0, g = 1:G) |>
          # Set the objective.
          set_objective(sum_expr(z[g], g = 1:G), sense = "min")
# Solve the MIP.
mipsol <- mip |> solve_model(with_ROI(solver = "cplex"))
CPLEX environment opened
Closed CPLEX environment
# Decode the solution.
sol <- mipsol |> get_solution(x[m, g]) |> filter(value > 0.9) |> arrange(g) |>
                 select(m) |> as.vector()
# Change from tibble to vector.
sol <- sol$m
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "MIP", Criterion = "MAD", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "MIP", Criterion = "MAD", Range = r, MAD = m)
# Summarize it.
cat("The MILP solution for minimizing MAD has range = ", r, " and MAD = ", m, ".")
The MILP solution for minimizing MAD has range =  0.4950586  and MAD =  0.0385512 .

We can drop the dummy rows used to initialize the data frames.

results <- results |> filter(!is.na(Method))
metrics <- metrics |> filter(!is.na(Method))

Results

The overall performance results are summarized below.

metrics

Percentage optimality gaps are as follows.

metrics |>
  mutate(Range = 100 * (Range / min(Range) - 1)) |>
  rename(`Range % Gap` = Range) |>
  mutate(MAD = 100 * (MAD / min(MAD) - 1)) |>
  rename(`MAD % Gap` = MAD)

The author’s heuristic, while fast, is far from optimal in multiple test runs. The GAs also tend to have substantial gaps, although increasing population size and iteration limits might help them.

Finally, we can visualize the group productivity levels of the various solutions.

ggplot(results, aes(x = Group, y = Criterion)) +
  facet_grid(Method ~ ., scales = "free") +
  geom_point(size = 100 * abs(results$Productivity - pAvg) / pAvg) +
  scale_x_continuous(breaks = 1:G) +
  ggtitle("% Deviation from Group Mean") +
  theme(plot.title = element_text(hjust = 0.5))

---
title: "Machine Groups"
output: html_notebook
---

This notebook explores a [question](https://or.stackexchange.com/questions/7611/dividing-machines-into-groups-of-equal-sizes-so-that-each-group-has-approximatel) posed on OR Stack Exchange about grouping machines so as to make the group productivity values approximately equal.

As always, the first step is to load libraries.

```{r}
library(GA, quietly = TRUE)                # for running GAs
library(ROI, quietly = TRUE)               # general solver interface
library(ROI.plugin.cplex, quietly = TRUE)  # connects the ROI package to CPLEX
library(ompr, quietly = TRUE)              # MIP modeling package
library(ompr.roi, quietly = TRUE)          # connects OMPR to ROI
library(dplyr, quietly = TRUE)             # for data frame operations
library(ggplot2, quietly = TRUE)           # to plot results
```

# Data

We start by generating some random data, using dimensions from the original post.

```{r}
M <- 21        # number of machines
G <- 7         # number of groups
S <- M / G     # size of a group
set.seed(246)  # seed the random number generator
productivity <- runif(M, min = 0, max = 10)  # productivity values
pAvg <- S * mean(productivity)               # mean group productivity
```

# Solutions

A solution will be a permutation of the sequence $1,\dots,M$, where the first $S$ elements will form the first machine group, the next $S$ elements will form the second group, etc.

For convenience, we will create an index vector indicating the group for each element in a permutation.

```{r}
gIndex <- rep(1:G, each = S)
```

# Criteria

We will seek to minimize either the range or the mean absolute deviation (MAD) of the group productivity levels. Other possible criteria include minimizing the mean squared deviation (MSD, which is likely to produce results similar but not necessarily identical to those using MAD), minimizing the highest group productivity and maximizing the lowest group productivity.

We first define a helper function that converts a solution into a vector of group productivity values.

```{r}
# Input: a permutation of the machine indices 1,...,M
# Output: a vector of dimension G, where each entry is the productivity of a group
groupVals <- function(x) {
  productivity[x] |> rowsum(group = gIndex, reorder = F)
}
```

Next, we define functions that calculate the range and mean absolute deviation of a solution.

```{r}
# Input: a permutation of the machine indices 1,...,M
# Output: the range of the group scores
pRange <- function(x) x |> groupVals() |> range() |> diff()

# Input: a permutation of the machine indices 1,...,M
# Output: the mean absolute deviation of group scores from the overall mean
pMAD <- function(x) {
  # Calculate the group values.
  y <- x |> groupVals()
  # Subtract the overall average, take absolute values and sum.
  (y - pAvg) |> abs() |> sum() / length(x)
}
```

We will use a data frame to store the group productivity values obtained in each solution, and another data frame to store the range and MAD for each solution.

```{r}
results <- data.frame("Method" = NA, "Criterion" = NA, "Group" = NA, "Productivity" = NA)
metrics <- data.frame("Method" = NA, "Criterion" = NA, "Range" = NA, "MAD" = NA)
```

# Author's heuristic

The author suggests a greedy heuristic in which the $G$ most productive machines are assigned to groups of size 1 and thereafter machines are assigned to the least productive group with space available.

```{r}
author <- function() {
  p <- rep(0, G)   # group productivity values
  s <- rep(0, G)   # group sizes
  y <- rep(NA, M)  # y[i] is group index for machine i
  # Process machines in decreasing productivity order.
  for (i in sort(productivity, decreasing = T, index.return = T)$ix) {
    # Find the least productive group.
    g <- which.min(p)
    # Assign machine i to group g.
    y[i] <- g
    # Update the group size and productivity.
    s[g] <- s[g] + 1
    p[g] <- p[g] + productivity[i]
    # If the group is full, set its productivity to NA, preventing it from further selection.
    if (s[g] == S) {
      p[g] <- NA
    }
  }
  # Translate the group index vector into a permutation.
  (1:M)[sort(y, index.return = T)$ix]
}
```

We test the heuristic on the sample data.

```{r}
sol <- author()
r <- pRange(sol)
m <- pMAD(sol)
results <- results |> add_row(Method = "Author", Criterion = "None", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "Author", Criterion = "None", Range = r, MAD = m)
# Summarize it.
cat("Author's heuristic solution has range = ", r, " and  MAD = ", m, ".")
```

# Genetic algorithms

As one comparison, we try a genetic algorithms. Since the GA is designed to maximize rather than minimize, we use as fitness value the difference between an upper bound on either range or MAD and the actual range or MAD. The upper bound for range is simply range in machine productivity values multiplied by the group size. The upper bound for MAD is the product of group size with the larger of the absolute difference between the overall average and either the highest or lowest productivity of any machine.

```{r}
rangeUB <-  productivity |> range() |> diff() * S
madUB <- S * max(max(productivity) - pAvg, pAvg - min(productivity))
```

The first GA minimizes range. We will use default values for some parameters, but increase the iteration limit and population size.

```{r}
ga <- ga(type = "permutation",
         fitness = function(x) rangeUB - pRange(x),
         lower = rep.int(1, M),
         upper = rep.int(M, M),
         popSize = 200,
         maxiter = 500,
         monitor = FALSE)
# Extract the solution.
sol <- ga@solution[1,]
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "GA", Criterion = "Range", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "GA", Criterion = "Range", Range = r, MAD = m)
# Summarize it.
cat("The GA solution for minimizing range has range = ", r, " and MAD = ", m, ".")
```
The second GA minimizes MAD.

```{r}
ga <- ga(type = "permutation",
         fitness = function(x) madUB - pMAD(x),
         lower = rep.int(1, M),
         upper = rep.int(M, M),
         popSize = 200,
         maxiter = 500,
         monitor = FALSE)
# Extract the solution.
sol <- ga@solution[1,]
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "GA", Criterion = "MAD", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "GA", Criterion = "MAD", Range = r, MAD = m)
# Summarize it.
cat("The GA solution for minimizing MAD has range = ", r, " and MAD = ", m, ".")
```

# MIP models

We can find a provably optimal solution using MIP models, which we will code using the `ompr` package and solve with CPLEX. We start with a model for minimizing range.

```{r}
mip <- MIPModel() |>
          # Use an indicator variable for each combination of machine and group.
          add_variable(x[m, g], m = 1:M, g = 1:G, type = "binary") |>
          # Use a nonnegative variable for the production level of each group.
          add_variable(p[g], g = 1:G, type = "continuous", lb = 0) |>
          # Use nonnegative variables for the smallest and largest group productivity levels.
          add_variable(zlo, type = "continuous", lb = 0) |>
          add_variable(zhi, type = "continuous", lb = 0) |>
          # Limit every machine to a single group.
          add_constraint(sum_expr(x[m, g], g = 1:G) == 1, m = 1:M) |>
          # Limit every group to S machines.
          add_constraint(sum_expr(x[m, g], m = 1:M) == S, g = 1:G) |>
          # Define the group production levels.
          add_constraint(sum_expr(productivity[m] * x[m, g], m = 1:M) - p[g] == 0
                         , g = 1:G) |>
          # Define the range limit variables.
          add_constraint(p[g] - zhi <= 0, g = 1:G) |>
          add_constraint(p[g] - zlo >= 0, g = 1:G) |>
          # Set the objective.
          set_objective(zhi - zlo, sense = "min")
# Solve the MIP.
mipsol <- mip |> solve_model(with_ROI(solver = "cplex"))
# Decode the solution.
sol <- mipsol |> get_solution(x[m, g]) |> filter(value > 0.9) |> arrange(g) |>
                 select(m) |> as.vector()
# Change from tibble to vector.
sol <- sol$m
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "MIP", Criterion = "Range", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "MIP", Criterion = "Range", Range = r, MAD = m)
# Summarize it.
cat("The MILP solution for minimizing range has range = ", r, " and MAD = ", m, ".")
```

Now we try a MIP model to minimize the sum of absolute deviations (which will minimize MAD, since they differ by a constant factor.)

```{r}
mip <- MIPModel() |>
          # Use an indicator variable for each combination of machine and group.
          add_variable(x[m, g], m = 1:M, g = 1:G, type = "binary") |>
          # Use a nonnegative variable for the production level of each group.
          add_variable(p[g], g = 1:G, type = "continuous", lb = 0) |>
          # Use a nonnegative variable for the absolute deviation of each group's productivity from the overall mean.
          add_variable(z[g], g = 1:G, type = "continuous", lb = 0) |>
          # Limit every machine to a single group.
          add_constraint(sum_expr(x[m, g], g = 1:G) == 1, m = 1:M) |>
          # Limit every group to S machines.
          add_constraint(sum_expr(x[m, g], m = 1:M) == S, g = 1:G) |>
          # Define the group production levels.
          add_constraint(sum_expr(productivity[m] * x[m, g], m = 1:M) - p[g] == 0
                         , g = 1:G) |>
          # Define the absolute value variables.
          add_constraint(p[g] - pAvg - z[g] <= 0, g = 1:G) |>
          add_constraint(p[g] - pAvg + z[g] >= 0, g = 1:G) |>
          # Set the objective.
          set_objective(sum_expr(z[g], g = 1:G), sense = "min")
# Solve the MIP.
mipsol <- mip |> solve_model(with_ROI(solver = "cplex"))
# Decode the solution.
sol <- mipsol |> get_solution(x[m, g]) |> filter(value > 0.9) |> arrange(g) |>
                 select(m) |> as.vector()
# Change from tibble to vector.
sol <- sol$m
r <- pRange(sol)
m <- pMAD(sol)
# Store the results.
results <- results |> add_row(Method = "MIP", Criterion = "MAD", Group = 1:7, Productivity = groupVals(sol))
metrics <- metrics |> add_row(Method = "MIP", Criterion = "MAD", Range = r, MAD = m)
# Summarize it.
cat("The MILP solution for minimizing MAD has range = ", r, " and MAD = ", m, ".")
```

We can drop the dummy rows used to initialize the data frames.

```{r}
results <- results |> filter(!is.na(Method))
metrics <- metrics |> filter(!is.na(Method))
```

# Results

The overall performance results are summarized below.

```{r}
metrics
```

Percentage optimality gaps are as follows.

```{r}
metrics |>
  mutate(Range = 100 * (Range / min(Range) - 1)) |>
  rename(`Range % Gap` = Range) |>
  mutate(MAD = 100 * (MAD / min(MAD) - 1)) |>
  rename(`MAD % Gap` = MAD)
```

The author's heuristic, while fast, is far from optimal in multiple test runs. The GAs also tend to have substantial gaps, although increasing population size and iteration limits might help them.

Finally, we can visualize the group productivity levels of the various solutions.

```{r}
ggplot(results, aes(x = Group, y = Criterion)) +
  facet_grid(Method ~ ., scales = "free") +
  geom_point(size = 100 * abs(results$Productivity - pAvg) / pAvg) +
  scale_x_continuous(breaks = 1:G) +
  ggtitle("% Deviation from Group Mean") +
  theme(plot.title = element_text(hjust = 0.5))
```

