RecursionError 使用 PuLP 优化

Question

I'm trying slowly scale up an optimization problem, and on the stage where I'm trying to bring a user inputted value into a comparison constraint. However, a recursion error is being thrown. I'm not sure I understand why a recursion error is happening and how to fix it (see first line of Constraint section). It works when I hard code a value, but when I use the user input it throws an error.

Also as a bonus, if anyone knows how to loop the constraint I would be very grateful. I have been banging my head on this for a while. Eventually this will have 10 employees and up to 55 different parts, so I figure looping through when adding constraints would be much easier. I've look online, but haven't found anything help yet.

# Initial User Input
total_parts = int(input("Enter number of different parts: "))
partno = []
quantity = []
for i in range(total_parts):
    pn = input("Enter Part Number : ").strip()
    qty = input("Enter Qty of Part Number : ")
    partno.append(pn)
    quantity.append(qty)

# Pulp Model
model = pulp.LpProblem("Part production", pulp.LpMinimize)

# Construct decision variable lists
part_numbers = partno
employees = ['Employee A', 'Employee B', 'Employee C']

qty_produced = pulp.LpVariable.dicts("production",
                                     ((i, j) for i in part_numbers for j in employees),
                                     lowBound=0,
                                     cat='Continuous')
# Objective Function
model += ((
    (pulp.lpSum(
        ((10 * qty_produced[part_numbers[0], employees[0]])/.5)
        +((10 * qty_produced[part_numbers[0], employees[1]])/.85)
       + ((10 * qty_produced[part_numbers[0], employees[2]])/.65)
        +((30 * qty_produced[part_numbers[1], employees[0]])/.85)
       + ((30 * qty_produced[part_numbers[1], employees[1]])/.75)
        +((30 * qty_produced[part_numbers[1], employees[2]])/.95)
))/6))

# Constraints
model += pulp.lpSum([qty_produced[part_numbers[0], j] for j in employees]) >= quantity[0]
model += pulp.lpSum([qty_produced[part_numbers[1], j] for j in employees]) >= 10
model += ((10 * qty_produced[part_numbers[0], employees[0]])/.5) + ((30 * qty_produced[part_numbers[1], employees[0]])/.85) <= 530
model += ((10 * qty_produced[part_numbers[0], employees[1]])/.5) + ((30 * qty_produced[part_numbers[1], employees[1]])/.85) <= 530
model += ((10 * qty_produced[part_numbers[0], employees[2]])/.5) + ((30 * qty_produced[part_numbers[1], employees[2]])/.85) <= 530

# Solve problem
model.solve()
pulp.LpStatus[model.status]

for var in qty_produced:
    var_value = qty_produced[var].varValue
    print("The quantity of {1} produced by {0} is {2}".format(var[1], var[0], var_value))

avg_time = pulp.value(model.objective)

Answer 1

You are on the right track here, but a few issues. I'm not sure where you would pop a recursion error here. You'd have to post the full code and the error message w/ line reference for help on that.

On your inputs... I don't see where you are converting qty to an integer? Recall, all keyboard inputs are taken in as strings, so a conversion is necessary. While you are debugging though, it would be wisest just to make some dictionaries at the start to hold the data so you are not repeatedly typing it in. Later, you can construct the same dictionaries/lists from keyboard inputs on the fly if desired. Also include your other model parameters such as the coefficients you are using in your obj function and the quantity limits. That will allow you to clean up your constraints. Here is an idea to show what I'm thinking...

import pulp

## Data

employees = {'bob', 'cindy', 'tom'}
parts = {'A19', 'X22'}
max_quantities = {  'A19': 200,
                    'X22': 150}

## Model
prob = pulp.LpProblem('sample', pulp.LpMinimize)

X = pulp.LpVariable.dicts("produce", [(e, p) for e in employees for p in parts],
                            lowBound=0, cat="Integer")

# max_production
for p in parts:
    prob += pulp.lpSum(X[e, p] for e in employees) <= max_quantities[p]

print(prob)