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

leet the solver drift

Browse Source
This commit is contained in:
Adrian Manteza 2022-03-16 02:51:39 +00:00
parent cc704d97da
commit 812e7aaad9
4 changed files with 67 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
app/models/bundle.py
View File

@ -15,14 +15,14 @@ class Bundle(BaseModel):
type: str
def tif(self, irt_model: IRTModel, theta: float) -> float:
return 0.9
# return TestInformationFunction(irt_model).calculate(self.items,
# theta=theta)
val = TestInformationFunction(irt_model).calculate(self.items, theta=theta)
return round(val, 2)
def trf(self, irt_model: IRTModel, theta: float) -> float:
return 0.9
# return TestResponseFunction(irt_model).calculate(self.items,
# theta=theta)
val = TestResponseFunction(irt_model).calculate(self.items, theta=theta)
return round(val, 2)
def tif_trf_sum(self, solver_run):
return self.__trf_sum(solver_run) + self.__tif_sum(solver_run)

12
app/models/item.py
View File

@ -14,14 +14,14 @@ class Item(BaseModel):
b_param: float = 0.00
def iif(self, solver_run, theta):
return 0.9
# return ItemInformationFunction(solver_run.irt_model).calculate(
# b_param=self.b_param, theta=theta)
val = ItemInformationFunction(solver_run.irt_model).calculate(b_param=self.b_param, theta=theta)
return round(val, 2)
def irf(self, solver_run, theta):
return 0.9
# return ItemResponseFunction(solver_run.irt_model).calculate(
# b_param=self.b_param, theta=theta)
val = ItemResponseFunction(solver_run.irt_model).calculate(b_param=self.b_param, theta=theta)
return round(val, 2)
def get_attribute(self, ref_attribute):
for attribute in self.attributes:

10
app/models/target.py
View File

@ -9,8 +9,14 @@ class Target(BaseModel):
@classmethod
def max_drift(cls):
return 10 # 10% elasticity
return 120 # let it drift...
@classmethod
def max_drift_increment(cls):
return 1 # 1%
return 10 # 10%
def minimum(self, drift_percent = 0.0) -> float:
return round(self.value - (self.value * drift_percent), 2)
def maximum(self, drift_percent = 0.0) -> float:
return round(self.value + (self.value * drift_percent), 2)

100
app/services/loft_service.py
View File

@ -86,13 +86,13 @@ class LoftService(Base):
problem = LpProblem('ata-form-generate', LpMinimize)
# objective function
problem += lpSum(
[item.iif_irf_sum(self.solver_run) * items[item.id] for item in self.solver_run.unbundled_items()]
+
[bundle.tif_trf_sum(self.solver_run) * bundles[bundle.id] for bundle in self.solver_run.bundles]
)
# problem += lpSum(
# [item.iif_irf_sum(self.solver_run) * items[item.id] for item in self.solver_run.unbundled_items()]
# +
# [bundle.tif_trf_sum(self.solver_run) * bundles[bundle.id] for bundle in self.solver_run.bundles]
# )
# problem += lpSum([items[item.id] for item in self.solver_run.unbundled_items()] + [bundles[bundle.id] for bundle in self.solver_run.bundles])
# problem += lpSum([items[item.id] for item in self.solver_run.items])
problem += lpSum([items[item.id] for item in self.solver_run.items])
# Form Constraints
problem += lpSum(
@ -111,93 +111,87 @@ class LoftService(Base):
# ) == self.solver_run.total_form_items, f'Total bundle form items for form {form_number}'
# Dynamic constraints.. currently we only support Metadata and Bundles(Cases/Passages)
problem = solver_helper.build_constraints(self.solver_run, problem, items, bundles)
# problem = solver_helper.build_constraints(self.solver_run, problem, items, bundles)
logging.info('Creating TIF and TCC Elastic constraints')
# Behold our very own Elastic constraints!
for tif_target in self.solver_run.objective_function.tif_targets:
problem += lpSum(
[
bundle.tif(self.solver_run.irt_model, tif_target.theta) * bundles[bundle.id]
for bundle in self.solver_run.bundles
] +
[
item.iif(self.solver_run, tif_target.theta) * items[item.id]
for item in self.solver_run.unbundled_items()
]
) >= tif_target.value - (tif_target.value * drift_percent)
problem += lpSum(
[
bundle.tif(self.solver_run.irt_model, tif_target.theta) * bundles[bundle.id]
for bundle in self.solver_run.bundles
] +
[
item.iif(self.solver_run, tif_target.theta) * items[item.id]
for item in self.solver_run.unbundled_items()
]
) <= tif_target.value + (tif_target.value * drift_percent)
# problem += lpSum(
# [
# bundle.tif(self.solver_run.irt_model, tif_target.theta) * bundles[bundle.id]
# for bundle in self.solver_run.bundles
# ] +
# [
# item.iif(self.solver_run, tif_target.theta) * items[item.id]
# for item in self.solver_run.items
# for item in self.solver_run.unbundled_items()
# ]
# ) >= tif_target.value - (tif_target.value * drift_percent)
# problem += lpSum(
# [
# bundle.tif(self.solver_run.irt_model, tif_target.theta) * bundles[bundle.id]
# for bundle in self.solver_run.bundles
# ] +
# [
# item.iif(self.solver_run, tif_target.theta) * items[item.id]
# for item in self.solver_run.items
# for item in self.solver_run.unbundled_items()
# ]
# ) <= tif_target.value + (tif_target.value * drift_percent)
for tcc_target in self.solver_run.objective_function.tcc_targets:
problem += lpSum(
[
bundle.trf(self.solver_run.irt_model, tcc_target.theta) * bundles[bundle.id]
for bundle in self.solver_run.bundles
] +
[
item.irf(self.solver_run, tcc_target.theta) * items[item.id]
for item in self.solver_run.unbundled_items()
item.iif(self.solver_run, tif_target.theta) * items[item.id]
for item in self.solver_run.items
]
) >= tcc_target.value - (tcc_target.value * drift_percent)
) >= tif_target.minimum(drift_percent)
problem += lpSum(
[
bundle.trf(self.solver_run.irt_model, tcc_target.theta) * bundles[bundle.id]
for bundle in self.solver_run.bundles
] +
[
item.irf(self.solver_run, tcc_target.theta) * items[item.id]
for item in self.solver_run.unbundled_items()
item.iif(self.solver_run, tif_target.theta) * items[item.id]
for item in self.solver_run.items
]
) <= tcc_target.value + (tcc_target.value * drift_percent)
) <= tif_target.maximum(drift_percent)
for tcc_target in self.solver_run.objective_function.tcc_targets:
# problem += lpSum(
# [
# bundle.trf(self.solver_run.irt_model, tcc_target.theta) * bundles[bundle.id]
# for bundle in self.solver_run.bundles
# ] +
# [
# item.irf(self.solver_run, tcc_target.theta) * items[item.id]
# for item in self.solver_run.items
# for item in self.solver_run.unbundled_items()
# ]
# ) >= tcc_target.value - (tcc_target.value * drift_percent)
# problem += lpSum(
# [
# bundle.trf(self.solver_run.irt_model, tcc_target.theta) * bundles[bundle.id]
# for bundle in self.solver_run.bundles
# ] +
# [
# item.irf(self.solver_run, tcc_target.theta) * items[item.id]
# for item in self.solver_run.items
# for item in self.solver_run.unbundled_items()
# ]
# ) <= tcc_target.value + (tcc_target.value * drift_percent)
problem += lpSum(
[
item.irf(self.solver_run, tcc_target.theta) * items[item.id]
for item in self.solver_run.items
]
) >= tcc_target.minimum(drift_percent)
problem += lpSum(
[
item.irf(self.solver_run, tcc_target.theta) * items[item.id]
for item in self.solver_run.items
]
) <= tcc_target.maximum(drift_percent)
logging.info(f'Solving for Form {form_number} with a drift of {current_drift}%')
problem.solve()
if LpStatus[problem.status] == 'Infeasible':
logging.info(f'attempt infeasible for drift of {current_drift}%')
# print(problem.objective.value())
# print(problem.constraints)
# print(problem.objective)
if current_drift == Target.max_drift(): # this is the last attempt, so lets finalize the solution
for v in problem.variables(): print(v.name, "=", v.varValue);