Linear Optimization with Categorical Constraints - python-3.x

Question

I am trying to optimize a lineup of players according to the level of competition to play based on maximizing a single statistic(Points in my example below). For a given lineup, 2 players are matched up against a competition level. Here is an example of my DataFrame(This is just an example, my actual DataFrame has a lot more players than this):
Comp Level Points Minutes Played
Player A Elite 10.1 22
Player A Middle -5 22
Player A Low 7.2 22
Player B Elite 0.8 20
Player B Middle 5.6 20
Player B Low 2.2 20
Player C Elite -7.2 18
Player C Middle 3.3 21
Player C Low 6.6 23
Player D Elite -7.2 18
Player D Middle 3.3 21
Player D Low 6.6 23
Player E Elite -7.2 18
Player E Middle 3.3 21
Player E Low 6.6 23
Player F Elite -7.2 18
Player F Middle 3.3 21
Player F Low 6.6 23
The optimized lineup will maximize the total points of the entire lineup (A sum of points from each player). The constraints are:
1. You can't use the same player for more than one competition level (For example, if player A is paired against the elite level, they can't be played against the middle or low levels).
2. Each Lineup Pair has to have a minutes played value that is within 10% of each other (For Example, Player A Could be Paired with Player B at the Elite Level but not Player C).
I'm hoping my output will look something like this:
Line up:
Elite: Player A and B
Middle: Player C and Player D
Low: Player E and Player F
Team Total Points: X
I've started by creating my DataFrame and figured on using PuLP for this optimization. The part where I am struggling with is adding my objective function, and appropriate constraints to the problem.
This is my code thus far:
prob = LpProblem('LineUp Optimization', LpMaximize)
players = list(data['Name'])
# print('The Players under consideration are \n' + '-'*100)
# for x in players:
# print(x, end=',\n ')
costs = dict(zip(players, data['Points']))
comp_levels = dict(zip(players, data['Competition Level']))
Minutes = dict(zip(players, data['Minutes Played']))
ozs = dict(zip(players, data['OZS%']))
player_var = LpVariable.dicts('Players', players, 0, cat='Integer')
Any help/guidance on what my constraints would look like within this PuLP optimization would be greatly appreciated!

Answer 1

If I understood you're problem correctly you need to choose a pair of players for each of the Elite, Middle and lower competition levels.
There are a number of ways you could formulate this problem. The most obvious to me would be to have sets of binary variables which indicate wheter (1) or not (0) each player is chosen for each level of competition:
player_var = LpVariable.dicts('player_var', (players, comp_levels), cat='Binary')
Your objective is to maximise total points of the included players:
prob += lpSum([player_var[p, l]*points[p, l] for p in players for l in comp_levels])
You then need to put in constraints that two players should be chosen for each level:
for l in comp_levels:
prob += lpSum([player_var[p, l] for p in players]) == 2
And that a player can play in at most one competition level:
for p in players:
prob += lpSum([player_var[p, l] for l in comp_levels]) <= 1
And that your 10% rule on minutes played at the chosen level for the pairing is satisfied. This last one is kind of interesting. I'm sure there is a more efficient way of doing this but what I've done below should work... I think.
for l in comp_levels:
for p in players:
prob += minutes[p, l]*player_var[p,l] <= 1.1*lpSum([minutes[p,l]*player_ver[other_p,l] for other_p in players if other_p != p])
This creates a constraints for each competition level, and for each player, however if the player is not chosen to play at the level (player_var[p,l] == 0) then the constraints should have no effect - term on left-hand-side will be 0.
If the player is chosen (player_var[p,l] == 1) then the constaint ensures that the chosen player has no more than 10% more minutes than their oponent - note the right hand sand takes a sum over all other players but only 1 of these will be non-zero.
No check is carried out to ensure the chosen player has at least 90% of the minutes of their oponent - but that case is covered when this constraint is applied to their oponent.
I'm sure someone out there can suggest a much more efficient/elegant way of doing this...