jshbrmn/irt-service
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

combination based bundle solving

Browse Source
This commit is contained in:
spushy 2022-02-09 01:13:49 -05:00
parent 744abbb7b8
commit 8ce5e6e540
4 changed files with 139 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
app/helpers/solver_helper.py
View File

@ -1,10 +1,16 @@
from pulp import lpSum
from itertools import combinations
from pulp import lpSum, LpProblem
from random import randint, sample
from models.bundle import Bundle
from models.item import Item
from models.solver_run import SolverRun
import logging
from lib.errors.item_generation_error import ItemGenerationError
def build_constraints(solver_run, problem, items, bundles):
def build_constraints(solver_run: SolverRun, problem: LpProblem, items: list[Item], bundles: list[Bundle] or None) -> LpProblem:
try:
total_form_items = solver_run.total_form_items
constraints = solver_run.constraints
@ -24,33 +30,47 @@ def build_constraints(solver_run, problem, items, bundles):
problem += lpSum([con[item.id]
* items[item.id]
for item in solver_run.items]) <= round(total_form_items * (max / 100)), f'{attribute.id} - {attribute.value} - max'
elif attribute.type == 'bundle':
# TODO: account for many different bundle types, since the id condition in L33 could yield duplicates
if solver_run.bundles != None:
total_bundles = randint(constraint.minimum, constraint.maximum)
selected_bundles = sample(solver_run.bundles, total_bundles)
total_bundle_items = 0
for bundle in selected_bundles:
con = dict(zip([item.id for item in solver_run.items],
[(getattr(item, bundle.type, False) == bundle.id)
for item in solver_run.items]))
problem += lpSum([con[item.id]
* items[item.id]
for item in solver_run.items]) == bundle.count, f'Bundle constraint for {bundle.type} ({bundle.id})'
total_bundle_items += bundle.count
# make sure all other items added to the form
# are not a part of any bundle
# currently only supports single bundle constraints, will need refactoring for multiple bundle constraints
elif attribute.type == 'bundle' and bundles:
total_bundle_items = sum(bundle.count for bundle in bundles)
for bundle in bundles:
con = dict(zip([item.id for item in solver_run.items],
[(getattr(item, attribute.id, None) == None)
for item in solver_run.items]))
[(getattr(item, bundle.type, False) == bundle.id)
for item in solver_run.items]))
problem += lpSum([con[item.id]
* items[item.id]
for item in solver_run.items]) == solver_run.total_form_items - total_bundle_items, f'Remaining items are not of a bundle type'
for item in solver_run.items]) == bundle.count, f'Bundle constraint for {bundle.type} ({bundle.id})'
# make sure all other items added to the form
# are not a part of any bundle
# currently only supports single bundle constraints, will need refactoring for multiple bundle constraints
con = dict(zip([item.id for item in solver_run.items],
[(getattr(item, attribute.id, None) == None)
for item in solver_run.items]))
problem += lpSum([con[item.id]
* items[item.id]
for item in solver_run.items]) == solver_run.total_form_items - total_bundle_items, f'Remaining items are not of a bundle type'
return problem
except ValueError as error:
logging.error(error)
raise ItemGenerationError("Bundle min and/or max larger than bundle amount provided", error.args[0])
def valid_bundle_combinations(total_form_items: int, total_bundles: int, min_bundles: int, bundles: list[Bundle], selected_bundle_combinations: list[list[Bundle]] = []) -> list[list[Bundle]]:
if total_bundles < min_bundles:
return selected_bundle_combinations
else:
# generate all bundle combinations
bundle_combinations = [list(combination) for combination in combinations(bundles, total_bundles)]
# iterate through all the combinations
# if the combination item count is less than or equal to
# the total items on a form, add it to selected bundles
for bundle_combination in bundle_combinations:
total_bundle_items = sum(bundle.count for bundle in bundle_combination)
if total_bundle_items <= total_form_items:
selected_bundle_combinations.append(bundle_combination)
# recurse to continue generating combinations
# all the way to the minimum amount of bundles allowed
return valid_bundle_combinations(total_form_items, total_bundles - 1, min_bundles, bundles, selected_bundle_combinations)

4
app/models/bundle.py
View File

@ -1,6 +1,10 @@
from pydantic import BaseModel
from typing import List
from models.item import Item
class Bundle(BaseModel):
id: int
count: int
items: List[Item]
type: str

18
app/models/solver_run.py
View File

@ -1,3 +1,5 @@
import logging
from pydantic import BaseModel
from typing import List, Optional
@ -20,17 +22,19 @@ class SolverRun(BaseModel):
advanced_options: Optional[AdvancedOptions]
engine: str
def get_item(self, item_id):
def get_item(self, item_id: int) -> Item or bool:
for item in self.items:
if str(item.id) == item_id:
return item
return False
def remove_items(self, items):
def remove_items(self, items: list[Item]) -> bool:
self.items = [item for item in self.items if item not in items]
return True
def generate_bundles(self):
logging.info('Generating Bundles...')
bundle_constraints = (constraint.reference_attribute for constraint in self.constraints if constraint.reference_attribute.type == 'bundle')
for bundle_constraint in bundle_constraints:
@ -53,16 +57,24 @@ class SolverRun(BaseModel):
self.bundles.append(Bundle(
id=attribute_id,
count=1,
items=[item],
type=type_attribute
))
else:
self.bundles[bundle_index].count += 1
self.bundles[bundle_index].items.append(item)
else:
self.bundles = [Bundle(
id=attribute_id,
count=1,
items=[item],
type=type_attribute
)]
def get_constraint(self, name):
def get_constraint(self, name: str) -> Constraint or None:
return next((constraint for constraint in self.constraints if constraint.reference_attribute.id == name), None)
# temp function until we build out bundles to more than just for cases
# for now it treats "bundle" attributes as a single unique constraint
def get_constraint_by_type(self, type: str) -> Constraint or None:
return next((constraint for constraint in self.constraints if constraint.reference_attribute.type == type), None)

123
app/services/loft_service.py
View File

@ -9,6 +9,7 @@ from models.solver_run import SolverRun
from models.solution import Solution
from models.form import Form
from models.item import Item
from models.bundle import Bundle
from services.base import Base
@ -25,7 +26,7 @@ class LoftService(Base):
logging.error(error)
self.result = self.stream_to_s3_bucket(ItemGenerationError("Provided params causing error in calculation results"))
def create_solver_run_from_attributes(self):
def create_solver_run_from_attributes(self) -> SolverRun:
logging.info('Retrieving attributes from message...')
# get s3 object
self.key = aws_helper.get_key_from_message(self.source)
@ -52,67 +53,95 @@ class LoftService(Base):
return solver_run
def generate_solution(self):
# unsolved solution
solution = Solution(
response_id=random.randint(100, 5000),
forms=[]
)
def generate_solution(self) -> Solution:
logging.info('Generating Solution...')
# counter for number of forms
f = 0
# setup vars
items = LpVariable.dicts(
"Item", [item.id for item in self.solver_run.items], lowBound=1, upBound=1, cat='Binary')
# check if problem request has bundles
bundle_constraint = self.solver_run.get_constraint_by_type('bundle')
# iterate for number of forms that require creation
# currently creates distinc forms with no item overlap
while f < self.solver_run.total_forms:
# setup vars
items = LpVariable.dicts(
"Item", [item.id for item in self.solver_run.items], lowBound=1, upBound=1, cat='Binary')
bundles = LpVariable.dicts(
"Bundle", [bundle.id for bundle in self.solver_run.bundles], lowBound=1, upBound=1, cat='Binary')
# unsolved solution
solution = Solution(
response_id=random.randint(100, 5000),
forms=[]
)
# initiate problem
problem = None
count = 0
if bundle_constraint:
# generate valid bundle combinations
bundle_combinations = solver_helper.valid_bundle_combinations(
self.solver_run.total_form_items,
int(bundle_constraint.maximum),
int(bundle_constraint.minimum),
self.solver_run.bundles)
problem_objection_functions = []
# create problem
problem = LpProblem("ata-form-generate", LpMinimize)
# dummy objective function, because it just makes things easier™
problem += lpSum([items[item.id]
for item in self.solver_run.items])
# constraints
problem += lpSum([items[item.id]
for item in self.solver_run.items]) == self.solver_run.total_form_items, 'Total form items'
# dynamic constraints
problem = solver_helper.build_constraints(self.solver_run, problem, items, bundles)
# multi-objective constraints
for target in self.solver_run.objective_function.tif_targets:
problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) >= target.value - 8, f'max tif theta ({target.theta}) target value {target.value}'
problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) <= target.value + 8, f'min tif theta ({target.theta}) target value {target.value}'
for target in self.solver_run.objective_function.tcc_targets:
problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) >= target.value - 20, f'max tcc theta ({target.theta}) target value {target.value}'
problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) <= target.value + 20, f'min tcc theta ({target.theta}) target value {target.value}'
# solve problem
problem.solve()
# scramble bundle_combinations to ensure distinctiveness for each form generated
random.shuffle(bundle_combinations)
for bundles in bundle_combinations:
problem = self.solve_problem(items, bundles)
# if optimal solution found, break loop
if LpStatus[problem.status] == 'Optimal':
break
else: # no bundles
problem = self.solve_problem(items)
# successfull form, increment and exit out of loop
f += 1
# add return items and create as a form
form_items = service_helper.solution_items(problem.variables(), self.solver_run)
# add form to solution
solution.forms.append(Form.create(form_items, self.solver_run, LpStatus[problem.status]))
# successfull form, increment
f += 1
return solution
def solve_problem(self, items: list[Item], bundles: list[Bundle] or None = None) -> LpProblem:
# create problem
problem = LpProblem("ata-form-generate", LpMinimize)
# dummy objective function, because it just makes things easier™
problem += lpSum([items[item.id]
for item in self.solver_run.items])
# constraints
problem += lpSum([items[item.id]
for item in self.solver_run.items]) == self.solver_run.total_form_items, 'Total form items'
# dynamic constraints
problem = solver_helper.build_constraints(self.solver_run, problem, items, bundles)
# multi-objective constraints
for target in self.solver_run.objective_function.tif_targets:
problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) >= target.value - 8, f'max tif theta ({target.theta}) target value {target.value}'
problem += lpSum([item.iif(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) <= target.value + 8, f'min tif theta ({target.theta}) target value {target.value}'
for target in self.solver_run.objective_function.tcc_targets:
problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) >= target.value - 20, f'max tcc theta ({target.theta}) target value {target.value}'
problem += lpSum([item.irf(self.solver_run, target.theta)*items[item.id]
for item in self.solver_run.items]) <= target.value + 20, f'min tcc theta ({target.theta}) target value {target.value}'
# solve problem
problem.solve()
return problem
return solution
def stream_to_s3_bucket(self, error = None):
self.file_name = f'{service_helper.key_to_uuid(self.key)}.csv'