Skip to content
Snippets Groups Projects
Commit 728bc023 authored by Frederik Arnold's avatar Frederik Arnold
Browse files

Add optimization notebook

parent 2afa379a
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
notebooks/Optimization.ipynb 0 → 100644
+ 302
− 0
View file @ 728bc023
%% Cell type:markdown id:df593963 tags:
# Optimization Example
This notebook shows a example of how to user linear programming to solve following optimization problem.
## Problem Description
TBD
## General approach
1. Create all possible combinations of papers given the maximum number of papers for a time slot.
2. Remove combinations which are impossible to satisfy because authors have conflicting time slot preferences.
3. Add a contraint to limit the number of time slots.
4. Add a constraint to make sure that a paper can only appear in up to one time slot.
5. Solve
%% Cell type:markdown id:0e2d98ee tags:
## Dependencies
%% Cell type:code id:5a732db1 tags:
```
!pip install pulp
```
%% Cell type:code id:64604da8 tags:
```
import pulp
from dataclasses import dataclass, field
from typing import List
```
%% Cell type:markdown id:97cdf625 tags:
## Data structures
%% Cell type:code id:7036ad2e tags:
```
@dataclass
class Reviewer:
id: str
time_slots: List[int]
def __repr__(self) -> str:
return self.id
```
%% Cell type:code id:e8352c4f tags:
```
@dataclass(eq=True, frozen=True)
class Paper:
id: str = field(hash=True)
reviewers: List[Reviewer] = field(compare=False, hash=False)
score: int = field(compare=False, hash=False)
def __repr__(self) -> str:
result = f'{self.id} (score: {self.score})'
for rev in self.reviewers:
result += f'\n{rev}'
return result
```
%% Cell type:markdown id:405bf280 tags:
## Functions
%% Cell type:code id:8b90cf13 tags:
```
def score(time_slot) -> int:
'''
Takes a time slot (i.e. a list of papers) and calculates a score.
The scores takes the number of papers in the time slot and the review score into account.
'''
paper_count = len(time_slot)
if paper_count == 1:
if len(time_slot[0].reviewers) > 0:
review_score = 2 - abs(time_slot[0].score)
return paper_count + review_score
else:
return 0
result = paper_count
for p in time_slot:
review_score = 2 - abs(p.score)
if len(p.reviewers) == 1:
result += review_score
elif len(p.reviewers) > 1:
result += review_score
# for multiple reviewers, we could also take into account the number of reviewers or how many
# reviewers are available at the same time, but currently this is not used
# all_ts_lists = []
# for rev in p.reviewers:
# if len(rev.time_slots) > 0:
# all_ts_lists.append(rev.time_slots)
# inters = set.intersection(*[set(x) for x in all_ts_lists])
# if len(inters) > 0:
# result += review_score
return result
```
%% Cell type:code id:dcd2472b tags:
```
def check(time_slot) -> bool:
'''
Takes a time slot (i.e. a list of papers) and checks if there are any contradictions, i.e., for every paper
with at least one reviewer, there is a time slot where at least one reviewer for every paper is available.
'''
all_ts_lists = []
for p in time_slot:
all_p_ts = []
for rev in p.reviewers:
if len(rev.time_slots) > 0:
all_p_ts.extend(rev.time_slots)
all_ts_lists.append(all_p_ts)
if len(all_ts_lists) > 0:
result = len(set.intersection(*[set(x) for x in all_ts_lists]))
return result >= 1
else:
return True
```
%% Cell type:markdown id:a09dfb77 tags:
## Test data
%% Cell type:code id:61224383 tags:
```
r1 = Reviewer('Reviewer1', [0, 1])
r2 = Reviewer('Reviewer2', [0, 1])
r3 = Reviewer('Reviewer3', [0])
r4 = Reviewer('Reviewer4', [1])
r5 = Reviewer('Reviewer5', [2])
r6 = Reviewer('Reviewer6', [2])
r7 = Reviewer('Reviewer7', [2])
r8 = Reviewer('Reviewer8', [2])
r9 = Reviewer('Reviewer9', [0])
r10 = Reviewer('Reviewer10', [1])
papers = []
papers.append(Paper('Paper1', [r1, r2], 2))
papers.append(Paper('Paper2', [r1], 0))
papers.append(Paper('Paper3', [r3, r4], 0))
papers.append(Paper('Paper4', [r5, r6], -2))
papers.append(Paper('Paper5', [r7, r8], 0))
papers.append(Paper('Paper6', [r9, r10], -1))
```
%% Cell type:markdown id:56c78a45 tags:
## The Model
%% Cell type:code id:daafd13a tags:
```
max_time_slots = 2
max_slot_size = 2
all_time_slots = [tuple(c) for c in pulp.allcombinations(papers, max_slot_size)]
possible_time_slots = []
for ts in all_time_slots:
if check(ts):
possible_time_slots.append(ts)
x = pulp.LpVariable.dicts(
"time_slot", possible_time_slots, lowBound=0, upBound=1, cat=pulp.LpInteger
)
review_model = pulp.LpProblem("Review Model", pulp.LpMaximize)
review_model += pulp.lpSum([score(ts) * x[ts] for ts in possible_time_slots])
review_model += (
pulp.lpSum([x[ts] for ts in possible_time_slots]) <= max_time_slots,
"Maximum_number_of_time_slots",
)
for paper in papers:
review_model += (
pulp.lpSum([x[ts] for ts in possible_time_slots if paper in ts]) <= 1,
f"Must_assign_{paper}",
)
status = review_model.solve()
if status == 1:
slot_count = 1
print(f"The best time slots are:")
for ts in possible_time_slots:
if x[ts].value() == 1.0:
print(f'\nSlot {slot_count}:')
for p in ts:
print(f'\n{p}')
slot_count += 1
else:
print('Problem could not be solved!')
```
%% Cell type:code id:856d62e2 tags:
```
```
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

Impressum | Datenschutzerklärung