arXiv subjects

Matteo Fischetti

Publications and source records attributed to Matteo Fischetti.

9 recordsLinked to original sources

arXiv2026

A Dantzig-Wolfe reformulation of the EndoWake model for optimal wind farm layouts

Wind Farm Layout Optimization places turbines to maximize the expected energy under a wind rose, each turbine lowering the wind downwind. In the EndoWake model the wind field is a variable, propagated by linear inequalities, and layouts are certified by branch-and-check. On a ladder of grids it certifies the $10\times10$ grid and leaves the larger grids open after one hour. We tighten the relaxation by a convexification computed rather than derived: every pattern of turbines inside a small tile of the grid is enumerated once with its power and enters the master as a column. The device is valid because the wind field is antitone, and exact, for the cubic power curve, with a Benders cut at integer layouts. Reduced-cost fixing and propagation between overlapping tiles shrink the master before the tree search, and the tree repeats the fixing at every improving incumbent. The incumbent comes from a tile heuristic or an LP dive. On the same computer as the branch-and-check, the $12\times12$ and $14\times14$ grids close in 48 and 395 seconds. The $16\times16$ grid is certified on five seeds from random starts, one job per seed, the heuristic on a GPU, in 1413 seconds under the uniform rose and 6484 seconds under a non-uniform one. Times are medians. A pre-specified test set of 36 unseen instances with forbidden cells confirms the advantage in the axial setting. Certified means closed at the solver's gap of $10^{-4}$: the optimum lies within it plus a residual of at most 0.00042%.

math.OC↗

arXiv2026

GPU-accelerated wind farm layout search with a distilled endogenous wake model (EndoWake)

We build on EndoWake, an endogenous wake model that links the wind speed at every grid cell to its upwind neighbors by linear constraints, so that wake field, siting decisions and project constraints share one mixed-integer model. Its four parameters are calibrated once on the single wake of a Reynolds-averaged Navier-Stokes (RANS) simulation, and a graphics processing unit (GPU) scores over a million layouts per second per wind direction. At Lillgrund, we compare searches guided by EndoWake and by PyWake under a RANS judge that no search calls: the fidelity of a wake model is not the quality of the layouts optimized under it. Two diagnostics separate a quadrature error between the sampled wind directions from a surrogate bias localized off each wake edge, not reported before to our knowledge; at random directions, five paired starts detect no difference between the pipelines. The main result puts the speed to use: EndoWake ranks the moves of a local search on the GPU, and PyWake confirms every accepted move. On twenty unseen starts, with one GPU and thirty CPU processes, screen-and-confirm reaches similar mean gains to a search on PyWake alone, 7.9 times faster at one wind speed and 14.9 times faster on the annual energy (3.0 and 4.7 with a proof of local optimality charged to the timed search); on a second site it keeps its speed, and its local optima fall slightly short of those of PyWake alone. Code and data are deposited on Zenodo.

math.OC↗

arXiv2026

EndoWake: Modeling Wind by Linear Programming for Wind Farm Layout Optimization

The Wind Farm Layout Optimization problem consists of placing a given number of turbines within a given area so as to maximize energy production. One of its main challenges is the wake effect between turbines, which can strongly affect production and is a cumbersome function to evaluate and to embed in an optimization framework. In this paper we introduce a new endogenous wake model (EndoWake), based on the idea of treating the wind speed at every grid point as a decision variable, linked to its upwind neighbors through linear propagation constraints. This makes it possible to incorporate the wake equations directly into a Mixed-Integer Linear Programming (MILP) model. We then develop such a MILP model and, in particular, introduce a new class of valid "band" inequalities, showing that they substantially strengthen the root bound. Building on this, we design a branch-and-check scheme: the master problem retains only the site variables together with one hypograph variable per cell and scenario, integer solutions are evaluated by an exact linear-time oracle, and the optimality cuts are problem-specific "upwind cuts". Computational results are reported on a ladder of square grids under a four-sector axial wind rose, demonstrating the effectiveness of the proposed improvements.

math.OC↗

arXiv2026

Minibatch persistency, eight years later: what batch reuse costs in steps and joules, and what it saves in data

Minibatch persistency reuses data instead of reading it: rather than drawing a fresh minibatch at every optimizer step, it takes K consecutive steps on the same one. Absorbed into data echoing in 2019, it has carried one objection -- that reuse merely imitates a larger learning rate -- and no baseline tuned as carefully as the method itself. This paper runs the missing test. A pre-registered study trains a 49M-parameter Transformer on FineWeb-Edu at minibatch size B in {32, 128, 512}, 8 seeds per cell, tuning the learning rate separately for every batch size and every arm, against a reuse-free control that changes the sampling and nothing else. Each headline claim is a cost to reach a fixed loss, read on four axes: optimizer steps, fresh tokens, seconds, and joules at the socket. We then replicate on new seeds and a newer GPU generation, and put the three arms on one schedule in steps. The outcome of our study is that what minibatch reuse buys is neither speed nor energy but data, and only at large minibatch size: at B = 32 it reads more fresh tokens than the baseline, not fewer. On steps, seconds and joules it is at best free; and at B = 512, where it looks best, a registered control cannot separate the effect of reuse from the position on the learning-rate schedule at n = 8 seeds. The technique is therefore worth using where fresh data rather than compute is the binding cost: a corpus that runs out, a pipeline that pays per sample, a stream that cannot be rewound. Where the data can simply be read again, spaced epochs do as well or better.

cs.LG↗

arXiv2022

Revisiting local branching with a machine learning lens

Finding high-quality solutions to mixed-integer linear programming problems (MILPs) is of great importance for many practical applications. In this respect, the refinement heuristic local branching (LB) has been proposed to produce improving solutions and has been highly influential for the development of local search methods in MILP. The algorithm iteratively explores a sequence of solution neighborhoods defined by the so-called local branching constraint, namely, a linear inequality limiting the distance from a reference solution. For a LB algorithm, the choice of the neighborhood size is critical to performance. In this work, we study the relation between the size of the search neighborhood and the behavior of the underlying LB algorithm, and we devise a leaning based framework for predicting the best size for the specific instance to be solved. Furthermore, we have also investigated the relation between the time limit for exploring the LB neighborhood and the actual performance of LB scheme, and devised a strategy for adapting the time limit. We computationally show that the neighborhood size and time limit can indeed be learned, leading to improved performances and that the overall algorithm generalizes well both with respect to the instance size and, remarkably, across instances.

math.OC↗

arXiv2019

Finding First and Most-Beautiful Queens by Integer Programming

The n-queens puzzle is a well-known combinatorial problem that requires to place n queens on an n x n chessboard so that no two queens can attack each other. Since the 19th century, this problem was studied by many mathematicians and computer scientists. While finding any solution to the n-queens puzzle is rather straightforward, it is very challenging to find the lexicographically first (or smallest) feasible solution. Solutions for this type are known in the literature for n <= 55, while for some larger chessboards only partial solutions are known. The present paper was motivated by the question of whether Integer Linear Programming (ILP) can be used to compute solutions for some open instances. We describe alternative ILP-based solution approaches, and show that they are indeed able to compute (sometimes in unexpectedly-short computing times) many new lexicographically optimal solutions for n ranging from 56 to 115. One of the proposed algorithms is a pure cutting plane method based on a combinatorial variant of classical Gomory cuts. We also address an intriguing "lexicographic bottleneck" (or min-max) variant of the problem that requires finding a most beautiful (in a well defined sense) placement, and report its solution for n up to 176.

cs.DS↗

arXiv2019

Embedded hyper-parameter tuning by Simulated Annealing

We propose a new metaheuristic training scheme that combines Stochastic Gradient Descent (SGD) and Discrete Optimization in an unconventional way. Our idea is to define a discrete neighborhood of the current SGD point containing a number of "potentially good moves" that exploit gradient information, and to search this neighborhood by using a classical metaheuristic scheme borrowed from Discrete Optimization. In the present paper we investigate the use of a simple Simulated Annealing (SA) metaheuristic that accepts/rejects a candidate new solution in the neighborhood with a probability that depends both on the new solution quality and on a parameter (the temperature) which is modified over time to lower the probability of accepting worsening moves. We use this scheme as an automatic way to perform hyper-parameter tuning, hence the title of the paper. A distinctive feature of our scheme is that hyper-parameters are modified within a single SGD execution (and not in an external loop, as customary) and evaluated on the fly on the current minibatch, i.e., their tuning is fully embedded within the SGD algorithm. The use of SA for training is not new, but previous proposals were mainly intended for non-differentiable objective functions for which SGD is not applied due to the lack of gradients. On the contrary, our SA method requires differentiability of (a proxy of) the loss function, and leverages on the availability of a gradient direction to define local moves that have a large probability to improve the current solution. Computational results on image classification (CIFAR-10) are reported, showing that the proposed approach leads to an improvement of the final validation accuracy for modern Deep Neural Networks such as ResNet34 and VGG16.

cs.LG↗

arXiv2018

Faster SGD training by minibatch persistency

It is well known that, for most datasets, the use of large-size minibatches for Stochastic Gradient Descent (SGD) typically leads to slow convergence and poor generalization. On the other hand, large minibatches are of great practical interest as they allow for a better exploitation of modern GPUs. Previous literature on the subject concentrated on how to adjust the main SGD parameters (in particular, the learning rate) when using large minibatches. In this work we introduce an additional feature, that we call minibatch persistency, that consists in reusing the same minibatch for K consecutive SGD iterations. The computational conjecture here is that a large minibatch contains a significant sample of the training set, so one can afford to slightly overfitting it without worsening generalization too much. The approach is intended to speedup SGD convergence, and also has the advantage of reducing the overhead related to data loading on the internal GPU memory. We present computational results on CIFAR-10 with an AlexNet architecture, showing that even small persistency values (K=2 or 5) already lead to a significantly faster convergence and to a comparable (or even better) generalization than the standard "disposable minibatch" approach (K=1), in particular when large minibatches are used. The lesson learned is that minibatch persistency can be a simple yet effective way to deal with large minibatches.

cs.LG↗

arXiv2017

Deep Neural Networks as 0-1 Mixed Integer Linear Programs: A Feasibility Study

Deep Neural Networks (DNNs) are very popular these days, and are the subject of a very intense investigation. A DNN is made by layers of internal units (or neurons), each of which computes an affine combination of the output of the units in the previous layer, applies a nonlinear operator, and outputs the corresponding value (also known as activation). A commonly-used nonlinear operator is the so-called rectified linear unit (ReLU), whose output is just the maximum between its input value and zero. In this (and other similar cases like max pooling, where the max operation involves more than one input value), one can model the DNN as a 0-1 Mixed Integer Linear Program (0-1 MILP) where the continuous variables correspond to the output values of each unit, and a binary variable is associated with each ReLU to model its yes/no nature. In this paper we discuss the peculiarity of this kind of 0-1 MILP models, and describe an effective bound-tightening technique intended to ease its solution. We also present possible applications of the 0-1 MILP model arising in feature visualization and in the construction of adversarial examples. Preliminary computational results are reported, aimed at investigating (on small DNNs) the computational performance of a state-of-the-art MILP solver when applied to a known test case, namely, hand-written digit recognition.

cs.LG↗