Este guia do usuário do Optimization Solver descreve como chamar o solver, inserir problemas e fornece uma lista das APIs do solver.
Este software possui muitas APIs e novos recursos são adicionados frequentemente. Para descrições detalhadas das APIs, você será frequentemente direcionado ao MindOpt User Guide - Full Version. Pedimos desculpas por qualquer inconveniente. Você pode alternar o idioma e a versão do documento na página.
Como chamar o Optimization Solver
Antes de começar, baixe e instale o kit de desenvolvimento de software (SDK) do solver e obtenha as permissões necessárias. Para mais informações, consulte Início Rápido (Ativação e Uso) e Baixar e instalar o SDK do solver.
As seções a seguir apresentam exemplos simples. Para instruções detalhadas sobre como chamar o solver e para exemplos completos, consulte Mais.
Exemplo de chamada via linha de comando
No Linux e macOS, supondo que você tenha instalado o MindOpt no diretório especificado pela variável de ambiente $MINDOPT_HOME, conforme descrito no documento de instalação:
mindopt $MINDOPT_HOME/examples/data/afiro.mps
No Windows:
mindopt %MINDOPT_HOME%\examples\data\afiro.mps
Exemplo de chamada em C/C++/C#/Java/Python/MATLAB
As APIs da versão V1.x e posteriores diferem significativamente das APIs da versão V0.x. Certifique-se de usar a versão correta.
V1.x
env = mindoptpy.Env()
env.start()
model = mindoptpy.read(filename, env)
model.optimize()
print(f"Optimal objective value is: {model.objval}")
for v in x:
print(f"{v.VarName} = {v.X}")
MDOEnv env = new MDOEnv();
MDOModel model = new MDOModel(env, filename);
model.optimize();
System.out.println("Optimal objective value is: " + model.get(MDO.DoubleAttr.ObjVal));
MDOVar[] x = model.getVars();
for (int i = 0; i < x.length; ++i) {
System.out.println(x[i].get(MDO.StringAttr.VarName) + " = " + x[i].get(MDO.DoubleAttr.X));
}
MDOEnv env = MDOEnv();
MDOModel model = MDOModel(env, filename);
model.optimize();
std::cout << "Optimal objective value is: " << model.get(MDO_DoubleAttr_ObjVal) << std::endl;
std::vector<MDOVar> vars = model.getVars();
for (auto v : vars) {
std::cout << v.get(MDO_StringAttr_VarName) << " = " << v.get(MDO_DoubleAttr_X) << std::endl;
}
MDOenv* env;
MDOemptyenv(&env);
MDOstartenv(env);
MDOmodel* model;
double obj;
MDOreadmodel(env, argv[1], filename);
MDOoptimize(model);
MDOgetdblattr(model, MDO_DBL_ATTR_OBJ_VAL, &obj);
printf("Optimal objective value is: %f\n", obj);
/* Free the environment. */
MDOfreemodel(model);
MDOfreeenv(env);
MDOEnv env = new MDOEnv();
MDOModel model =new MDOModel(env, filename);
model.optimize();
Console.WriteLine($"Optimal objective value is: {model.Get(MDO.DoubleAttr.ObjVal)}");
MDOVar[] vars = model.GetVars();
for (int i = 0; i < vars.Length; i++)
{
Console.WriteLine($"{vars[i].Get(MDO.StringAttr.VarName)} = {vars[i].Get(MDO.DoubleAttr.X)}");
}
model = mindopt_read(file);
result = mindopt(model);
for v=1:length(result.X)
fprintf('%s %d\n', model.varnames{v}, result.X(v));
end
fprintf('Optimal objective value is: %e\n', result.ObjVal);
objval = result.ObjVal;
Para exemplos de código completos, consulte Mais.
V0.x
# Method 1: A new model creation method was introduced in version 0.19.0. This method provides faster cloud authentication and consumes less concurrency.
env = mindoptpy.MdoEnv()
model = mindoptpy.MdoModel(env)
model.read_prob(filename)
model.solve_prob()
model.display_results()
# Method 2: The old model creation method is still supported.
# model = mindoptpy.MdoModel()
# model.read_prob(filename)
# model.solve_prob()
# model.display_results()
//<dependency>
// <groupId>com.alibaba.damo</groupId>
// <artifactId>mindoptj</artifactId>
// <version>[0.20.0,)</version>
//</dependency>
// Load the dynamic-link library, as follows:
Mdo.load("c:\\mindopt\\0.20.0\\win64_x86\\lib\\mindopt_0_20_0.dll");
// Method 1: A new model creation method was introduced in version 0.19.0. This method provides faster cloud authentication and consumes less concurrency.
// Set up the environment during program initialization, for example, in the setup phase of MapReduce.
MdoEnv env = new MdoEnv();
// Create a model.
MdoModel model = env.createModel();
model.readProb(filename)
model.solveProb();
model.displayResult();
model.free();
// The Java SDK requires you to manually release the env at the end of the program, for example, in the cleanup phase of MapReduce.
env.free();
// Method 2: The old model creation method is still supported but is marked as deprecated and will be removed in a future version.
/*
MdoModel model = new MdoModel();
model.readProb(filename)
model.solveProb();
model.displayResult();
*/
// Method 1: A new model creation method was introduced in version 0.19.0. This method provides faster cloud authentication and consumes less concurrency.
using mindopt::MdoEnv;
MdoEnv env;
MdoModel model(env);
model.readProb(filename);
model.solveProb();
model.displayResults();
// Method 2: The old model creation method is still supported.
/*
MdoModel model;
model.readProb(filename);
model.solveProb();
model.displayResults();
*/
// Method 1: A new model creation method was introduced in version 0.19.0. This method provides faster cloud authentication and consumes less concurrency.
MdoEnvPtr env;
MdoMdlPtr model;
Mdo_createEnv(&env);
Mdo_createMdlWithEnv(&model, env);
Mdo_readProb(model, filename);
Mdo_solveProb(model);
Mdo_displayResults(model);
Mdo_freeMdl(&model);
// The C SDK requires you to manually release the env.
Mdo_freeEnv(&env);
// Method 2: The old model creation method is still supported.
/*
MdoMdlPtr model;
Mdo_createMdl(&model);
Mdo_readProb(model, filename);
Mdo_solveProb(model);
Mdo_displayResults(model);
Mdo_freeMdl(&model);
*/
Para exemplos de código completos, consulte a documentação V0.x.
Problemas de otimização suportados
A versão atual do solver oferece suporte ao seguinte:
Programação linear: O solver oferece capacidades abrangentes para resolver problemas de programação linear (LP). Ele suporta o método simplex primal/dual e o método de pontos interiores. Também resolve problemas de otimização de fluxo de rede em grande escala.
Programação inteira: O solver suporta o método branch-and-cut para problemas de programação linear inteira mista (MILP).
Programação não linear: O solver suporta problemas convexos de programação quadrática (QP) e problemas de programação semidefinida (SDP).
Métodos de entrada para problemas de otimização
Existem três formas de inserir problemas de otimização: por arquivo, usando a API de modelagem de dados ou chamando ferramentas externas de modelagem.
Método 1: Entrada por arquivo
O solver suporta o formato MPS e o formato LP, como arquivos
.mpse.lp, além de suas versões compactadas, como.mps.gze.mps.bz2.Também há suporte para o formato
.dat-s, utilizado em exemplos de problemas SDP.O formato
.qpsé aceito para dados de problemas QP.O módulo
mindoptamplpermite a entrada de arquivos.nl. Por exemplo, execute o comandomindoptampl filename.nl.
Para mais informações, consulte Mais.
Método 2: Entrada via API de modelagem
As APIs da versão V1.x e posteriores diferem significativamente das APIs da versão V0.x. Certifique-se de usar a versão correta.
V1.x
Diversas APIs relacionadas estão disponíveis para suportar a entrada de dados por linha.
-
Veja abaixo um breve exemplo em Python:
Use
mindoptpy.Model.modelsense = MDO.MINIMIZEpara definir a função objetivo como minimização.Use
mindoptpy.Model.addVar()para adicionar variáveis de otimização e definir seus limites inferiores, limites superiores, coeficientes do objetivo, nomes e tipos.Use
mindoptpy.Model.addConstrs()para adicionar restrições.
Para mais informações, consulte Mais. Para obter uma lista de atributos, veja Mais. Os capítulos da API também contêm exemplos completos para cada linguagem.
V0.x
Várias APIs relacionadas estão disponíveis, permitindo a entrada dos mesmos dados de diversas maneiras.
-
Segue um breve exemplo em Python para entrada por linha:
Use
mindoptpy.MdoModel.set_int_attr()para definir a função objetivo como minimização.Use
mindoptpy.MdoModel.add_var()para adicionar quatro variáveis de otimização e definir seus limites inferiores, limites superiores, nomes e tipos.Use
mindoptpy.MdoModel.add_cons()para adicionar restrições.
-
Abaixo está um breve exemplo em Python para entrada por coluna:
Use
mindoptpy.MdoModel.set_int_attr()para definir a função objetivo como minimização.Primeiro, chame
mindoptpy.MdoModel.add_cons()para criar restrições com valores especificados para os lados esquerdo e direito, mas sem elementos diferentes de zero.Crie um objeto de coluna temporário
mindoptpy.MdoCol()para armazenar sequencialmente as restrições e os valores dos elementos diferentes de zero.Por fim, chame
mindoptpy.MdoModel.add_var()para criar novas variáveis com seus respectivos coeficientes da função objetivo, elementos diferentes de zero no vetor coluna, limites inferiores e superiores, nomes e tipos de variáveis.
Para mais informações, consulte a documentação V0.x. Para uma lista de atributos do modelo, veja a documentação V0.x.
Método 3: Linguagens de modelagem MindOpt APL, AMPL, Pyomo, PuLP e JuMP
A vantagem de usar uma linguagem de modelagem é que sua API permite construir modelos facilmente alternáveis entre diferentes versões do solver.
O MindOpt suporta várias ferramentas comuns de modelagem, incluindo as seguintes:
1. MindOpt APL
O suporte ao MindOpt APL, uma linguagem de modelagem desenvolvida pela equipe MindOpt, foi introduzido em 2022.
Use a linguagem de modelagem e o solver gratuitamente no seu navegador, através da plataforma online de modelagem e resolução do MindOpt. A plataforma também inclui estudos de caso para ajudar você a começar rapidamente. Nenhuma instalação de software é necessária; basta abrir o navegador para utilizá-la.
Para mais documentação sobre sintaxe, consulte Mais.
2. AMPL
Antes de usar o AMPL para chamar o MindOpt, instale tanto o MindOpt quanto o AMPL. O aplicativo mindoptampl está localizado no diretório \bin\mindoptampl do pacote de instalação. O mindoptampl fornece parâmetros configuráveis. Use o comando option do AMPL para definir o parâmetro mindoptampl_options. Por exemplo:
ampl: option mindoptampl_options 'numthreads=4 maxtime=1e+4';
Para mais informações e exemplos, consulte Mais.
3. CVXPY
Antes de usar o CVXPY para chamar o MindOpt, instale o MindOpt e o CVXPY. Para chamar a API CVXPY do solver MindOpt, importe primeiro os arquivos de interface mindopt_conif.py e mindopt_qpif.py. Importe esses arquivos no seu código Python da seguinte forma:
from mindopt_conif import *
from mindopt_qpif import *
Para mais informações e exemplos, consulte Mais.
4. Pyomo
Antes de usar o Pyomo para chamar o MindOpt, instale o MindOpt e o Pyomo. Para chamar a API Pyomo do solver MindOpt, utilize o arquivo de interface mindopt_pyomo.py. A interface MindOpt Pyomo herda da classe DirectSolver do Pyomo. O código de implementação está no arquivo \lib\pyomo\mindopt_pyomo.py do pacote de instalação. Importe este arquivo no seu código Python da seguinte forma:
from mindopt_pyomo import MindoptDirect
Para mais informações e exemplos, consulte Mais.
5. PuLP
Antes de usar o PuLP para chamar o MindOpt, instale o MindOpt e o PuLP. Para chamar a API PuLP do solver MindOpt, utilize o arquivo de interface mindopt_pulp.py. A interface MindOpt PuLP herda da classe LpSolver do PuLP. O código de implementação está no arquivo \lib\pulp\mindopt_pulp.py do pacote de instalação. Importe este arquivo no seu código Python da seguinte forma:
from mindopt_pulp import MINDOPT
Para mais informações e exemplos, consulte Mais.
6. JuMP
O JuMP é uma ferramenta de modelagem de código aberto baseada na linguagem de programação Julia. Antes de usar o JuMP para chamar o MindOpt, instale o MindOpt, Julia, JuMP e AmplNLWriter. Chame a API do JuMP para criar um objeto de modelagem e especifique mindoptampl como o solver.
model = Model(() -> AmplNLWriter.Optimizer(mindoptampl))
Para mais informações, consulte Mais.
Configurações de parâmetros para resolução
Defina parâmetros de entrada ao executar o solver. Para a documentação V1.x, consulte o capítulo Parâmetros. Por exemplo, defina o tempo máximo de resolução do solver usando "MaxTime". Para a documentação V0.x, consulte o capítulo Parâmetros de Entrada Opcionais.
Referência para configuração de dispositivos de computação: Características de diferentes algoritmos para resolução de LP
Ao configurar recursos de máquina, o consumo varia conforme a estrutura do problema e o algoritmo selecionado. Teste e selecione a configuração conforme necessário.
Para resolução de LP, fornecemos atualmente os algoritmos Simplex, Método de Pontos Interiores (IPM) e Otimização Concorrente. O fluxo de execução é mostrado na imagem "Fluxo de execução" abaixo. O algoritmo Concorrente é selecionado por padrão. Defina o parâmetro "Method" para escolher um algoritmo diferente.
As diferenças entre esses três algoritmos são as seguintes:
Simplex | Método de Pontos Interiores (IPM) | Concorrente (Otimização Simultânea) | |
Características | - Geralmente menos sensível a problemas numéricos - Consome menos memória - Suporta warm-start | - Mais sensível a problemas numéricos - Consome de 2 a 10 vezes mais memória que o método Simplex - Não suporta warm-start - Pode ser mais adequado para problemas de grande escala | - Otimiza usando ambos os métodos simultaneamente, consumindo mais memória - Mais robusto - Ao resolver uma nova categoria de problemas, tente este método primeiro para determinar se o Simplex ou IPM é mais adequado. Isso ajuda na seleção futura de algoritmos. |
Requisitos do dispositivo de computação Os requisitos podem variar significativamente entre problemas. Use resultados de testes reais como padrão. Os valores de teste de laboratório a seguir servem apenas como referência: | |||
Quando o número de restrições é 43.200 e o número de elementos diferentes de zero é 1.038.761 | Uso máximo de memória testado: 350 MB | Uso máximo de memória testado: 620 MB | Uso máximo de memória testado: 920 MB |
Quando o número de restrições é 986.069 e o número de elementos diferentes de zero é 4.280.320 | Uso máximo de memória testado: 1250 MB | Uso máximo de memória testado: 1500 MB | Uso máximo de memória testado: 1650 MB |
Quando o número de restrições é 4.284 e o número de elementos diferentes de zero é 11.279.748 | Uso máximo de memória testado: 2050 MB | Uso máximo de memória testado: 5200 MB | Uso máximo de memória testado: 5200 MB |
Quando o número de restrições é 22.117 e o número de elementos diferentes de zero é 20.078.717 | Uso máximo de memória testado: 3400 MB | Uso máximo de memória testado: 5600 MB | Uso máximo de memória testado: 8300 MB |
O consumo de memória depende da forma, escala e esparsidade do problema. Para estimar recursos de memória antecipadamente, calcule primeiro o consumo com base na escala e esparsidade do problema. Em seguida, multiplique esse valor por um determinado fator para obter um valor estimado de recursos de memória reservados.
Obtenção dos resultados da solução
Execução via linha de comando
Ao executar o solver via linha de comando, ele imprime a saída do processo de resolução e um resumo dos resultados. Também gera arquivos de resultado .bas e .sol com o mesmo nome, no mesmo diretório do arquivo do problema.
A figura a seguir mostra que, após executar o comando mindopt afiro.mps, os arquivos afiro.bas e afiro.sol são gerados na pasta. O arquivo .bas salva a base, e o arquivo .sol salva o valor objetivo ótimo e a solução para os valores das variáveis.

Resolução via API e recuperação de resultados
As APIs da versão V1.x e posteriores diferem significativamente das APIs da versão V0.x. Certifique-se de usar a versão correta.
V1.x
Após inserir o problema a ser resolvido, chame a API optimize() para resolvê-lo. Por exemplo, o comando em Python é model.optimize().
Após a resolução, chame as APIs para recuperar os resultados. Os exemplos a seguir usam Python:
Chame
model.statuspara recuperar o status da solução. Os status possíveis incluem UNKNOWN, OPTIMAL, INFEASIBLE, UNBOUNDED, INF_OR_UBD e SUB_OPTIMAL. Por exemplo,MDO.OPTIMALem Python.-
Use
model.objvalpara recuperar o valor objetivo.-
Também é possível chamar
model.getAttr(MDO.Attr.PrimalObjVal)para recuperar outros valores de atributos do modelo. Da mesma forma:SolutionTime: Tempo total de execução em segundosDualObjVal: Valor objetivo dualColBasis: Base da solução primal
-
Chame
var.Xpara recuperar a solução de uma variável.Para uma lista de mais atributos de solução, consulte Mais.
Para exemplos de código completos, consulte a pasta example no pacote de instalação, a documentação em Mais, ou o capítulo de exemplos na documentação da API de cada linguagem, como os exemplos em Python.
V0.x
Após inserir o problema a ser resolvido, chame a API solveProb para resolvê-lo. Por exemplo, o comando em Python é model.solve_prob().
Após a resolução, chame as APIs para recuperar os resultados. Os exemplos a seguir usam Python:
Chame
model.display_results()para imprimir os resultados.Chame
model.get_status()para recuperar o status da solução.-
Chame
model.get_real_attr("PrimalObjVal")para recuperar o valor objetivo primal. Da mesma forma:"DualObjVal": Valor objetivo dual"PrimalSoln": Solução primal"ColBasis": Base da solução primalPara uma lista de mais atributos de solução, consulte a documentação V0.x
Para exemplos de código completos, consulte a pasta example no pacote de instalação ou a documentação.
Ferramentas de análise de solução e técnicas avançadas de modelagem
Análise de inviabilidade para restrições
Durante o processo de modelagem e resolução, você pode encontrar problemas inviáveis causados por restrições conflitantes. Analisar o problema inviável e identificar as restrições chave que causam o conflito ajuda significativamente na modelagem. Um subconjunto mínimo de restrições que torna o problema inviável é chamado de sistema irredutivelmente inviável (IIS).
O MindOpt fornece uma API para calcular um IIS. Se um problema for "INFEASIBLE", use a API de cálculo de IIS para analisar o problema inviável. Por exemplo, modifique ou remova as restrições no IIS para tornar o problema de otimização viável.
Segue um exemplo de como chamar a interface Python do IIS:
V1.x
if model.status == MDO.INFEASIBLE or model.status == MDO.INF_OR_UBD:
idx_rows, idx_cols = model.compute_iis()
Para instruções completas sobre o cálculo de um IIS, consulte Mais.
V0.x
status_code, status_msg = model.get_status()
if status_msg == "INFEASIBLE":
idx_rows, idx_cols = model.compute_iis()
Para instruções completas sobre o cálculo de um IIS, consulte a documentação V0.x.
Callback
O MindOpt usa o método clássico branch-and-bound para resolver problemas MIP. O recurso de callback permite rastrear o processo de resolução e tomar decisões para orientar o solver, incluindo o seguinte:
Adicionar planos de corte para podar ramos que não conterão a solução ótima.
Intervir na estratégia de seleção de ramos do MindOpt para controlar o método de bisseção de nós e a ordem de travessia.
Adicionar soluções viáveis personalizadas (como soluções obtidas por meio de um algoritmo heurístico). Uma boa solução viável pode melhorar a eficiência de resolução do MindOpt.
Crie uma função de callback da seguinte forma:
def callback(model, where):
Para instruções completas sobre callbacks, consulte Mais.
Ajuste de parâmetros do solver
O MindOpt Tuner também pode realizar otimização de hiperparâmetros para o solver. Forneça dados do seu cenário de negócios e use o MindOpt Tuner. Após o ajuste de parâmetros, obtenha um solver mais rápido e personalizado para o seu cenário de negócios. Alguns recursos estão atualmente disponíveis na plataforma em nuvem MindOpt.
Modelagem assistida por engenheiro de IA
Um engenheiro de IA é um robô de IA construído sobre um Modelo de Linguagem Grande (LLM) e integrado com conhecimento de ferramentas de software específicas de domínio para fornecer consultoria técnica básica. O MindOpt Copilot é um engenheiro de IA que ajuda você a usar a tecnologia MindOpt para resolver problemas de otimização matemática. Ele pode ser usado para consultoria técnica no campo de otimização matemática.
Atualmente, o engenheiro de IA MindOpt Copilot suporta ferramentas como o MindOpt Solver e a linguagem de modelagem MindOpt APL. Ele se comunica por meio de linguagem natural e dados tabulares para executar tarefas automaticamente com base nos seus problemas de negócios. Essas tarefas incluem modelagem matemática, formulação de equações matemáticas, escrita de código e chamada de software MindOpt para resolver problemas. Ele também pode gerar projetos a partir do texto, fórmulas matemáticas e código que produz, permitindo que você os importe rapidamente para seus projetos de desenvolvimento.
Lançado inicialmente em setembro de 2023, está disponível na plataforma em nuvem MindOpt.
Outros recursos
Mascaramento de dados
A linha de comando do MindOpt inclui a opção --sanitize, que gera um arquivo de modelo mascarado. Isso facilita o envio de dados para trocas técnicas ou para ajuste e melhoria de parâmetros do solver.
Fluxo de execução do solver
Fluxo de execução do MindOpt:
Problemas de otimização diferentes possuem métodos de resolução diferentes, mas o fluxo geral é semelhante. Abaixo está um exemplo do fluxo de chamada para um problema LP. Durante o processo, defina certos parâmetros.

APIs completas e métodos de chamada
Para instruções completas, consulte o MindOpt User Guide - Full Version
O sumário é o seguinte: