Overslaan naar inhoud

Wij volgen optimalisatieonderzoek en dragen bij aan open source

Wiskundige optimalisatie wordt sinds 1947 gepubliceerd, bediscussieerd en verbeterd. Er komen voortdurend nieuwe methoden bij. Wij lezen ze, meten ze op de instanties die onze klanten echt insturen, en wisselen van solver zodra de cijfers dat zeggen. De connectoren tussen de modelleertaal Julia en die solvers zijn open source, en wij onderhouden ze in het openbaar.

GitHub-organisatie
NexOR-Optimization
Geschreven in
Julia, Python
Bijdragen
JuMP-kern en solverbruggen
Conferenties
JuMP-dev, Odoo Experience
Academische banden
UCLouvain

Tachtig jaar methoden

Acht decennia resultaten, en geen enkele methode die het gehaald heeft. Elke vermelding hieronder is een gedateerde publicatie, met de mensen die het schreven.

Optimalisatie begon als een planningsprobleem in oorlogstijd en groeide uit tot een vakgebied. De simplexmethode verscheen in 1947, en de vijftien jaar daarna leverden het meeste gereedschap op dat vandaag nog draait: dynamisch programmeren, snijvlakken, branch and bound, kortste paden, en de decomposities waarmee één groot probleem als een reeks kleine wordt opgelost.

Toen liet Karp in 1972 zien waarom het werk nooit af zou zijn. Een hele familie gewone planningsproblemen heeft geen bekend efficiënt exact algoritme, en er is er sindsdien geen gevonden. Het antwoord was niet één beter algoritme maar vele, geleend waar ze maar te vinden waren: simulated annealing bij de metallurgie, tabu search bij het idee van een kort geheugen, genetische algoritmen en ant colony optimisation bij de biologie, constraint programming bij de logica, en large neighbourhood search bij de vaststelling dat een goed plan meestal één kleine wijziging van een beter plan verwijderd is.

Geen ervan heeft gewonnen, en dat is precies het punt. Elk is sterk op een vorm van probleem die de andere slecht aankunnen, dus hield het vakgebied ze allemaal en leerde het ze te combineren: exact zoeken gestuurd door heuristieken, constraintpropagatie ondersteund door clause learning, en sinds kort vertakkingsbeslissingen geleerd uit data. De laatste jaren kwamen daar eerste-orde-methoden en GPU's bij, die lineaire programma's heropenen op groottes waarvoor de simplexmethode nooit bedoeld was.

jaren 1940

  • 1947
    Simplex method
    Dantzig

jaren 1950

  • 1954
    Cutting planes for the TSP
    Dantzig, Fulkerson and Johnson
  • 1957
    Dynamic programming
    Bellman
  • 1958
    Integer cutting planes
    Gomory
  • 1959
    Shortest paths
    Dijkstra
  • 1959
    The vehicle routing problem
    Dantzig and Ramser

jaren 1960

  • 1960
    Branch and bound
    Land and Doig
  • 1960
    Dantzig-Wolfe decomposition
    Dantzig and Wolfe
  • 1961
    Column generation
    Gilmore and Gomory
  • 1962
    Benders decomposition
    Benders
  • 1964
    Clarke-Wright savings
    Clarke and Wright

jaren 1970

  • 1970
    Lagrangian relaxation
    Held and Karp
  • 1972
    NP-completeness
    Karp
  • 1973
    Lin-Kernighan
    Lin and Kernighan
  • 1975
    Genetic algorithms
    Holland
  • 1977
    Arc consistency
    Mackworth
  • 1979
    Ellipsoid method
    Khachiyan

jaren 1980

  • 1983
    Simulated annealing
    Kirkpatrick, Gelatt and Vecchi
  • 1984
    Interior point methods
    Karmarkar
  • 1986
    Tabu search
    Glover
  • 1987
    Constraint logic programming
    Jaffar and Lassez

jaren 1990

  • 1991
    Branch and cut
    Padberg and Rinaldi
  • 1992
    Ant colony optimisation
    Dorigo
  • 1994
    The alldifferent constraint
    Regin
  • 1996
    Conflict-driven clause learning
    Marques-Silva and Sakallah
  • 1997
    Variable neighbourhood search
    Mladenovic and Hansen
  • 1998
    Branch and price
    Barnhart and others
  • 1998
    Large neighbourhood search
    Shaw

jaren 2000

  • 2005
    Feasibility pump
    Fischetti, Glover and Lodi
  • 2006
    Adaptive large neighbourhood search
    Ropke and Pisinger
  • 2007
    MiniZinc
    Nethercote and others
  • 2009
    Lazy clause generation
    Ohrimenko, Stuckey and Codish

jaren 2010

  • 2017
    JuMP
    Dunning, Huchette and Lubin
  • 2019
    Learned branching heuristics
    Gasse and others

jaren 2020

  • 2020
    Neural diving for mixed-integer programs
    Nair and others
  • 2021
    First-order methods for large linear programs
    Applegate and others
  • 2023
    Linear programming on GPUs
    Lu and Yang

Het vakgebied volgen hoort bij het werk

Een groeiende solvercatalogus

Het aantal solvers dat wij ondersteunen blijft toenemen. Elke nieuwe solver komt via dezelfde JuMP-interface in de catalogus, gemeten tegen de solvers die er al staan en gepubliceerd met zijn tarief.

Solverreleases

Elke solverrelease verschuift welke solver het snelst is op welk probleem. Wij draaien onze benchmarkset opnieuw op elke nieuwe versie en verzetten de standaardsolver alleen wanneer de winst op meer dan één instantie standhoudt.

Gepubliceerd onderzoek

Operationeel onderzoek wordt in de openbaarheid gepubliceerd, zodat een methode gelezen en gecontroleerd kan worden voordat iemand erop bouwt. Wij volgen de literatuur over routering en planning en implementeren wat zich op klantgegevens bewijst.

De JuMP-dev-workshop

Op JuMP-dev nemen de mensen die de modelleerlaag en haar solverinterfaces onderhouden het werk van het jaar persoonlijk door. Wij gaan erheen, en wij presenteren er.

De Odoo Experience-conferentie

Odoo Experience brengt de roadmap van Odoo en zijn klanten in één zaal samen. We gaan er luisteren naar wat zij nodig hebben, tonen wat we doen, en houden ons optimalisatiewerk passend bij het platform waarop het draait.

Onze eigen benchmarkset

Een methode verdient haar plaats in de catalogus door te winnen van wat er al staat. Wij meten dat op instanties die wij uit echte klantproblemen bewaren, niet op de benchmarks die de auteurs zelf kozen.

Julia, en de laag waarin het vakgebied modelleert

Julia is waar veel van het huidige optimalisatieonderzoek geschreven wordt. Het draait op de snelheid die solvers nodig hebben en leest dicht bij de wiskunde, zodat een artikel en zijn implementatie herkenbaar hetzelfde blijven.

JuMP ligt daarbovenop. Beschrijf een probleem één keer, in bijna wiskundige syntaxis, en geef het door aan een van de meer dan 30 solvers achter één interface. Het is de de-factostandaard in de Julia-gemeenschap en de ruggengraat van optimalisatieonderzoek aan Europese universiteiten, waaronder UCLouvain, waar een deel van ons team is opgeleid.

Wij werken eraan, niet alleen ermee. Teamleden dienen pull requests in op de kernpakketten, onderhouden solverinterfaces en presenteren op de JuMP-dev-workshop.

Gebouwd op JuMP, algebraïsche modelleertaal Programmeertaal Julia

Getoond op JuMP-dev

Benoît Legat, een van onze oprichters en kernontwikkelaar van JuMP, toont de stack achter NexOR aan de gemeenschap die JuMP bouwt.

De speler laadt pas van YouTube nadat u op afspelen drukt.

Wat wij openbaar onderhouden

De solverbruggen, de modelleerlagen en de client die onze servers bereikt. Ze blijven op GitHub onder hun eigen licenties.

Hexaly.jl

JuMP-interface naar Hexaly, een commerciële high-performance solver voor constraint programming en metaheuristieken. Laat Julia-modellen Hexaly rechtstreeks aansturen.

MaxiCP.jl

JuMP-interface naar MaxiCP, een academische constraint-programmingsolver die aan UCLouvain onderhouden wordt. Open source, solver inbegrepen.

Vroom.jl

JuMP-interface naar VROOM, een veelgebruikte opensource Vehicle Routing-solver. Brengt VROOM in de gereedschapskist van Julia en JuMP.

OscaRCBLS.jl

JuMP-interface naar OscaR.cbls, een bibliotheek voor constraint-based local search van CETIC. Zet lokaal zoeken achter dezelfde modelleertaal als de exacte solvers.

MathOptVRP.jl

JuMP-uitbreiding voor Vehicle Routing Problems. Modelleert stops, capaciteiten en tijdvensters als een routeringsmodel dat JuMP aan elke solver kan doorgeven.

JuMPy

Een Python-interface naar MathOptInterface. Modellen worden één keer als sjabloon geschreven en in gecompileerde Julia uitgeschreven, zodat een groot model bouwen niet langer meer kost dan het oplossen.

ContractionHierarchies.jl

Kortstepadberekening op OpenStreetMap-grafen met contractiehiërarchieën. Het bouwt de afstands- en reistijdmatrices die een optimalisatiemodel als invoer neemt.

NexOR.jl

Julia-client voor onze solve-API. Een model dat in JuMP geschreven is, wordt op onze servers opgelost in plaats van op de lokale machine, en de resultaten komen terug in dezelfde sessie.

Open wiskunde wint van black-box-wiskunde.

Controleerbare modellen

De solverbruggen staan in code die iedereen kan lezen, en de solvers die ze bereiken ook. De wiskunde is geen black box die u op vertrouwen moet aannemen.

Getoetst door onderzoek

JuMP en zijn solvers worden gebruikt in operations-research labs wereldwijd. De modellen die wij uitbrengen worden kritisch bekeken door de globale community.

Geen vendor lock-in

De bruggen blijven op GitHub onder hun eigen open licenties, wat er ook met ons gebeurt. Uw data en uw database zijn van u en u kunt ze altijd exporteren.

Op maat van de klant

Een solver die uw realiteit niet modelleert, is gewoon trage software. Wij breiden de open packages uit zodra een klantconstraint nog niet wordt ondersteund.

De optimalisatiecode die wij schrijven is open source

github.com/NexOR-Optimization