Introduction

This is an attempt to solve a joint clustering problem (assigning users and servers to a specified number of groups or clusters) using a random key genetic algorithm. The original problem was cross-posted on Math Stack Exchange and OR Stack Exchange. The latter contains an answer reformulating it as a mixed integer linear program, but the OP expressed interest in a heuristic or metaheuristic solution, so I will try a GA.

Problem statement

There are \(U\) users and \(S\) servers (transmitters) to be assigned to a predetermined number \(G\) of groups. Any number of users may be assigned to a group, but a group may contain no more than \(M\) servers (and must contain at least one). We assume here that it is possible for a group to be assigned no users. Users are served by all servers in their group, but servers in other groups may interfere with them. For each combination of a user \(u\) and a server \(s\), there is a parameter \(h_{us}\). The overall quality of service for a user \(u\) in group \(g\) is given by \[q_{u} = \frac{\sum_{s\in G} h_{us}}{\sum_{s \notin G} h_{us}}.\]The objective is to maximize the total quality \[\sum_{u=1}^U q_u.\]

Preliminary observations

Data consistency

The OP specifies that \(U > S > G\). We must also assume that \(S < GM\). Finally, we will assume that \(h_{us}\) is strictly positive.

User assignment

Note that (a) there are no limits to the number of users in any group, (b) the quality of service to user \(u\) depends on which servers are/are not in the same group with user \(u\) but not on the assignments of any other users, and (c) the objective is additive (service qualities do not interact). So, given a feasible partition of the servers into \(G\) groups, we can simply measure \(q_u\) for each possible group assignment of \(u\) and assign \(u\) to the group giving it the highest quality value. Thus the problem reduces to grouping servers.

Group sizes

Suppose that we have partitioned the servers into \(G\) groups, with \(n_g\) the number of servers in group \(g\). We require that \(1 \le n_g \le M\). It follows that the allocation is feasible if and only if the following all hold: \[1 \le n_g \quad \forall g \quad (1)\] \[n_g \le M \quad \forall g \quad (2)\] \[S - (G-g)M \le \sum_{\gamma=1}^g n_\gamma \quad \forall g \quad (3)\] and \[\sum_{\gamma=1}^g n_\gamma \le S - G + g\quad \forall g \quad (4).\]Constraint (3) ensures that enough servers are allocated among the first \(g\) groups that the remaining groups, if assigned the maximum number each, can accommodate the remaining servers. Constraint (4) ensures that the first \(g\) groups leave enough unassigned servers that each remaining group can have at least one.

Let \(U_g=\sum_{\gamma=1}^g n_\gamma\) with \(U_{0}=0\). We can combine (1) and (3) into \[\max(1, S - (G-g)M - U_{g-1})\le n_g\quad \forall g \quad (1')\]and (2) and (4) into\[n_g \le \min(M, S - G + g - U_{g-1})\quad \forall g\quad (2').\]

GA conceptualization

We will use a random key genetic algorithm, which requires a method of decoding a chromosome into a feasible solution. Without loss of generality, we can assume that server 1 is assigned to the first group. (This mitigates a little bit of symmetry.) We will use a permutation-based GA, in which the objects being permuted are the servers \(2,\dots, S\) and \(G-1\) “dividers” (represented by NA in the code) that split the permuted server list into \(G\) groups. So, for example, suppose that \(S=7\), \(G=3\), \(M=3\) and our permuted list is \((2, |, 7, 4, 5, |, 3, 6)\). Server 1 is automatically prepended to the list and a last divider is appended. This assigns servers 1 and 2 to the first group, servers 4, 5 and 7 to the second group, and servers 3 and 6 to the third group.

There is no guarantee that the sorted list will meet the group size requirements, which is where the constraints (1’) and (2’) come in. We proceed through the sorted list, computing cumulative group sizes, and adjust dividers by the minimum amount necessary to satisfy (1’) and (2’). Continuing the previous example, suppose that the permutation is \((2, 7, 4, |, |, 5, 3, 6)\). After prepending 1 and tacking on a last divider, we have \((1, 2, 7, 4, |, |, 5, 3, 6, |)\). The first partial sum would be \(n_1 =4\), which violates constraint (2’), whose right-hand side is \(\min(3, 7-3+1-0)=3\). So we move the first divider between 7 and 4, the minimum change necessary, giving \((1, 2, 7, |, 4, |, 5, 3, 6, |)\). The partition is now feasible, with groups \(\lbrace 1, 2, 7\rbrace\), \(\lbrace 4 \rbrace\) and \(\lbrace 3, 5, 6\rbrace\).

Test problem

We start by loading the GA library (and the magrittr library for convenience).

library(GA)
Loading required package: foreach
Loading required package: iterators
  ____    _    
 / ___|  / \     Genetic 
| |  _  / _ \    Algorithms
| |_| |/ ___ \   
 \____/_/   \_\  version 3.2
Type 'citation("GA")' for citing this R package in publications.

Attaching package: ‘GA’

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

    de
library(magrittr)

We set the dimensions of the test problem

U <- 100  # number of users
S <- 20  # number of servers
G <- 4   # number of groups (clusters)
M <- 7   # maximum number of servers per group

The quality values are generated uniformly over (0,1).

h <- runif(U * S) %>% matrix(nrow = U)

GA

Solution representation

We will represent a candidate solution with a list containing the following items:

  • obj the total objective value (scalar)

  • users a data frame of users containing two named columns

    • Group the index (\(1,\dots,G\)) of the group to which they are assigned
    • Quality the computed quality measure \(q_u\) for the user
  • groups a list of \(G\) vectors, each vector containing the indices of the servers in the corresponding group.

Chromosome representation

A chromosome will be an index vector for a permutation of \(S + G - 2\) objects: the \(S-1\) servers other than the first server (always assigned to the first group) and \(G-1\) NA values representing dividers between groups.

To facilitate working with permutations, we define an “alphabet” vector and a function that maps a permutation of \(\lbrace 2, 3, \dots, S + G - 1\rbrace\) into a sorted sequence of servers and dividers. The server sequence will always begin with server 1 and end with a divider (NA).

alphabet <- c(1:S, rep.int(NA, G))

Decoding a chromosome

The first step in getting from a chromosome to a solution is to convert the chromosome into a divided list with two elements. The first element (seq) is a sorted sequence of servers and dividers. The second element (div) is a vector giving the indices in the sequence of the dividers. The following function does that.

# Input: permutation vector (chromosome)
# Output: list containing the decoded sequence and the divider locations
as_sequence <- function(permutation) {
  sequence <- list()
  sequence$seq <- alphabet[c(1, permutation, S + G)]
  sequence$div <- sequence$seq %>% is.na() %>% which(arr.ind = TRUE)
  return(sequence)
}

Next, we need to make the proposed sequence feasible by adjusting the dividers as needed to meet the size restrictions on groups. In preparation for that, we will define a couple of helper functions that will move dividers.

When a group is too large, we need to move its terminating divider to an earlier position in the sequence. This is straightforward, since there is no chance the divider will pass a previous divider in the process. The following function takes as arguments a divided list, the index in the div element of the divider to move, and the number of positions to move it, and returns a modified copy of the list.

#Inputs:
#  `dlist`, a list with elements `seq` (sequence of servers and dividers) and `div` (indices of the dividers)
#  `ix` the index in `dlist$div` of the divider to move
#  `dist` the number of positions to the left to move the divider
#Output: the modified version of `dlist`
move_left <- function(dlist, ix, dist) {
  # Get the starting point of the divider to be moved.
  from <- dlist$div[ix]
  # Get the destination of the divider.
  to <- from - dist
  # Rearrange the subsequence of `seq`.
  dlist$seq[to:from] <- dlist$seq[c(from, to:(from - 1))]
  # Adjust the location of the divider that moved.
  dlist$div[ix] <- to
  return(dlist)
}

When a group is too small, its terminal divider needs to move to the right in the sequence. This is a bit trickier, since the moving divider could pass other dividers before it achieved the desired increase in group size. The following function takes the same arguments as move_left() but moves the divider far enough to the right that the current group gains the number of servers specified by the dist argument. Additional dividers encountered during the change are also moved.

#Inputs:
#  `dlist`, a list with elements `seq` (sequence of servers and dividers) and `div` (indices of the dividers)
#  `ix` the index in `dlist$div` of the divider to move
#  `dist` the number of servers the divider needs to pass
#Output: the modified version of `dlist`
move_right <- function(dlist, ix, dist) {
  # Get the starting point of the divider to be moved.
  from <- dlist$div[ix]
  # Compute the nominal final resting place of the moving divider.
  to <- from + dist
  q <- c()  # queue of dividers that need to be moved
  # Check subsequent dividers to see if they also need to move.
  for (j in (ix + 1):G) {
    if (dlist$div[j] > to) {
      break
    } else {
      # Adjust the move length and queue this divider to be moved.
      to <- to + 1
      q <- append(q, j)
    }
  }
  # Rotate the elements in the sequence to move the specified divider to its destination.
  dlist$seq[from:to] <- dlist$seq[c((from + 1):to, from)]
  dlist$div[ix] <- to
  # Update any other divider locations that changed.
  for (j in q) {
    dlist$div[j] <- dlist$div[j] - 1
  }
  # If there are other dividers queued to be moved, move each of them to the positions after the target divider.
  if (length(q) > 0) {
    iy <- max(q)  # index of the last divider being moved, if any
  }
  while (length(q) > 0) {
    # Pop the index of the next divider from the queue.
    j <- q[1]
    q <- q[-1]
    # Move this divider after the last moved divider.
    from <- dlist$div[j]
    dlist$seq[from:to] <- dlist$seq[c((from + 1):to, from)]
    dlist$div[j] <- to
    # Update affected divider locations (all the ones moving other than j).
    for (k in ix:iy) {
      if (k != j) {
        dlist$div[k] <- dlist$div[k] - 1
      }
    }
  }
  # Return the modified list.
  return(dlist)
}

Armed with these two functions, we can define a function that takes a divided list as input and modifies it to satisfy the group size limits.

# Input: a divided list with elements `seq` and `div` as above.
# Output: a modified version of the list satisfying group size requirements.
adjust <- function(dlist) {
  # Initialize variables.
  cusum <- 0       # cumulative sum of group sizes so far
                   # (U_{g-1} in (1') and (2'))
  last_div <- 0    # location of last divider encountered
                   # (marking the last position before the current
                   # group starts)
  # Process groups in order, adjusting the divider as needed.
  for (g in 1:(G - 1)) {
    # Update the lower and upper bounds.
    lo <- max(1, S - (G - g)*M - cusum)
    hi <- min(M, S - G + g - cusum)
    # Get the location of the next divider and the tentative group size.
    d <- dlist$div[g]
    n <- d - last_div - 1  # n_g in (1') and (2')
    # Adjust as needed.
    if (n < lo) {
      dlist <- move_right(dlist, g, lo - n)
      n <- lo
    } else if (n > hi) {
      dlist <- move_left(dlist, g, n - hi)
      n <- hi
    }
    # Update the cumulative sum and last divider location.
    cusum <- cusum + n
    last_div <- dlist$div[g]
  }
  # Return the modified list.
  return(dlist)
}

Next, we create a utility function that takes a divided sequence list and produces a list of \(G\) vectors, each containing the server list for one group.

# Input: a divided list with elements `seq` and `div` as above.
# Output: a list of G vectors containing the indices of servers in each group
server_lists <- function(dlist) {
  slist <- list()
  last_div <- 0
  for (g in 1:G) {
    next_div <- dlist$div[g]
    slist[[g]] <- sort(dlist$seq[(last_div + 1):(next_div -1)])
    last_div <- next_div
  }
  return(slist)
}

Given a list of server vectors as produced by server_lists, the next function evaluates the utility of assigning each user to each possible group and generates a dataframe containing the chosen group and utility value for each user. To reduce computation time, we first create a vector containing the sum \(\sum_{s=1}^S h_{us}\) of the utilities of assigning user \(u\) to each server \(s\).

total_utility <- apply(h, 1, sum)

We also create a utility function that takes as arguments a user and a vector of servers in a group and returns the quality measure \(q_u\) for assigning that user to that group.

# Inputs:
#  user = index of user
#  group = vector of servers in the group
# Output: quality value for assigning the user to that group
assignment_quality <- function(user, group) {
  numerator <- sum(h[user, group])
  denominator <- total_utility[user] - numerator
  return(numerator / denominator)
}

The next function makes the user assignments.

# Input: list of server vectors (as in the `groups` element of a solution list)
# Output: dataframe with chosen group and utility for each user (as in the `users` element of a solution list)
assign_users <- function(slist) {
  df <- data.frame(Group = rep.int(NA, U), Quality = rep.int(NA, U))
  for (u in 1:U) {
    # Evaluate all possible assignments of user u.
    qu <- sapply(slist, function(x) assignment_quality(u, x))
    # Find the index of the first group that maximizes quality.
    ix <- which.max(qu)
    # Record the assignment.
    df[u, "Group"] <- ix
    df[u, "Quality"] <- qu[ix]
  }
  return(df)
}

Now we define a function that converts a permutation vector list into a solution list with elements obj (total objective value), users (data frame of user assignments) and groups (list of server vectors).

# Input: a permutation vector (chromosome)
# Output: a solution list
decode <- function(permutation) {
  slist <- list()
  # Decode the permutation vector into a feasible collection of groups.
  slist$groups <-
    permutation %>% as_sequence() %>% adjust() %>% server_lists()
  # Compute the user assignments.
  slist$users <- slist$groups %>% assign_users()
  # The objective value is the sum of the user assignment qualities.
  slist$obj <- sum(slist$users$Quality)
  return(slist)
}

Fitness function

The fitness function takes a permutation, converts it to a feasible solution, and returns the objective value.

fitness <- function(chromosome) {
  sol <- chromosome %>% decode
  sol$obj
}

Solution report

We use the following function to report on a candidate solution.

# Input: a solution list with components `obj`, `users` and `groups`
solution_report <- function(solution) {
  cat("Solution with overall quality = ", solution$obj, ":\n")
  for (g in 1:G) {
    cat("\tServers in group ", g, ": ", solution$groups[[g]], "\n")
    u <- which(solution$users$Group == g, arr.ind = TRUE)
    if (length(u) == 0) {
      cat("\tUsers assigned to group ", g, ": NONE\n")
    } else {
      cat("\tUsers assigned to group ", g, " (", length(u), "): ", u, "\n")
    }
  }
}

Solution

We need to set some parameters for the genetic algorithm.

popSize <- 200        # population size
maxGens <- 200        # number of generations to run
stall <- 20           # stop if this many generations elapse without any improvement
multithread <- TRUE   # use parallel processes?
mutate <- 0.25        # use a relatively high mutation probability to discourage premature convergence

Now we run the GA. We use the “island evolution” variant to try to ward off premature convergence.

GA <- gaisl(type = "permutation",
            fitness = fitness,
            lower = 2,           # permutation indices start at 2
            upper = S + G - 1,   # permutation indices end at S+G-1
            popSize = popSize,
            maxiter = maxGens,
            run = stall,
            parallel = multithread,
            pmutation = mutate
)
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 1 
Mean = 65.45251 | Best = 70.35057 
Mean = 65.45251 | Best = 70.35057 
Mean = 65.45251 | Best = 70.35057 
Mean = 65.45251 | Best = 70.35057 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 2 
Mean = 64.18192 | Best = 70.90503 
Mean = 65.18431 | Best = 70.35057 
Mean = 65.67132 | Best = 70.35057 
Mean = 65.55964 | Best = 70.90721 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 3 
Mean = 65.70566 | Best = 71.08163 
Mean = 65.63610 | Best = 72.57250 
Mean = 66.01068 | Best = 70.35057 
Mean = 65.20788 | Best = 70.90721 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 4 
Mean = 65.94918 | Best = 71.75459 
Mean = 64.33893 | Best = 72.57250 
Mean = 66.12253 | Best = 72.57250 
Mean = 65.37149 | Best = 70.90721 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 5 
Mean = 66.18817 | Best = 71.75459 
Mean = 65.17979 | Best = 72.75234 
Mean = 65.62997 | Best = 73.55963 
Mean = 65.77710 | Best = 72.75234 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 6 
Mean = 64.85094 | Best = 72.75234 
Mean = 64.02787 | Best = 72.75234 
Mean = 65.64232 | Best = 73.55963 
Mean = 64.26401 | Best = 73.55963 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 7 
Mean = 65.60882 | Best = 73.55963 
Mean = 65.84829 | Best = 72.75234 
Mean = 65.57098 | Best = 73.55963 
Mean = 66.34094 | Best = 73.55963 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 8 
Mean = 66.21717 | Best = 73.55963 
Mean = 64.78888 | Best = 73.55963 
Mean = 64.63630 | Best = 73.55963 
Mean = 64.71138 | Best = 73.55963 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 9 
Mean = 64.46584 | Best = 73.55963 
Mean = 65.11027 | Best = 73.55963 
Mean = 65.65946 | Best = 73.55963 
Mean = 65.86944 | Best = 73.55963 
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
loaded GA and set parent environment
Islands GA | epoch = 10 
Mean = 64.17191 | Best = 73.55963 
Mean = 65.25347 | Best = 73.55963 
Mean = 65.25288 | Best = 73.55963 
Mean = 64.85213 | Best = 73.55963 
plot(GA)

Last, we recover the best solution found by the GA.

GA@solution[1,] %>% decode() %>% solution_report()
Solution with overall quality =  73.55963 :
    Servers in group  1 :  1 3 14 15 16 19 20 
    Users assigned to group  1  ( 48 ):  1 2 3 4 5 8 11 13 14 23 28 29 31 32 36 37 38 43 45 47 50 52 53 58 59 60 62 63 65 66 67 70 73 76 77 78 81 83 85 86 87 88 89 91 93 96 97 99 
    Servers in group  2 :  2 4 5 6 7 9 10 
    Users assigned to group  2  ( 50 ):  6 7 9 10 12 15 16 17 18 19 20 21 22 24 25 26 27 30 33 34 35 39 40 41 42 44 46 48 49 51 54 55 56 57 64 68 69 71 72 74 75 79 82 84 90 92 94 95 98 100 
    Servers in group  3 :  8 11 12 17 18 
    Users assigned to group  3  ( 2 ):  61 80 
    Servers in group  4 :  13 
    Users assigned to group  4 : NONE
---
title: "Joint Clustering"
output: html_notebook
author: Paul A. Rubin (rubin@msu.edu)
date: April 8, 2021
---

# Introduction

This is an attempt to solve a joint clustering problem (assigning users and servers to a specified number of groups or clusters) using a random key genetic algorithm. The original problem was cross-posted on [Math Stack Exchange](https://math.stackexchange.com/questions/4088441/what-will-be-an-efficient-joint-clustering-solution-to-this-problem) and [OR Stack Exchange](https://or.stackexchange.com/questions/6023/how-to-mathematically-formulate-the-optimization-problem). The latter contains an answer reformulating it as a mixed integer linear program, but the OP expressed interest in a heuristic or metaheuristic solution, so I will try a GA.

# Problem statement

There are $U$ users and $S$ servers (transmitters) to be assigned to a predetermined number $G$ of groups. Any number of users may be assigned to a group, but a group may contain no more than $M$ servers (and must contain at least one). We assume here that it is possible for a group to be assigned no users. Users are served by all servers in their group, but servers in other groups may interfere with them. For each combination of a user $u$ and a server $s$, there is a parameter $h_{us}$. The overall quality of service for a user $u$ in group $g$ is given by $$q_{u} = \frac{\sum_{s\in G} h_{us}}{\sum_{s \notin G}
h_{us}}.$$The objective is to maximize the total quality $$\sum_{u=1}^U q_u.$$

# Preliminary observations

## Data consistency

The OP specifies that $U > S > G$. We must also assume that $S < GM$. Finally, we will assume that $h_{us}$ is strictly positive.

## User assignment

Note that (a) there are no limits to the number of users in any group, (b) the quality of service to user $u$ depends on which servers are/are not in the same group with user $u$ but *not on the assignments of any other users*, and (c) the objective is additive (service qualities do not interact). So, given a feasible partition of the servers into $G$ groups, we can simply measure $q_u$ for each possible group assignment of $u$ and assign $u$ to the group giving it the highest quality value. Thus the problem reduces to grouping servers.

## Group sizes

Suppose that we have partitioned the servers into $G$ groups, with $n_g$ the number of servers in group $g$. We require that $1 \le n_g \le M$. It follows that the allocation is feasible if and only if the following all hold: $$1 \le n_g \quad \forall g \quad (1)$$ $$n_g \le M \quad \forall g \quad (2)$$ $$S - (G-g)M \le \sum_{\gamma=1}^g n_\gamma \quad \forall g \quad (3)$$ and $$\sum_{\gamma=1}^g n_\gamma \le S - G + g\quad \forall g \quad (4).$$Constraint (3) ensures that enough servers are allocated among the first $g$ groups that the remaining groups, if assigned the maximum number each, can accommodate the remaining servers. Constraint (4) ensures that the first $g$ groups leave enough unassigned servers that each remaining group can have at least one.

Let $U_g=\sum_{\gamma=1}^g n_\gamma$ with $U_{0}=0$. We can combine (1) and (3) into $$\max(1, S - (G-g)M - U_{g-1})\le n_g\quad \forall g \quad (1')$$and (2) and (4) into$$n_g \le \min(M, S - G + g - U_{g-1})\quad \forall g\quad (2').$$

# GA conceptualization

We will use a random key genetic algorithm, which requires a method of decoding a chromosome into a feasible solution. Without loss of generality, we can assume that server 1 is assigned to the first group. (This mitigates a little bit of symmetry.) We will use a permutation-based GA, in which the objects being permuted are the servers $2,\dots, S$ and $G-1$ "dividers" (represented by `NA` in the code) that split the permuted server list into $G$ groups. So, for example, suppose that $S=7$, $G=3$, $M=3$ and our permuted list is $(2, |, 7, 4, 5, |, 3, 6)$. Server 1 is automatically prepended to the list and a last divider is appended. This assigns servers 1 and 2 to the first group, servers 4, 5 and 7 to the second group, and servers 3 and 6 to the third group.

There is no guarantee that the sorted list will meet the group size requirements, which is where the constraints (1') and (2') come in. We proceed through the sorted list, computing cumulative group sizes, and adjust dividers by the minimum amount necessary to satisfy (1') and (2'). Continuing the previous example, suppose that the permutation is $(2, 7, 4, |, |, 5, 3, 6)$. After prepending 1 and tacking on a last divider, we have $(1, 2, 7, 4, |, |, 5, 3, 6, |)$. The first partial sum would be $n_1 =4$, which violates constraint (2'), whose right-hand side is $\min(3, 7-3+1-0)=3$. So we move the first divider between 7 and 4, the minimum change necessary, giving $(1, 2, 7, |, 4, |, 5, 3, 6, |)$. The partition is now feasible, with groups $\lbrace 1, 2, 7\rbrace$, $\lbrace 4 \rbrace$ and $\lbrace 3, 5, 6\rbrace$.

# Test problem

We start by loading the GA library (and the magrittr library for convenience).

```{r}
library(GA)
library(magrittr)
```

We set the dimensions of the test problem

```{r}
U <- 100  # number of users
S <- 20  # number of servers
G <- 4   # number of groups (clusters)
M <- 7   # maximum number of servers per group
```

The quality values are generated uniformly over (0,1).

```{r}
h <- runif(U * S) %>% matrix(nrow = U)
```

# GA

## Solution representation

We will represent a candidate solution with a list containing the following items:

-   `obj` the total objective value (scalar)

-   `users` a data frame of users containing two named columns

    -   `Group` the index ($1,\dots,G$) of the group to which they are assigned
    -   `Quality` the computed quality measure $q_u$ for the user

-   `groups` a list of $G$ vectors, each vector containing the indices of the servers in the corresponding group.

## Chromosome representation

A chromosome will be an index vector for a permutation of $S + G - 2$ objects: the $S-1$ servers other than the first server (always assigned to the first group) and $G-1$ NA values representing dividers between groups.

To facilitate working with permutations, we define an "alphabet" vector and a function that maps a permutation of $\lbrace 2, 3, \dots, S + G - 1\rbrace$ into a sorted sequence of servers and dividers. The server sequence will always begin with server 1 and end with a divider (NA).

```{r}
alphabet <- c(1:S, rep.int(NA, G))
```

## Decoding a chromosome

The first step in getting from a chromosome to a solution is to convert the chromosome into a divided list with two elements. The first element (`seq`) is a sorted sequence of servers and dividers. The second element (`div`) is a vector giving the indices in the sequence of the dividers. The following function does that.

```{r}
# Input: permutation vector (chromosome)
# Output: list containing the decoded sequence and the divider locations
as_sequence <- function(permutation) {
  sequence <- list()
  sequence$seq <- alphabet[c(1, permutation, S + G)]
  sequence$div <- sequence$seq %>% is.na() %>% which(arr.ind = TRUE)
  return(sequence)
}
```

Next, we need to make the proposed sequence feasible by adjusting the dividers as needed to meet the size restrictions on groups. In preparation for that, we will define a couple of helper functions that will move dividers.

When a group is too large, we need to move its terminating divider to an earlier position in the sequence. This is straightforward, since there is no chance the divider will pass a previous divider in the process. The following function takes as arguments a divided list, the index in the `div` element of the divider to move, and the number of positions to move it, and returns a modified copy of the list.

```{r}
#Inputs:
#  `dlist`, a list with elements `seq` (sequence of servers and dividers) and `div` (indices of the dividers)
#  `ix` the index in `dlist$div` of the divider to move
#  `dist` the number of positions to the left to move the divider
#Output: the modified version of `dlist`
move_left <- function(dlist, ix, dist) {
  # Get the starting point of the divider to be moved.
  from <- dlist$div[ix]
  # Get the destination of the divider.
  to <- from - dist
  # Rearrange the subsequence of `seq`.
  dlist$seq[to:from] <- dlist$seq[c(from, to:(from - 1))]
  # Adjust the location of the divider that moved.
  dlist$div[ix] <- to
  return(dlist)
}

```

When a group is too small, its terminal divider needs to move to the right in the sequence. This is a bit trickier, since the moving divider could pass other dividers before it achieved the desired increase in group size. The following function takes the same arguments as `move_left()` but moves the divider far enough to the right that the current group gains the number of servers specified by the `dist` argument. Additional dividers encountered during the change are also moved.

```{r}
#Inputs:
#  `dlist`, a list with elements `seq` (sequence of servers and dividers) and `div` (indices of the dividers)
#  `ix` the index in `dlist$div` of the divider to move
#  `dist` the number of servers the divider needs to pass
#Output: the modified version of `dlist`
move_right <- function(dlist, ix, dist) {
  # Get the starting point of the divider to be moved.
  from <- dlist$div[ix]
  # Compute the nominal final resting place of the moving divider.
  to <- from + dist
  q <- c()  # queue of dividers that need to be moved
  # Check subsequent dividers to see if they also need to move.
  for (j in (ix + 1):G) {
    if (dlist$div[j] > to) {
      break
    } else {
      # Adjust the move length and queue this divider to be moved.
      to <- to + 1
      q <- append(q, j)
    }
  }
  # Rotate the elements in the sequence to move the specified divider to its destination.
  dlist$seq[from:to] <- dlist$seq[c((from + 1):to, from)]
  dlist$div[ix] <- to
  # Update any other divider locations that changed.
  for (j in q) {
    dlist$div[j] <- dlist$div[j] - 1
  }
  # If there are other dividers queued to be moved, move each of them to the positions after the target divider.
  if (length(q) > 0) {
    iy <- max(q)  # index of the last divider being moved, if any
  }
  while (length(q) > 0) {
    # Pop the index of the next divider from the queue.
    j <- q[1]
    q <- q[-1]
    # Move this divider after the last moved divider.
    from <- dlist$div[j]
    dlist$seq[from:to] <- dlist$seq[c((from + 1):to, from)]
    dlist$div[j] <- to
    # Update affected divider locations (all the ones moving other than j).
    for (k in ix:iy) {
      if (k != j) {
        dlist$div[k] <- dlist$div[k] - 1
      }
    }
  }
  # Return the modified list.
  return(dlist)
}
```

Armed with these two functions, we can define a function that takes a divided list as input and modifies it to satisfy the group size limits.

```{r}
# Input: a divided list with elements `seq` and `div` as above.
# Output: a modified version of the list satisfying group size requirements.
adjust <- function(dlist) {
  # Initialize variables.
  cusum <- 0       # cumulative sum of group sizes so far
                   # (U_{g-1} in (1') and (2'))
  last_div <- 0    # location of last divider encountered
                   # (marking the last position before the current
                   # group starts)
  # Process groups in order, adjusting the divider as needed.
  for (g in 1:(G - 1)) {
    # Update the lower and upper bounds.
    lo <- max(1, S - (G - g)*M - cusum)
    hi <- min(M, S - G + g - cusum)
    # Get the location of the next divider and the tentative group size.
    d <- dlist$div[g]
    n <- d - last_div - 1  # n_g in (1') and (2')
    # Adjust as needed.
    if (n < lo) {
      dlist <- move_right(dlist, g, lo - n)
      n <- lo
    } else if (n > hi) {
      dlist <- move_left(dlist, g, n - hi)
      n <- hi
    }
    # Update the cumulative sum and last divider location.
    cusum <- cusum + n
    last_div <- dlist$div[g]
  }
  # Return the modified list.
  return(dlist)
}
```

Next, we create a utility function that takes a divided sequence list and produces a list of $G$ vectors, each containing the server list for one group.

```{r}
# Input: a divided list with elements `seq` and `div` as above.
# Output: a list of G vectors containing the indices of servers in each group
server_lists <- function(dlist) {
  slist <- list()
  last_div <- 0
  for (g in 1:G) {
    next_div <- dlist$div[g]
    slist[[g]] <- sort(dlist$seq[(last_div + 1):(next_div -1)])
    last_div <- next_div
  }
  return(slist)
}
```

Given a list of server vectors as produced by `server_lists`, the next function evaluates the utility of assigning each user to each possible group and generates a dataframe containing the chosen group and utility value for each user. To reduce computation time, we first create a vector containing the sum $\sum_{s=1}^S h_{us}$ of the utilities of assigning user $u$ to each server $s$.

```{r}
total_utility <- apply(h, 1, sum)
```

We also create a utility function that takes as arguments a user and a vector of servers in a group and returns the quality measure $q_u$ for assigning that user to that group.

```{r}
# Inputs:
#  user = index of user
#  group = vector of servers in the group
# Output: quality value for assigning the user to that group
assignment_quality <- function(user, group) {
  numerator <- sum(h[user, group])
  denominator <- total_utility[user] - numerator
  return(numerator / denominator)
}
```

The next function makes the user assignments.

```{r}
# Input: list of server vectors (as in the `groups` element of a solution list)
# Output: dataframe with chosen group and utility for each user (as in the `users` element of a solution list)
assign_users <- function(slist) {
  df <- data.frame(Group = rep.int(NA, U), Quality = rep.int(NA, U))
  for (u in 1:U) {
    # Evaluate all possible assignments of user u.
    qu <- sapply(slist, function(x) assignment_quality(u, x))
    # Find the index of the first group that maximizes quality.
    ix <- which.max(qu)
    # Record the assignment.
    df[u, "Group"] <- ix
    df[u, "Quality"] <- qu[ix]
  }
  return(df)
}
```

Now we define a function that converts a permutation vector list into a solution list with elements `obj` (total objective value), `users` (data frame of user assignments) and `groups` (list of server vectors).

```{r}
# Input: a permutation vector (chromosome)
# Output: a solution list
decode <- function(permutation) {
  slist <- list()
  # Decode the permutation vector into a feasible collection of groups.
  slist$groups <-
    permutation %>% as_sequence() %>% adjust() %>% server_lists()
  # Compute the user assignments.
  slist$users <- slist$groups %>% assign_users()
  # The objective value is the sum of the user assignment qualities.
  slist$obj <- sum(slist$users$Quality)
  return(slist)
}
```

## Fitness function

The fitness function takes a permutation, converts it to a feasible solution, and returns the objective value.

```{r}
fitness <- function(chromosome) {
  sol <- chromosome %>% decode
  sol$obj
}
```

## Solution report

We use the following function to report on a candidate solution.

```{r}
# Input: a solution list with components `obj`, `users` and `groups`
solution_report <- function(solution) {
  cat("Solution with overall quality = ", solution$obj, ":\n")
  for (g in 1:G) {
    cat("\tServers in group ", g, ": ", solution$groups[[g]], "\n")
    u <- which(solution$users$Group == g, arr.ind = TRUE)
    if (length(u) == 0) {
      cat("\tUsers assigned to group ", g, ": NONE\n")
    } else {
      cat("\tUsers assigned to group ", g, " (", length(u), "): ", u, "\n")
    }
  }
}
```

# Solution

We need to set some parameters for the genetic algorithm.

```{r}
popSize <- 200        # population size
maxGens <- 200        # number of generations to run
stall <- 20           # stop if this many generations elapse without any improvement
multithread <- TRUE   # use parallel processes?
mutate <- 0.25        # use a relatively high mutation probability to discourage premature convergence
```

Now we run the GA. We use the "island evolution" variant to try to ward off premature convergence.

```{r}
GA <- gaisl(type = "permutation",
            fitness = fitness,
            lower = 2,           # permutation indices start at 2
            upper = S + G - 1,   # permutation indices end at S+G-1
            popSize = popSize,
            maxiter = maxGens,
            run = stall,
            parallel = multithread,
            pmutation = mutate
)
plot(GA)
```

Last, we recover the best solution found by the GA.

```{r}
GA@solution[1,] %>% decode() %>% solution_report()
```
