def main(argc, argv): from amplpy import AMPL, DataFrame os.chdir(os.path.dirname(__file__) or os.curdir) try: ampl = AMPL() ampl.eval('set CITIES; set LINKS within (CITIES cross CITIES);') ampl.eval('param cost {LINKS} >= 0; param capacity {LINKS} >= 0;') ampl.eval('data; set CITIES := PITT NE SE BOS EWR BWI ATL MCO;') cost = [2.5, 3.5, 1.7, 0.7, 1.3, 1.3, 0.8, 0.2, 2.1] capacity = [250, 250, 100, 100, 100, 100, 100, 100, 100] LinksFrom = ['PITT', 'PITT', 'NE', 'NE', 'NE', 'SE', 'SE', 'SE', 'SE'] LinksTo = ['NE', 'SE', 'BOS', 'EWR', 'BWI', 'EWR', 'BWI', 'ATL', 'MCO'] df = DataFrame(('LINKSFrom', 'LINKSTo'), ('cost', 'capacity')) df.setColumn('LINKSFrom', LinksFrom) df.setColumn('LINKSTo', LinksTo) df.setColumn('cost', cost) df.setColumn('capacity', capacity) print(df) ampl.setData(df, 'LINKS') except Exception as e: print(e) raise
def main(argc, argv): from amplpy import AMPL, DataFrame os.chdir(os.path.dirname(__file__) or os.curdir) try: # Create an AMPL instance ampl = AMPL() """ # If the AMPL installation directory is not in the system search path: from amplpy import Environment ampl = AMPL( Environment('full path to the AMPL installation directory')) """ ampl.eval('set CITIES; set LINKS within (CITIES cross CITIES);') ampl.eval('param cost {LINKS} >= 0; param capacity {LINKS} >= 0;') ampl.eval('data; set CITIES := PITT NE SE BOS EWR BWI ATL MCO;') cost = [2.5, 3.5, 1.7, 0.7, 1.3, 1.3, 0.8, 0.2, 2.1] capacity = [250, 250, 100, 100, 100, 100, 100, 100, 100] LinksFrom = ['PITT', 'PITT', 'NE', 'NE', 'NE', 'SE', 'SE', 'SE', 'SE'] LinksTo = ['NE', 'SE', 'BOS', 'EWR', 'BWI', 'EWR', 'BWI', 'ATL', 'MCO'] df = DataFrame(('LINKSFrom', 'LINKSTo'), ('cost', 'capacity')) df.setColumn('LINKSFrom', LinksFrom) df.setColumn('LINKSTo', LinksTo) df.setColumn('cost', cost) df.setColumn('capacity', capacity) print(df) ampl.setData(df, 'LINKS') except Exception as e: print(e) raise
def __init__(self): self._ampl = AMPL() """ Use the CPLEX solver driver for linear programming problems. """ self._ampl.setOption('solver', 'cplex') """ Prevent using the current values as well as the statuses of the variables in constructing the starting point at the next solve. """ self._ampl.setOption('reset_initial_guesses', True) """ The major use of solver status values from an optimal basic solution is to provide a good starting point for the next optimization run. The option send_statuses, when set to True, instructs AMPL to include statuses with the information about variables sent to the solver at each solve. """ self._ampl.setOption('send_statuses', True) self._n_iterations: int = 0 """ Add class that handles AMPL outputs """ self._ampl.setOutputHandler(AMPLOutputHandler(self.set_n_iterations)) """ Add class that handles errors and warnings that may occur during the AMPL execution. """ self._ampl.setErrorHandler(AMPLErrorHandler())
def solve(dat): """ core solving routine :param dat: a good ticdat for the input_schema :return: a good ticdat for the solution_schema, or None """ assert input_schema.good_tic_dat_object(dat) assert not input_schema.find_foreign_key_failures(dat) assert not input_schema.find_data_type_failures(dat) assert not input_schema.find_data_row_failures(dat) # use default parameters, unless they are overridden by user-supplied parameters full_parameters = dict( default_parameters, **{k: v["Value"] for k, v in dat.parameters.items()}) sln = solution_schema.TicDat() # create an empty solution' ampl_dat = input_schema.copy_to_ampl( dat, excluded_tables=set(input_schema.all_tables).difference( {"load_amounts"})) # solve a distinct MIP for each pair of (# of one-way-trips, amount leftover) for number_trips, amount_leftover in product(dat.number_of_one_way_trips, dat.amount_leftover): ampl = AMPL() ampl.setOption('solver', 'gurobi') # use the ampl_format function for AMPL friendly key-named text substitutions ampl.eval( ampl_format(""" set LOAD_AMTS; var Num_Visits {LOAD_AMTS} integer >= 0; var Amt_Leftover >= {{amount_leftover_lb}}, <= {{amount_leftover_ub}}; minimize Total_Visits: sum {la in LOAD_AMTS} Num_Visits[la]; subj to Set_Amt_Leftover: Amt_Leftover = sum {la in LOAD_AMTS} la * Num_Visits[la] - {{one_way_price}} * {{number_trips}};""", number_trips=number_trips, one_way_price=full_parameters["One Way Price"], amount_leftover_lb=amount_leftover if full_parameters["Amount Leftover Constraint"] == "Equality" else 0, amount_leftover_ub=amount_leftover)) input_schema.set_ampl_data(ampl_dat, ampl, {"load_amounts": "LOAD_AMTS"}) ampl.solve() if ampl.getValue("solve_result") != "infeasible": # store the results if and only if the model is feasible for la, x in ampl.getVariable( "Num_Visits").getValues().toDict().items(): if round(x) > 0: sln.load_amount_details[number_trips, amount_leftover, la] = round(x) sln.load_amount_summary[number_trips, amount_leftover]["Number Of Visits"]\ += round(x) return sln
def run_ampl_model(self, data): # Intiialize AMPL choose solver and load model ampl = AMPL() ampl.eval('option solver cplex;') ampl.read('model/ampl/model.mod') # Generate and load temporary data file data_file = self.generate_temp_data_file(data) ampl.readData(data_file.name) data_file.close() ampl.solve() return ampl
def main(argc, argv): from amplpy import AMPL os.chdir(os.path.dirname(__file__) or os.curdir) try: # Create an AMPL instance ampl = AMPL() # Get the value of the option presolve and print presolve = ampl.getOption('presolve') print("AMPL presolve is", presolve) # Set the value to false (maps to 0) ampl.setOption('presolve', False) # Get the value of the option presolve and print presolve = ampl.getOption('presolve') print("AMPL presolve is now", presolve) # Check whether an option with a specified name # exists value = ampl.getOption('solver') if value is not None: print("Option solver exists and has value:", value) # Check again, this time failing value = ampl.getOption('s_o_l_v_e_r') if value is None: print("Option s_o_l_v_e_r does not exist!") except Exception as e: print(e) raise
def tsp_model(tsp_data, enable_mtz=True): from amplpy import AMPL from math import sqrt ampl = AMPL() ampl.eval(''' param n; set V := 1..n; set A := {(i,j) in V cross V : i != j}; param c{A} >= 0 default Infinity; var x{A}, binary; var u{V} >= 0; minimize total: sum{(i,j) in A} c[i,j] * x[i,j]; s.t. enter{j in V}: sum{i in V: i != j} x[i, j] == 1; s.t. leave{i in V}: sum{j in V: j != i} x[i, j] == 1; ''') if enable_mtz: ampl.eval(''' # subtour elimination Miller, Tucker and Zemlin (MTZ) (1960) subject to MTZ{(i,j) in A: i != 1}: u[i]-u[j] + (n-1)*x[i,j] <= n-2; ''') n, xs, ys = load_tsp_data(tsp_data) dist = {(i + 1, j + 1): sqrt((xs[j] - xs[i])**2 + (ys[j] - ys[i])**2) for i in range(n) for j in range(n) if i != j} ampl.param['n'] = n ampl.param['c'] = dist return ampl
def testEnvironment(self): from amplpy import Environment, AMPL env1 = Environment() env2 = Environment(os.curdir) self.assertEqual(env2.getBinDir(), os.curdir) env1.setBinDir(env2.getBinDir()) self.assertEqual(env1.getBinDir(), env1.getBinDir()) self.assertEqual(len(dict(env1)), len(list(env1))) self.assertEqual(list(sorted(dict(env1).items())), list(sorted(env1))) env1['MyEnvVar'] = 'TEST' self.assertEqual(env1['MyEnvVar'], 'TEST') self.assertEqual(env2['MyEnvVar'], None) d = dict(env1) self.assertEqual(d['MyEnvVar'], 'TEST') ampl = AMPL(Environment()) ampl.close()
def test_environment(self): from amplpy import Environment, AMPL env1 = Environment() env2 = Environment(os.curdir) self.assertEqual(env2.get_bin_dir(), os.curdir) env1.set_bin_dir(env2.get_bin_dir()) self.assertEqual(env1.get_bin_dir(), env1.get_bin_dir()) self.assertEqual(len(dict(env1)), len(list(env1))) self.assertEqual(list(sorted(dict(env1).items())), list(sorted(env1))) env1["MyEnvVar"] = "TEST" self.assertEqual(env1["MyEnvVar"], "TEST") self.assertEqual(env2["MyEnvVar"], None) d = dict(env1) self.assertEqual(d["MyEnvVar"], "TEST") ampl = AMPL(Environment()) ampl.close()
def amplSubTourElimination(ampl: AMPL): # Add the constraint and the needed parameters subToursAMPL = """param nSubtours >= 0 integer, default 0; set SUB {1..nSubtours} within NODES; subject to Subtour_Elimination {k in 1..nSubtours}: sum {i in SUB[k], j in NODES diff SUB[k]} if (i,j) in PAIRS then X[i,j] else X[j,i] >= 2;""" ampl.eval(subToursAMPL) AMPLnSubtours = ampl.getParameter("nSubtours") AMPLSubtours = ampl.getSet("SUB") allsubtours = list() while True: # Repeat until the solution contains only one tour ampl.solve() # Get solution ARCS = ampl.getData("{(i,j) in PAIRS : X[i,j]>0} X[i,j];") ARCS = set([(i, j) for (i, j, k) in ARCS.toList()]) nodes = NODES.copy() subtours = findSubTours(ARCS, nodes) # If we have only one tour, the solution is valid if len(subtours) <= 1: break if PLOTSUBTOURS: plotTours(subtours, CPOINTS) # Else add the current tours to the list of subtours allsubtours.extend(subtours) # And add those to the constraints by assigning the values to # the parameter and the set AMPLnSubtours.set(len(allsubtours)) for (i, tour) in enumerate(allsubtours): AMPLSubtours[i + 1].setValues(tour)
def get_trajectory_regularised(params, ampl_mdl_path, hide_solver_output=True): ampl = AMPL() ampl.read(ampl_mdl_path) for lbl, val in params.items(): _ampl_set_param(ampl, lbl, val) _ampl_set_param(ampl, 'reg', 0) # no regularisation _ampl_solve(ampl, hide_solver_output) optimal_sol_found = _ampl_optimal_sol_found(ampl) traj = None objective = None optimal_sol_found_reg = False if optimal_sol_found: _ampl_set_param(ampl, 'reg', 1) # regularisation _ampl_solve(ampl, hide_solver_output) optimal_sol_found_reg = _ampl_optimal_sol_found(ampl) if optimal_sol_found_reg: traj = _extract_trajectory_from_solver(ampl) objective = ampl.getObjective('myobjective').value() ampl.close() return optimal_sol_found_reg, traj, objective
def __init__(self, data, model_type, relax=False, time_limit=600): self.dat = data self.ampl = AMPL() self.ampl.setOption('solver', 'cplex') self.ampl.setOption('cplex_options', 'timelimit={:d} return_mipgap=1 bestbound memoryemphasis=1'.format(time_limit)) self.relax = relax if relax: self.ampl.setOption('relax_integrality', 1) if model_type == "pv": self.ampl.read('ampl_models/pos_variables.mod') elif model_type == "ct": self.ampl.read('ampl_models/conc_time.mod') else: print("Invalid model_type") return self.bind_data()
def solverSubTourElimination(ampl: AMPL, solver): global xvars, xinverse, vertices # Export the model using ampls model = ampl.exportModel(solver) model.enableLazyConstraints() # Get the global maps between solver vars and AMPL entities varMap = model.getVarMapFiltered("X") inverse = model.getVarMapInverse() xvars = {index: var2tuple(var)[1:] for var, index in varMap.items()} xinverse = {var2tuple(var)[1:]: index for index, var in inverse.items()} vertices = list( sorted( set([x[0] for x in xvars.values()] + [x[1] for x in xvars.values()]))) # Assign the callback callback = MyCallback() model.setCallback(callback) # Start the optimization model.optimize() # Import the solution back to AMPL ampl.importSolution(model)
def main(argc, argv): # You can install amplpy with "python -m pip install amplpy" from amplpy import AMPL os.chdir(os.path.dirname(__file__) or os.curdir) # Create an AMPL instance ampl = AMPL() """ # If the AMPL installation directory is not in the system search path: from amplpy import Environment ampl = AMPL( Environment('full path to the AMPL installation directory')) """ # Get the value of the option presolve and print presolve = ampl.get_option("presolve") print("AMPL presolve is", presolve) # Set the value to false (maps to 0) ampl.set_option("presolve", False) # Get the value of the option presolve and print presolve = ampl.get_option("presolve") print("AMPL presolve is now", presolve) # Check whether an option with a specified name # exists value = ampl.get_option("solver") if value is not None: print("Option solver exists and has value:", value) # Check again, this time failing value = ampl.get_option("s_o_l_v_e_r") if value is None: print("Option s_o_l_v_e_r does not exist!")
def get_trajectory(params, ampl_mdl_path, hide_solver_output=True): ampl = AMPL( ) # ampl installation directory should be in system search path # .mod file ampl.read(ampl_mdl_path) # set parameter values for lbl, val in params.items(): _ampl_set_param(ampl, lbl, val) _ampl_solve(ampl, hide_solver_output) optimal_sol_found = _ampl_optimal_sol_found(ampl) traj = None objective = None if optimal_sol_found: traj = _extract_trajectory_from_solver(ampl) objective = ampl.getObjective('myobjective').value() ampl.close() return optimal_sol_found, traj, objective
def call_ampl(dat): ampl = AMPL() ampl.read('Base.md') ampl.setOption('solver', 'cplex') n = ampl.getParameter('n') n.set(dat['n']) cx = ampl.getParameter('cx') cx.setValues(dat['cx']) cy = ampl.getParameter('cy') cy.setValues(dat['cy']) ampl.getOutput('solve;') fo = ampl.getObjective('fo').value() x = ampl.getVariable('x') rota = [] for i in range(dat['n']): for j in range(dat['n']): if j != i: if x[i, j].value() > 0.9: rota.append(j) return (fo, rota)
ampl.reset() ampl.read('/Users/jonathan/Desktop/169projectPEnvy.mod') ampl.readData( "/Users/jonathan/Desktop/random_data/{}ppl{}obj_heuristic.dat".format( ppl, obj)) ampl.setOption('solver', 'cplex') start_time = time.time() ampl.solve() finish_time = time.time() p_envy = ampl.getObjective('p_envy').value() return p_envy, finish_time - start_time ampl = AMPL( Environment( "/Users/jonathan/Documents/files/amplide.macosx64/amplide.macosx64")) with open('part4.csv', 'a', newline='') as csvfile: fieldnames = [ 'Number of People', 'Number of Items', 'Optimal P-Envy', 'Wall Clock Time' ] writer = csv.DictWriter(csvfile, fieldnames=fieldnames) writer.writeheader() for i in range(1, 11): for j in range(1, 11): for _ in range(30): p_envy, run_time = run_one_experiment(ampl, i, j) out = { 'Number of People': j,
def main(argc, argv): from amplpy import AMPL, DataFrame import amplpy from time import time os.chdir(os.path.dirname(__file__) or os.curdir) try: # Create an AMPL instance ampl = AMPL() """ # If the AMPL installation directory is not in the system search path: from amplpy import Environment ampl = AMPL( Environment('full path to the AMPL installation directory')) """ ampl.setOption('reset_initial_guesses', True) ampl.setOption('send_statuses', False) ampl.setOption('relax_integrality', True) if argc > 1: ampl.setOption('solver', argv[1]) # Load the AMPL model from file modelDirectory = argv[2] if argc == 3 else os.path.join('..', 'models') ampl.read(os.path.join(modelDirectory, 'qpmv/qpmv.mod')) ampl.read(os.path.join(modelDirectory, 'qpmv/qpmvbit.run')) # Set tables directory (parameter used in the script above) ampl.getParameter('data_dir').set(os.path.join(modelDirectory, 'qpmv')) # Read tables ampl.readTable('assetstable') ampl.readTable('astrets') # Set the output handler to accumulate the output messages class MyOutputHandler(amplpy.OutputHandler): """ Class used as an output handler. It only prints the solver output. Must implement :class:`amplpy.OutputHandler`. """ def output(self, kind, msg): if kind == amplpy.Kind.SOLVE: assert ampl.isBusy() print('Solver: {}'.format(msg)) class MyErrorHandler(amplpy.ErrorHandler): def error(self, exception): print('Error:', exception.getMessage()) def warning(self, exception): print('Warning:', exception.getMessage()) # Create an output handler outputHandler = MyOutputHandler() ampl.setOutputHandler(outputHandler) # Create an error handler errorHandler = MyErrorHandler() ampl.setErrorHandler(errorHandler) print("Main thread: Model setup complete. Solve on worker thread.") # Initiate the solution process asynchronously ampl.solveAsync() # Wait for the solution to complete print("Main thread: Waiting for solution to end...") start = time() # Wait for the async operation to finish ampl.wait() duration = time() - start print("Main thread: done waiting.") print("Main thread: waited for {} s".format(duration)) # Print the objective value print("Main thread: cost: {}".format(ampl.getValue('cst'))) except Exception as e: print(e, type(e)) raise
execute this, move to the root directory of this project and issue the command below. ``` python3 src/main.py ``` """ from amplpy import AMPL, DataFrame import pandas as pd import numpy as np import os ## Load the ample model ## # It might be great idea to separate configs to another file, e.g. JSON? ampl = AMPL() modelDirectory = 'models' modelName = 'two_markets.mod' mod_path = os.path.join(modelDirectory, modelName) dataDirectory = 'data/balanced/' ampl.read(mod_path) ## Assign set data ## def assign_set_data(name,data): """Method to assign set data taking set name and a list as arguments""" df = DataFrame(name) df.setColumn(name,data) ampl.setData(df,name) intervals = pd.read_csv(os.path.join(dataDirectory, 'intervals.csv'), skipinitialspace=True)
def solve(dat): """ core solving routine :param dat: a good ticdat for the input_schema :return: a good ticdat for the solution_schema, or None """ assert input_schema.good_pan_dat_object(dat) assert not input_schema.find_duplicates(dat) assert not input_schema.find_foreign_key_failures(dat) assert not input_schema.find_data_type_failures(dat) # build the AMPL math model ampl = AMPL() ampl.setOption('solver', 'gurobi') ampl.eval(""" set Workers; set Shifts; set Availability within {Workers,Shifts}; param Pay{Workers}; param Shift_Require{Shifts}; var x{Availability} binary; var slack{Shifts}>=0; var totShifts{Workers}; var totSlack; minimize Total_slack: totSlack; subject to reqCts{s in Shifts}: slack[s]+sum{(w,s) in Availability} x[w,s]== Shift_Require[s]; subject to TotalSlack:totSlack==sum{s in Shifts}slack[s]; subject to TotalShifts{w in Workers}:totShifts[w]==sum{(w,s) in Availability} x[w,s]; """) # copy the tables to amplpy.DataFrame objects, renaming the data fields as needed dat = input_schema.copy_to_ampl(dat, field_renamings={ ("shifts", "Requirement"): "Shift_Require", ("workers", "Payment"): "Pay"}) # load the amplpy.DataFrame objects into the AMPL model, explicitly identifying how to populate the AMPL sets input_schema.set_ampl_data(dat, ampl, {"workers": "Workers", "shifts": "Shifts", "availability": "Availability"}) ampl.solve() if ampl.getValue("solve_result") != "infeasible": # lexicographical solve 2 - minimize Total Payments while restricting Total Slack to be as small as possible totalSlack = ampl.getValue("totSlack") ampl.eval(""" param maxSlack; subject to MaximumSlack: totSlack <= maxSlack; var totPayments; subject to TotalPayments: totPayments = sum{(w,s) in Availability}x[w,s]*Pay[w]; minimize Total_payments: totPayments; objective Total_payments; """) ampl.param["maxSlack"] = totalSlack ampl.solve() if ampl.getValue("solve_result") != "infeasible": # lexicographical solve 2 - minimize imbalance among workers while restricting # Total Slack and Total Payments to be as small as possible totalPayments = ampl.getValue("Total_payments") ampl.eval(""" param maxTotalPayments; subject to MaximumTotalPayments: totPayments <= maxTotalPayments; var avgShifts; var diffShifts{Workers}; subject to avgShiftsC: card(Workers)*avgShifts==sum{w in Workers} totShifts[w]; subject to Diff{w in Workers}: diffShifts[w]==totShifts[w]-avgShifts; minimize Total_Imbalance: sum{w in Workers}diffShifts[w] * diffShifts[w]; objective Total_Imbalance; """) ampl.param["maxTotalPayments"] = totalPayments ampl.solve() if ampl.getValue("solve_result") != "infeasible": sln = solution_schema.copy_from_ampl_variables( {('assignments' ,''): (ampl.getVariable("x"), lambda x: abs(x-1) < 1e-5), ('slacks', 'Slack'): ampl.getVariable("slack"), ('total_shifts', 'Total Number Of Shifts'): ampl.getVariable("totShifts") }) sln.parameters.loc[0] = ['Total Slack', ampl.getValue("Total_slack")] sln.parameters.loc[1] = ['Total Payments', ampl.getValue("Total_payments")] sln.parameters.loc[2] = ['Variance of Total Shifts', ampl.getValue("Total_Imbalance/card(Workers)")] return sln
training_dat = "phase2_training.dat"#input("What's the directory of your training .dat file?") validating_dir = "Validation_Dataset.csv" #input("What's the directory of your validating set?") model_dir = "phase2_lasso.mod" #input("What's the directory of your model?") ampl_dir = "/home/nub3ar/AMPL" #input("Where is ampl installed on your computer?") #"E:\ampl_mswin64" validating_data = pd.read_csv(open(validating_dir)) #dimensions of the data dv1,dv2 = validating_data.shape print(dv1, dv2) #column names col_names_va = validating_data.columns.values #x/y variable separation y_va = validating_data.loc[0::,'Label'].values.tolist() x_va = validating_data.loc[0::,'Item'::] ############AMPL################# ampl = AMPL(Environment(ampl_dir)) index_list = [] Accuracy_list = [] for index in (range 1:1000) ampl.reset() tuning = ampl.getParameter("tuning") tuning.SetValues(0.00001*index) ampl.read(model_dir) ampl.readData(training_dat) ampl.solve() a = ampl.getVariable('a').getValues().toList() b = ampl.getVariable('b').value() #parsing the coefficients a_list = []
def solve(dat): assert input_schema.good_tic_dat_object(dat) # copy the data over to amplpy.DataFrame objects, renaming the data fields as needed dat = input_schema.copy_to_ampl(dat, field_renamings={("arcs", "Capacity"): "capacity", ("cost", "Cost"): "cost", ("inflow", "Quantity"): "inflow"}) ampl = AMPL() ampl.setOption('solver', 'gurobi') ampl.eval(""" set NODES; set ARCS within {i in NODES, j in NODES: i <> j}; set COMMODITIES; param capacity {ARCS} >= 0; param cost {COMMODITIES,ARCS} > 0; param inflow {COMMODITIES,NODES}; var Flow {COMMODITIES,ARCS} >= 0; minimize TotalCost: sum {h in COMMODITIES, (i,j) in ARCS} cost[h,i,j] * Flow[h,i,j]; subject to Capacity {(i,j) in ARCS}: sum {h in COMMODITIES} Flow[h,i,j] <= capacity[i,j]; subject to Conservation {h in COMMODITIES, j in NODES}: sum {(i,j) in ARCS} Flow[h,i,j] + inflow[h,j] = sum {(j,i) in ARCS} Flow[h,j,i]; """) input_schema.set_ampl_data(dat, ampl, {"nodes": "NODES", "arcs": "ARCS", "commodities": "COMMODITIES"}) ampl.solve() if ampl.getValue("solve_result") != "infeasible": sln = solution_schema.copy_from_ampl_variables( {('flow' ,'Quantity'):ampl.getVariable("Flow")}) sln.parameters["Total Cost"] = ampl.getObjective('TotalCost').value() return sln
# -*- coding: utf-8 -*- """ Created on Sat Aug 11 17:20:23 2018 @author: donja """ from amplpy import AMPL, Environment ampl = AMPL(Environment('D:\\amplide.mswin64\\amplide.mswin64')) ampl.option['solver'] = 'cplexamp' ampl.read('example.mod') #read the model ampl.eval('objective z; solve;') ampl.display('z', 'roth', 'traditional', 'surplus') pstring = """ objective function = {z} bi-weekly roth contribution = ${roth} bi-weekly traditional contribution = ${traditional} surplus (amount left after optimal allocation) = ${surplus} total (without surplus) = ${total} total (with surplus) = ${totalS} """ z = ampl.getValue('z') roth = ampl.getValue('roth') traditional = ampl.getValue('traditional') surplus = ampl.getValue('surplus') annual_roth_amt = roth * 12 * 2 annual_traditional_amt = traditional * 12 * 2
def call_ampl_normal(dat): ampl = AMPL() ampl.read('HierarquicoPMediana.md') ampl.setOption('solver', 'cplex') ni = ampl.getParameter('ni') ni.set(dat['ni']) nj = ampl.getParameter('nj') nj.set(dat['nj']) p = ampl.getParameter('p') p.set(dat['p']) q = ampl.getParameter('q') q.set(dat['q']) ampl.param['a'] = {(i, j) : dat['a'][i][j] for i in range(dat['ni']) for j in range(dat['nj'])} ampl.param['b'] = {(i, j) : dat['b'][i][j] for i in range(dat['ni']) for j in range(dat['nj'])} ampl.param['c'] = {(i, j) : dat['c'][i][j] for i in range(dat['ni']) for j in range(dat['nj'])} ampl.getOutput('solve;') fo = ampl.getObjective('fo').value() y = ampl.getVariable('y') _y = [int(j) for j in range(dat['nj']) if y[j].value() > 0.9] z = ampl.getVariable('z') _z = [int(j) for j in range(dat['nj']) if z[j].value() > 0.9] return (fo, _y, _z)
def solve(dat): """ core solving routine :param dat: a good pandat for the input_schema :return: a good pandat for the solution_schema, or None """ assert input_schema.good_pan_dat_object(dat) assert not input_schema.find_duplicates(dat) assert not input_schema.find_foreign_key_failures(dat) assert not input_schema.find_data_type_failures(dat) # build the AMPL math model # for instructional purposes, the following code anticipates extreme sparsity and doesn't generate # conservation of flow records unless they are really needed ampl = AMPL() ampl.setOption('solver', 'gurobi') ampl.eval(""" set NODES; set ARCS within {i in NODES, j in NODES: i <> j}; set COMMODITIES; param volume {COMMODITIES} > 0, < Infinity; param capacity {ARCS} >= 0; set SHIPMENT_OPTIONS within {COMMODITIES,ARCS}; param cost {SHIPMENT_OPTIONS} >= 0, < Infinity; set INFLOW_INDEX within {COMMODITIES,NODES}; param inflow {INFLOW_INDEX} > -Infinity, < Infinity; var Flow {SHIPMENT_OPTIONS} >= 0; minimize TotalCost: sum {(h,i,j) in SHIPMENT_OPTIONS} cost[h,i,j] * Flow[h,i,j]; subject to Capacity {(i,j) in ARCS}: sum {(h,i,j) in SHIPMENT_OPTIONS} Flow[h,i,j] * volume[h] <= capacity[i,j]; subject to Conservation {h in COMMODITIES, j in NODES: card {(h,i,j) in SHIPMENT_OPTIONS} > 0 or card {(h,j,i) in SHIPMENT_OPTIONS} > 0 or (h,j) in INFLOW_INDEX}: sum {(h,i,j) in SHIPMENT_OPTIONS} Flow[h,i,j] + (if (h,j) in INFLOW_INDEX then inflow[h,j]) = sum {(h,j,i) in SHIPMENT_OPTIONS} Flow[h,j,i]; """) # copy the tables to amplpy.DataFrame objects, renaming the data fields as needed dat = input_schema.copy_to_ampl(dat, field_renamings={ ("commodities", "Volume"): "volume", ("arcs", "Capacity"): "capacity", ("cost", "Cost"): "cost", ("inflow", "Quantity"): "inflow" }) # load the amplpy.DataFrame objects into the AMPL model, explicitly identifying how to populate the AMPL sets input_schema.set_ampl_data( dat, ampl, { "nodes": "NODES", "arcs": "ARCS", "commodities": "COMMODITIES", "cost": "SHIPMENT_OPTIONS", "inflow": "INFLOW_INDEX" }) # solve and recover the solution if feasible ampl.solve() if ampl.getValue("solve_result") != "infeasible": # solution tables are populated by mapping solution (table, field) to AMPL variable sln = solution_schema.copy_from_ampl_variables({ ('flow', 'Quantity'): ampl.getVariable("Flow") }) # append the solution KPI results to the solution parameters table sln.parameters.loc[0] = [ 'Total Cost', ampl.getObjective('TotalCost').value() ] return sln
def solver(alpha, n_intersections, C, g_i_inbound, g_i_outbound, delta, verbose=True): """ Solves the linear problem for the given set of parameters :param alpha: :type alpha: :param n_intersections: :type n_intersections: :param C: :type C: :param g_i_inbound: :type g_i_inbound: :param g_i_outbound: :type g_i_outbound: :param delta: :type delta: :return: :rtype: """ ampl = AMPL(Environment(path)) # Set the solver ampl.setOption('solver', path + '/cplex') # Read the model file ampl.read('lp.mod') # Set parameters values ampl.param['alpha'] = alpha ampl.param['N'] = n_intersections ampl.param['C'] = C ampl.param['g_incoming'] = g_i_inbound ampl.param['g_outgoing'] = g_i_outbound ampl.param['delta'] = delta if verbose == True: print("alpha: {}".format(alpha)) print("N: {}".format(n_intersections)) print("C: {}".format(C)) print("g_incoming: {}".format(g_i_inbound)) print("g_outgoing: {}".format(g_i_outbound)) print("delta: {}".format(delta)) # Resolve and display objective ampl.solve() bandwidth = ampl.getObjective('bandwidth').value() # Display the variables b_incoming = ampl.getVariable('b_incoming').value() b_outgoing = ampl.getVariable('b_outgoing').value() wl = ampl.getVariable('w').getValues() if verbose == True: print("New objective value: {}".format(bandwidth)) print("New offsets: {}".format(list(wl.toPandas()['w.val']))) print("Incoming bandwidth: {}".format(b_incoming)) print("Outgoing bandwidth: {}".format(b_outgoing)) # return bandwidths and offset values return b_incoming, b_outgoing, list(wl.toPandas()['w.val'])
def solve(dat): assert input_schema.good_tic_dat_object(dat) assert not input_schema.find_foreign_key_failures(dat) assert not input_schema.find_data_type_failures(dat) assert not input_schema.find_data_row_failures(dat) dat = input_schema.copy_to_ampl(dat, field_renamings={ ("roster", "Grade"):"grade", ("positions", "Position Importance"): "position_importance", ("positions", "Position Group"): "position_group", ("player_ratings", "Rating"): "player_rating", ("innings", "Inning Group"): "inning_group", ("position_constraints", "Min Players"): "min_players", ("position_constraints", "Max Players"): "max_players" }) ampl = AMPL() ampl.setOption('solver', 'gurobi') mod_str = """ # Players and grades set PLAYERS; param grade {PLAYERS} symbolic; set GRADES = setof {pl in PLAYERS} grade[pl]; set IN_GRADE {g in GRADES} = {pl in PLAYERS: grade[pl] = g}; # Positions and position groups; player ratings set POSITIONS; param position_importance {POSITIONS}; param position_group {POSITIONS} symbolic; set POSITION_GROUPS = setof {p in POSITIONS} position_group[p]; set IN_POSITION_GROUP {pg in POSITION_GROUPS} = {p in POSITIONS: position_group[p] = pg}; param player_rating {PLAYERS,POSITION_GROUPS}; # Innings and inning groups; player limits set INNINGS; param inning_group {INNINGS} symbolic; set INNING_GROUPS = setof {i in INNINGS} inning_group[i]; set IN_INNING_GROUP {ig in INNING_GROUPS} = {i in INNINGS: inning_group[i] = ig}; set POSITION_CONSTRAINTS within {POSITION_GROUPS,INNING_GROUPS,GRADES}; param min_players {POSITION_CONSTRAINTS}; param max_players {POSITION_CONSTRAINTS}; # Decision variables: 1 ==> assignment of a player to a position in an inning var Play {INNINGS,POSITIONS,PLAYERS} binary; # Objective function: Maximize desirability of the assignment maximize TotalImportance: sum {i in INNINGS, p in POSITIONS, pl in PLAYERS} position_importance[p] * player_rating[pl,position_group[p]] * Play[i,p,pl]; # Exactly one player per position per inning subject to AllPositionsFilledPerInning {i in INNINGS, p in POSITIONS}: sum {pl in PLAYERS} Play[i,p,pl] = 1; # At most one possition per player per inning subject to AtMostOnePositionPerInning {i in INNINGS, pl in PLAYERS}: sum {p in POSITIONS} Play[i,p,pl] <= 1; # Total roster slots assigned, for listed combinations of # position group, inning group, and grade, must be within specified limits subject to MinMaxPlayers {(pg,ig,g) in POSITION_CONSTRAINTS}: min_players[pg,ig,g] <= sum {p in IN_POSITION_GROUP[pg], i in IN_INNING_GROUP[ig], pl in IN_GRADE[g]} Play[i,p,pl] <= max_players[pg,ig,g]; """ ampl.eval(mod_str) input_schema.set_ampl_data(dat, ampl, {"roster": "PLAYERS", "positions": "POSITIONS", "innings": "INNINGS", "position_constraints": "POSITION_CONSTRAINTS"}) ampl.solve() if ampl.getValue("solve_result") != "infeasible": sln = solution_schema.TicDat() for (i,p,pl),x in ampl.getVariable("Play").getValues().toDict().items(): if round(x[0]) > 0: sln.lineup[i,p] = pl sln.parameters["Total Cost"] = ampl.getObjective('TotalImportance').value() return sln
def main(argc, argv): from amplpy import AMPL os.chdir(os.path.dirname(__file__) or os.curdir) try: ampl = AMPL() if argc > 1: ampl.setOption('solver', argv[1]) modelDirectory = os.path.join( argv[2] if argc == 3 else os.path.join('..', 'models'), 'tracking') # Load the AMPL model from file ampl.read(os.path.join(modelDirectory, 'tracking.mod')) # Read data ampl.readData(os.path.join(modelDirectory, 'tracking.dat')) # Read table declarations ampl.read(os.path.join(modelDirectory, 'trackingbit.run')) # Set tables directory (parameter used in the script above) ampl.getParameter('data_dir').set(modelDirectory) # Read tables ampl.readTable('assets') ampl.readTable('indret') ampl.readTable('returns') hold = ampl.getVariable('hold') ifinuniverse = ampl.getParameter('ifinuniverse') # Relax the integrality ampl.setOption('relax_integrality', True) # Solve the problem ampl.solve() objectives = list(obj for name, obj in ampl.getObjectives()) assert objectives[0].value() == ampl.getObjective('cst').value() print("QP objective value", ampl.getObjective('cst').value()) lowcutoff = 0.04 highcutoff = 0.1 # Get the variable representing the (relaxed) solution vector holdvalues = hold.getValues() toHold = [] # For each asset, if it was held by more than the highcutoff, # forces it in the model, if less than lowcutoff, forces it out for value in holdvalues.getColumn('hold'): if value < lowcutoff: toHold.append(0) elif value > highcutoff: toHold.append(2) else: toHold.append(1) # uses those values for the parameter ifinuniverse, which controls # which # stock is included or not in the solution ifinuniverse.setValues(toHold) # Get back to the integer problem ampl.setOption('relax_integrality', False) # Solve the (integer) problem ampl.solve() print("QMIP objective value", ampl.getObjective('cst').value()) except Exception as e: print(e) raise
def call_ampl(dat): ampl = AMPL() ampl.read('ComplementarMaxCovering.md') ampl.setOption('solver', 'cplex') ni = ampl.getParameter('ni') ni.set(dat['ni']) # Envia a quantidade de clientes para o AMPL nj = ampl.getParameter('nj') nj.set(dat['nj']) # Envia a quantidade de facilidades para o AMPL p = ampl.getParameter('p') p.set(dat['p'] ) # Envia o valor da quantidade máxima de facilidades para o AMPL w = ampl.getParameter('w') w.setValues(dat['w']) # Envia os pesos de cada cliente para o AMPL for i in range(dat['ni']): ampl.set['a'][i] = dat['a'][i] # Envia a matriz A para o AMPL ampl.getOutput('solve;') # Demonstra o resultado na tela do Python fo = ampl.getObjective('fo').value() x = ampl.getVariable('x') _x = [int(j) for j in range(dat['nj']) if x[j].value() > 0.9] y = ampl.getVariable('y') _y = [int(i) for i in range(dat['ni']) if y[i].value() > 0.9] return (fo, _x, _y)
def main(argc, argv): # You can install amplpy with "python -m pip install amplpy" from amplpy import AMPL os.chdir(os.path.dirname(__file__) or os.curdir) # Create an AMPL instance ampl = AMPL() """ # If the AMPL installation directory is not in the system search path: from amplpy import Environment ampl = AMPL( Environment('full path to the AMPL installation directory')) """ if argc > 1: ampl.set_option("solver", argv[1]) model_directory = os.path.join( argv[2] if argc == 3 else os.path.join("..", "models"), "tracking") # Load the AMPL model from file ampl.read(os.path.join(model_directory, "tracking.mod")) # Read data ampl.read_data(os.path.join(model_directory, "tracking.dat")) # Read table declarations ampl.read(os.path.join(model_directory, "trackingbit.run")) # Set tables directory (parameter used in the script above) ampl.get_parameter("data_dir").set(model_directory) # Read tables ampl.read_table("assets") ampl.read_table("indret") ampl.read_table("returns") hold = ampl.get_variable("hold") ifinuniverse = ampl.get_parameter("ifinuniverse") # Relax the integrality ampl.set_option("relax_integrality", True) # Solve the problem ampl.solve() solve_result = ampl.get_value("solve_result") if solve_result != "solved": raise Exception( "Failed to solve (solve_result: {})".format(solve_result)) objectives = list(obj for name, obj in ampl.get_objectives()) assert objectives[0].value() == ampl.get_objective("cst").value() print("QP objective value", ampl.get_objective("cst").value()) lowcutoff = 0.04 highcutoff = 0.1 # Get the variable representing the (relaxed) solution vector holdvalues = hold.get_values() to_hold = [] # For each asset, if it was held by more than the highcutoff, # forces it in the model, if less than lowcutoff, forces it out for value in holdvalues.get_column("hold.val"): if value < lowcutoff: to_hold.append(0) elif value > highcutoff: to_hold.append(2) else: to_hold.append(1) # uses those values for the parameter ifinuniverse, which controls # which stock is included or not in the solution ifinuniverse.set_values(to_hold) # Get back to the integer problem ampl.set_option("relax_integrality", False) # Solve the (integer) problem ampl.solve() solve_result = ampl.get_value("solve_result") if solve_result != "solved": raise Exception( "Failed to solve (solve_result: {})".format(solve_result)) print("QMIP objective value", ampl.get_objective("cst").value())