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

added constant drift incrementing for tcc, tif values

Browse Source
This commit is contained in:
Joshua Burman 2022-02-12 03:43:37 -05:00
parent 46d3538690
commit f18e048081
6 changed files with 152 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
app/helpers/solver_helper.py
View File

@ -49,27 +49,6 @@ def build_constraints(solver_run: SolverRun, problem: LpProblem,
bundles[bundle.id] for bundle in solver_run.bundles bundles[bundle.id] for bundle in solver_run.bundles
]) == randint(int(constraint.minimum), ]) == randint(int(constraint.minimum),
int(constraint.maximum)) int(constraint.maximum))
# total_bundle_items = 0
# selected_bundles = get_random_bundles(solver_run.total_form_items, solver_run.bundles, int(constraint.minimum), int(constraint.maximum))
# 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
# 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'
logging.info('Constraints Created...') logging.info('Constraints Created...')
return problem return problem

2
app/main.py
View File

@ -24,7 +24,7 @@ class ServiceListener(SqsListener):
def main(): def main():
logging.info('Starting Solver Service (v1.1.2)...') logging.info('Starting Solver Service (v1.1.3)...')
listener = ServiceListener( listener = ServiceListener(
os.environ['SQS_QUEUE'], os.environ['SQS_QUEUE'],
region_name=os.environ['AWS_REGION'], region_name=os.environ['AWS_REGION'],

29
app/models/objective_function.py
View File

@ -12,3 +12,32 @@ class ObjectiveFunction(BaseModel):
tcc_targets: List[Target] tcc_targets: List[Target]
objective: AnyStr = "minimize" objective: AnyStr = "minimize"
weight: Dict = {'tif': 1, 'tcc': 1} weight: Dict = {'tif': 1, 'tcc': 1}
def increment_targets_drift(self,
limit: float or bool,
all: bool = False,
amount: float = 0.1,
targets: list[Target] = []) -> bool:
if all:
for target in self.tif_targets:
target.drift = round(target.drift + amount, 2)
for target in self.tcc_targets:
target.drift = round(target.drift + amount, 2)
else:
for target in targets:
target.drift = round(target.drift + amount, 2)
print(self.tif_targets)
print(self.tcc_targets)
return amount
def minimum_drift(self) -> float:
minimum_drift = 0.0
for target in self.all_targets():
if target.drift < minimum_drift:
minimum_drift = target.drift
return minimum_drift
def all_targets(self) -> list[Target]:
return self.tif_targets + self.tcc_targets

3
app/models/solver_run.py
View File

@ -1,5 +1,5 @@
from pydantic import BaseModel from pydantic import BaseModel
from typing import List, Optional from typing import List, Literal, Optional
import logging import logging
@ -20,6 +20,7 @@ class SolverRun(BaseModel):
total_form_items: int total_form_items: int
total_forms: int = 1 total_forms: int = 1
theta_cut_score: float = 0.00 theta_cut_score: float = 0.00
drift_style: Literal['constant', 'variable'] = 'constant'
advanced_options: Optional[AdvancedOptions] advanced_options: Optional[AdvancedOptions]
engine: str engine: str

1
app/models/target.py
View File

@ -6,3 +6,4 @@ class Target(BaseModel):
theta: float theta: float
value: float value: float
result: Optional[float] result: Optional[float]
drift: float = 0.0

205
app/services/loft_service.py
View File

@ -122,99 +122,132 @@ class LoftService(Base):
# iterate for number of forms that require creation # iterate for number of forms that require creation
# currently creates distinc forms with no item overlap # currently creates distinc forms with no item overlap
while f < self.solver_run.total_forms: while f < self.solver_run.total_forms:
# setup vars # currently constant drift is supported
items = LpVariable.dicts( # plan to support variable drift
"Item", [item.id for item in self.solver_run.items], problem = None
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')
# create problem # allow target drift to increment to keep trying
problem = LpProblem("ata-form-generate", LpMinimize) # once limit has been reached loop will stop
problem_objective_functions = [] # at this point the latest solve attempt will be used
# though likely to be infeasible
while self.solver_run.objective_function.minimum_drift() <= 2.0:
# setup vars
items = LpVariable.dicts(
"Item", [item.id for item in self.solver_run.items],
lowBound=0,
upBound=1,
cat='Binary')
bundles = LpVariable.dicts(
"Bundle",
[bundle.id for bundle in self.solver_run.bundles],
lowBound=0,
upBound=1,
cat='Binary')
# dummy objective function, because it just makes things easier™ # create problem
# problem += lpSum( problem = LpProblem("ata-form-generate", LpMinimize)
# [items[item.id] for item in self.solver_run.items]) problem_objective_functions = []
# constraints # dummy objective function, because it just makes things easier™
# problem += lpSum([items[item.id] # problem += lpSum(
# for item in self.solver_run.items]) == self.solver_run.total_form_items, 'Total form items' # [items[item.id] for item in self.solver_run.items])
problem += lpSum(
[
bundle.count * bundles[bundle.id]
for bundle in self.solver_run.bundles
] + [
1 * items[item.id]
for item in self.solver_run.unbundled_items()
]
) == self.solver_run.total_form_items, 'Total bundle form items for form'
# dynamic constraints # constraints
problem = solver_helper.build_constraints(self.solver_run, problem, # problem += lpSum([items[item.id]
items, bundles) # for item in self.solver_run.items]) == self.solver_run.total_form_items, 'Total form items'
problem += lpSum(
[
bundle.count * bundles[bundle.id]
for bundle in self.solver_run.bundles
] + [
1 * items[item.id]
for item in self.solver_run.unbundled_items()
]
) == self.solver_run.total_form_items, 'Total bundle form items for form'
# multi-objective constraints # dynamic constraints
logging.info('Creating TIF and TCC constraints') problem = solver_helper.build_constraints(
for target in self.solver_run.objective_function.tif_targets: self.solver_run, problem, items, bundles)
tif = lpSum([ # multi-objective constraints
bundle.tif(self.solver_run.irt_model, target.theta) * logging.info('Creating TIF and TCC constraints')
bundles[bundle.id] for bundle in self.solver_run.bundles for target in self.solver_run.objective_function.tif_targets:
] + [
item.iif(self.solver_run, target.theta) * items[item.id]
for item in self.solver_run.items
])
problem_objective_functions.append(tif)
# problem += lpSum([
# bundle.tif(self.solver_run.irt_model, target.theta) *
# bundles[bundle.id] for bundle in self.solver_run.bundles
# ] + [
# item.iif(self.solver_run, target.theta) * items[item.id]
# for item in self.solver_run.items
# ]) >= target.value - 5, f'max tif theta ({target.theta}) target value {target.value}'
# problem += lpSum([
# bundle.tif(self.solver_run.irt_model, target.theta) *
# bundles[bundle.id] for bundle in self.solver_run.bundles
# ] + [
# item.iif(self.solver_run, target.theta) * items[item.id]
# for item in self.solver_run.items
# ]) <= target.value + 5, f'min tif theta ({target.theta}) target value {target.value}'
for target in self.solver_run.objective_function.tcc_targets: tif = lpSum([
tcc = lpSum([ bundle.tif(self.solver_run.irt_model, target.theta) *
bundle.trf(self.solver_run.irt_model, target.theta) * bundles[bundle.id]
bundles[bundle.id] for bundle in self.solver_run.bundles for bundle in self.solver_run.bundles
] + [ ] + [
item.irf(self.solver_run, target.theta) * items[item.id] item.iif(self.solver_run, target.theta) *
for item in self.solver_run.items items[item.id] for item in self.solver_run.items
]) ])
problem_objective_functions.append(tcc) problem_objective_functions.append(tif)
# problem += lpSum([ problem += lpSum([
# bundle.trf(self.solver_run.irt_model, target.theta) * bundle.tif(self.solver_run.irt_model, target.theta) *
# bundles[bundle.id] for bundle in self.solver_run.bundles bundles[bundle.id]
# ] + [ for bundle in self.solver_run.bundles
# item.irf(self.solver_run, target.theta) * items[item.id] ] + [
# for item in self.solver_run.items item.iif(self.solver_run, target.theta) *
# ]) >= target.value - 15, f'max tcc theta ({target.theta}) target value {target.value}' items[item.id] for item in self.solver_run.items
# problem += lpSum([ ]) >= target.value - target.value * target.drift, f'max tif theta ({target.theta}) target value {target.value}'
# bundle.trf(self.solver_run.irt_model, target.theta) * problem += lpSum([
# bundles[bundle.id] for bundle in self.solver_run.bundles bundle.tif(self.solver_run.irt_model, target.theta) *
# ] + [ bundles[bundle.id]
# item.irf(self.solver_run, target.theta) * items[item.id] for bundle in self.solver_run.bundles
# for item in self.solver_run.items ] + [
# ]) <= target.value + 15, f'min tcc theta ({target.theta}) target value {target.value}' item.iif(self.solver_run, target.theta) *
items[item.id] for item in self.solver_run.items
]) <= target.value + target.value * target.drift, f'min tif theta ({target.theta}) target value {target.value}'
# solve problem for target in self.solver_run.objective_function.tcc_targets:
logging.info('Solving...') tcc = lpSum([
# problem.solve() bundle.trf(self.solver_run.irt_model, target.theta) *
problem.sequentialSolve(problem_objective_functions) bundles[bundle.id]
logging.info('Solved...generating form and adding to solution') for bundle in self.solver_run.bundles
] + [
item.irf(self.solver_run, target.theta) *
items[item.id] for item in self.solver_run.items
])
problem_objective_functions.append(tcc)
problem += lpSum([
bundle.trf(self.solver_run.irt_model, target.theta) *
bundles[bundle.id]
for bundle in self.solver_run.bundles
] + [
item.irf(self.solver_run, target.theta) *
items[item.id] for item in self.solver_run.items
]) >= target.value - target.value * target.drift, f'max tcc theta ({target.theta}) target value {target.value}'
problem += lpSum([
bundle.trf(self.solver_run.irt_model, target.theta) *
bundles[bundle.id]
for bundle in self.solver_run.bundles
] + [
item.irf(self.solver_run, target.theta) *
items[item.id] for item in self.solver_run.items
]) <= target.value + target.value * target.drift, f'min tcc theta ({target.theta}) target value {target.value}'
# solve problem
logging.info('Solving...')
# problem.solve()
problem.sequentialSolve(problem_objective_functions)
# optimal solution found!
if LpStatus[problem.status] == 'Optimal':
logging.info(
f'Problem solved...generating Form and adding to Solution with {self.solver_run.drift_style} drift \n\
tif target drift: \n\
{["theta @" + str(target.theta) + " - " + str(target.drift) for target in self.solver_run.objective_function.tif_targets]} \n\
tcc target drift: \n\
{["theta @" + str(target.theta) + " - " + str(target.drift) for target in self.solver_run.objective_function.tcc_targets]}'
)
break
else:
# increment drift to attempt to find optimal solution
increment = self.solver_run.objective_function.increment_targets_drift(
2.0, True)
logging.info(
f'Non Optimal Solution...widening Target ranges to {increment} using {self.solver_run.drift_style} drift'
)
# add return items and create as a form # add return items and create as a form
form_items = service_helper.solution_items(problem.variables(), form_items = service_helper.solution_items(problem.variables(),
@ -224,7 +257,7 @@ class LoftService(Base):
solution.forms.append( solution.forms.append(
Form.create(form_items, self.solver_run, Form.create(form_items, self.solver_run,
LpStatus[problem.status])) LpStatus[problem.status]))
logging.info('Form generated and added to solution...') logging.info('Form generated and added to Solution...')
# successfull form, increment # successfull form, increment
f += 1 f += 1