|
FMIP: Joint Continuous-Integer Flow For Mixed-Integer Linear Programming |
Soundness: 3: good
Presentation: 3: good
Contribution: 3: good
Rating: 6: marginally above the acceptance threshold
Confidence: 2: You are willing to defend your assessment, but it is quite likely that you did not understand the central parts of the submission or that you are unfamiliar with some pieces of related work. Math/other details were not carefully checked. |
The paper introduces FMIP (Joint Continuous-Integer Flow for Mixed-Integer Linear Programming), a generative framework that addresses limitations in existing MILP heuristics by modeling the joint distribution of both integer and continuous variables using conditional flow matching. This approach captures the interdependencies between variable types, enabling a holistic guidance mechanism during inference that steers solutions toward optimality and feasibility via objective function and constraint feedback. FMIP, integrated with various graph neural network backbones and downstream solvers, is evaluated on some benchmarks.
The claimed empirical performance is good, achieving decent relative improvement in primal gap over state-of-the-art baselines on some benchmarks. The framework's compatibility with multiple GNN architectures and solvers, as shown in ablation studies and compatibility analyses, highlights its flexibility and generalizability. Additionally, the holistic guidance, supported by gradient-based updates for continuous variables and sampling-reweighting for integers, effectively leverages complete solution candidates at each step, leading to higher-quality heuristics.
FMIP's focus on bounded integer variables limits its applicability to general MILP problems with unbounded or non-binary integers. The reliance on flow matching introduces higher inference times compared to discriminative baselines like supervised learning. While ablations confirm the value of joint modeling and guidance, the paper could benefit from deeper analysis on failure cases or scalability to very large-scale instances beyond the tested benchmarks.
None |
Heavily AI-edited |
|
FMIP: Joint Continuous-Integer Flow For Mixed-Integer Linear Programming |
Soundness: 3: good
Presentation: 3: good
Contribution: 2: fair
Rating: 4: marginally below the acceptance threshold
Confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work. |
FMIP uses a multimodal flow matching generative model to learn the distribution of high-quality MILP solutions in a combined continuous–discrete space. The author proposes a **“holistic” guidance mechanism** that steers the generation process using the MILP’s objective function and constraint satisfaction feedback, refining candidate solutions toward feasibility and optimality during sampling. This approach is expected to addresses the limitation of previous graph neural network (GNN) predictors that predicted only integer variables and left continuous ones to a solver, thereby missing the intricate coupling between them .
1. The joint modeling of integer variables and continuous variables is a notable contribution, where previous works usually only focus on discrete value predictions, which ignores some global relationships.
2. The author proposed the holistic guidance mechanism integrated into FMIP’s sampling. During inference, FMIP uses the MILP’s objective and constraint violations to guide the generative trajectory, which is expected to produce better predictions.
1. Given the context where integer–continuous coupling is important, the motivation for a generative approach is under-developed. Why is a generative model preferable to discriminative predictors under identical solver budgets? Why is the Flow Matching used in the proposed framework?
2. In Tables 1–2 the downstream solver time limits should be standardized (e.g., a flat 1000 s for all methods) to ensure fairness; the mixed 400/600 s budgets are short for some instances and confound comparisons. A unified budget would make the FMIP gains more persuasive.
1. The guidance combines the objective with squared constraint violations via a hyperparameter $\gamma$. Please clarify how it balances objective vs. violation terms, its sensitivity, and the tuning/selection procedure used.
2. The reweighting step appears to require evaluating continuous variables, which is extra computational efforts. If many continuous variables are functionally dependent or cheaply recoverable, why is explicit prediction necessary? Could a GNN/GAT that aggregates global information suffice without predicting continuous components? Is it necessary because of the generative model? Please clarify the additional computational cost or justify the benefit of jointly predicting discrete and continuous variables (e.g., tighter guidance, reduced repair time, better warm starts). |
Lightly AI-edited |
|
FMIP: Joint Continuous-Integer Flow For Mixed-Integer Linear Programming |
Soundness: 4: excellent
Presentation: 4: excellent
Contribution: 2: fair
Rating: 6: marginally above the acceptance threshold
Confidence: 3: You are fairly confident in your assessment. It is possible that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work. Math/other details were not carefully checked. |
This manuscript is an incremental extension of [1], with the following core enhancements: i) an extention from integer linear programs (ILP) to mixed-integer linear programs (MILP), and ii) replacing diffusion models with flow matching models. The authors conduct extensive experiments, demonstrating improvements over existing methods.
[1] Zeng, Hao, et al. "Effective generation of feasible solutions for integer programming via guided diffusion." ACM SIGKDD 2024.
1. The paper is well-organized with a clear logical flow.
2. Extending the application of generative methods from ILP to MILP is a natural progression.
3. Empirical experiments are comprehensive, and the results show improvements over the selected baselines.
I have reviewed this paper at NeurIPS 2025, and I am satisfied with the revisions made by the authors. I do not have any major concerns, but I have a minor suggestion:
The paper states that "existing generative methods for MILP suffer from a critical limitation: they model the distribution of only the integer variables." However, the transition from ILP to MILP seems relatively straightforward, and this limitation may not constitute a major challenge. I recommend that the authors emphasize the more difficult aspects and make the challenges clearer to the reader.
1. Does the inference time in Table 3 include the time cost of the guidance process?
2. In Table 4, how does the "w/o Continuous" variant perform the guidance? Without continuous variables, how are constraint violations and objective value calculated? |
Lightly AI-edited |
|
FMIP: Joint Continuous-Integer Flow For Mixed-Integer Linear Programming |
Soundness: 3: good
Presentation: 3: good
Contribution: 2: fair
Rating: 4: marginally below the acceptance threshold
Confidence: 3: You are fairly confident in your assessment. It is possible that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work. Math/other details were not carefully checked. |
This paper introduces FMIP a flow model for MILP solving, cast at sampling from a generative model, that defines a method to sample from joint distributions over discrete and continuous variable assignments. This can help capturing interactions between these two sets of variables, which is often missing in previous works on generative models for MILPs.
The model is based on a 'tripartite-graph' a variation of the standard bipartite graph where integer and continuous variables are mapped to two disjoint set of nodes.
However, while the distribution is joint, it is assumed to be factorized and amounts to one independent prediction per variable (discrete or continuous). Only the conditioning is from a complete, and noisy, assignment.
Additionally, authors introduce guidance mechanisms for the two types of
variables helping steer the model's trajectories towards feasible assignments.
For the continuous variables the guidance is based on projected gradient descent to enforce box constraints (the other constraints are taken into account via the violation penalty)
For integer variables, authors use a sample-and-reweight method where the denoiser is used to generate several candidates which are evaluated. The rates are updated to promote (ie, increase the probability) of candidates which combine good objective value and low constraint violation. The final samples are also projected to enforce box constraints.
Eventually, FMIP returns an assignment for the continuous relaxation of the
input MILP, and must be processed further by a solver. In that sense, FMIP
remains a tool to warm-start a solver.
Typos:
- The two first references to Gasse et al. are the same
- The two first references to Taoan Huang et al. are the same
- l. 712 missing space before Edges
- l. 728 why $> 0$ and not $\neq 0$ ?
- l. 753 $t$ and $t$ ??
This paper identifies and highlights one of the blind posts from previous generative models for MILPs: the lack of a proper treatment of continuous variables. I believe this is the main contribution of the paper
- The model is straightforward and amounts to the concatenation of a continuous flow and a discrete flows that can both be conditioned on predicted assignments.
- The tri-partite representation is surprising and questionable (see question below)
1. Where is the 41.34% improvement mentioned in the abstract and the conclusion found in the experiments? Maybe it's lost
2. In Table 4, how is the system "w/o Continuous" implemented? How does it handle continuous variables? This is important since, as mentioned by authors, this performance gap gives a direct evidence that modelling joint distributions as advocated in FMIP is important.
3. Why do you call your graph a tripartite graph instead of a bipartite graph with continuous/discrete binary features for variable nodes? It overcomplicates the model and makes the reader thinks edges between discrete and continuous nodes are allowed.
Besides, line 726 mentions a bipartite graph
4.The discussion lines 468-474 is interesting. Could an additional reason to explain why the number of sampling steps may have a detrimental effect is that the coefficient $\gamma$ given to the violation (and possibly the measure of the violation itself based on the max operator) may lead to a situation where the function $f$ favors constraints over objective? |
Fully human-written |
|
FMIP: Joint Continuous-Integer Flow For Mixed-Integer Linear Programming |
Soundness: 3: good
Presentation: 4: excellent
Contribution: 3: good
Rating: 6: marginally above the acceptance threshold
Confidence: 4: You are confident in your assessment, but not absolutely certain. It is unlikely, but not impossible, that you did not understand some parts of the submission or that you are unfamiliar with some pieces of related work. |
The authors study mixed-integer optimization problems (MILPS) which are computationally hard to solve to optimality in general. Solvers for MILPs benefit from good heuristic start solutions, which can be generated by using state-of-the-art learning methods. The authors propose a generative model which is able to generate good feasible solutions by predicting (compared to previous models) both, integer and continuous variables. The performance of the model is tested on a wide variety of instances and compared to several benchmarks.
The paper is very clearly written and all concepts are presented in a detailed but concise way. The methodology is very sophisticated and the idea of incorporating the continuous variables into the generative model is interesting and hence the whole paper provides an important contribution to the knowledge of the field. The experiments are extensive, although there are some subtle issues which should be improved.
1. The goal of the paper is to provide (exact) solvers with good feasible solutions. Hence I don't understand why there is no state-of-the-art exact MILP solver used as downstream solver (e.g. Gurobi, SCIP or HiGHS)? It would be important to see on very hard instances, how much the predicted solutions improve the performance of the exact solver (e.g. in terms of optimality gap after 1 hour). Solvers as Gurobi have sophisticated methods implemented to search for good feasible solutions. If your extremely complex model (which has to be trained etc.) cannot provide better solutions then it is useless for exact solvers.
2. In the experiments Gurobi is able to provide the same objective values as your model for nearly all instances (except LB and IP, although on LB it nearly achieves the same value). This indicates that the instances which are solved here are quite easy for exact solvers as Gurobi and at the same time Gurobi provides you with an optimality gap (which you should report). So looking at the results as a user I would prefer using Gurobi, which maybe has to run for 3600 seconds but on the other hand it is extremely simple to use: there is no training involved and it provides an optimality gap. As mentioned above, it would be interesting to see how good your predicted solutions are for harder instances.
3. It is not clear from the main paper, what data the model is trained on. Since you have to provide good solutions for the training instances these can only be instances which are easy to solve by the MILP solvers. Your model should be evaluated on instances which are of larger dimension/harder than the training set.
Minor comments:
- The paragraph "Metrics" is not clear enough. What exactly do you mean hear by OBJ and what is BKS? Is BKS the best known solution after running the downstream solver? Why do you compare it to OBJ which I understand is the objective value of the solution predicted by the generative models?
- The statement in abstract and conclusion that the primal gap is reduced by 41.34% is misleading. Gurobi is able to provide primal solutions nearly as good as your model in one hour.
- Why don't you use any exact downstream solvers as Gurobi, SCIP etc.?
- Looking at the experiments, why should I use your (very complex) model involving data collection and training instead of just running Gurobi?
- How good is your model for hard instances which are harder than the instances in the training set?
- How much does your model improve the Gurobi process compared to the standard heuristics implemented in Gurobi? |
Fully human-written |