neural - MINLP solvers | Neural solvers

What is it?

Octeract Neural is our latest experimental technology that solves optimisation problems using machine learning. This is something that works very well for us and for the kinds of problems we solve in production for clients. Optimisation problems are so vastly varied that we honestly don’t know how well it will work for you and the problems you have, so we are now testing whether this is something people like you will find useful. One thing we will say about its performance is that internally we use it more than we do our own engine, and that’s a product that’s broken multiple world records.

If the technology is well received and people use it a lot, we plan to invest into improving the public service, and to eventually monetise it. This will allow us to add more compute, increase usage limits, and of course to train larger and better models.

The service is currently free of charge.

Deepmind references

Parts of the technology are based on Deepmind’s work on Neural Diving, Neural Large Neighbourhood Search, and FunSearch. It’s pretty cool stuff, you should check them out if you haven’t already. We adapted those concepts to work for nonlinear programming, and expanded them using our own technology to be much more compute efficient.

How does it work?

Octeract Neural is a complex system with numerous components. Part of the service is an automated algorithmic generation framework which is capable of dynamically spawning a custom algorithm to solve the exact problem you submitted. We also use a number of generative techniques to predict parts of the solutions.

The model currently available for public testing is called neuralF_small, which is a lightweight Neural Feasibility model.

What can i use it for?

neuralF_small is trained to find good feasible points for nonlinear problems as quickly as possible. Your anonymised model (the .nl file) will be added to our training set and, even if you don’t get a solution immediately, the system will keep trying to solve it in the background, which means you may receive a notification in your mailbox that your problem was solved at a later time.

Here’s a few cool things you can do with it:

Solve large systems of nonlinear equations.
Solve any type of nonlinear and mixed-integer feasibility problems.
Find good feasible points for nonlinear and mixed-integer optimisation problems.
(coming soon) Find almost feasible points, either to warm start other solvers or to use in practice because they’re good enough.

Why only (MI) nonlinear problems? What about MIPs???

There are three main reasons:

First, there are already plenty of excellent MIP solvers out there so it’s much harder to give you something you are likely to use frequently. Nonlinear solvers on the other hand are a bit meh.

Second, even though we do have MIP Neural models capable of outperforming current MIP solvers, they are much more expensive to evaluate, and the performance gap is not as impressive. Modern MIP solvers are very good at what they do. However, depending on how successful we are in eventually monetising the service, it may become cost-effective for us to start making some of those models publicly available.

Third, in our experience feasibility is not nearly of as much practical interest in MIP as it is in nonlinear programming.

How does it compare against solver X?

It doesn’t. No, really. Different solvers are good are different things, and Octeract Neural will not necessarily be a substitute for other things you currently use. For instance, neuralF_small does not guarantee optimality. In fact, it’s not even trained to achieve it. The system attempts to predict a good feasible solution with no guarantees of optimality (local or global) whatsoever. It can be very fast, and it can solve some very hard things, but it’s not a solver in the way we understand solvers today.

Octeract Neural is a numerical AI platform, and it’s the first of its kind. Like a solver, it consumes mathematics and returns a result, but that’s where the similarities end. As an algorithmic and numerical generation platform, Neural doesn’t do the same things a solver does, nor does it behave the same way. There is no single executable doing calculations in the backend, it’s a distributed system with many moving parts.

Is it ok if I run a bunch of benchmarks?

Sure, knock yourself out. Just keep in mind a few things:

The model is trained on a vast number of problems, including publicly available ones. Just because it’s good at something it’s seen before that doesn’t mean much about how good it will be for your specific use case. This is the same with regular solvers by the way. It may be stellar or it may break horribly. Either way, testing it on things we’ve seen before won’t tell you much.
We have usage limits in place to help us manage server load. There are daily solving limits per account, as well as timeouts between API calls. This is necessary for us to be able to provide enough compute for everyone, and it also means that you can’t just spam the system with a thousand problems just to see “how fast it is”. We get it, and we love doing such tests ourselves, but our priority is to enable people to solve real problems.
This is a distributed system that does not guarantee optimality and runs on diverse hardware with varying load and a queuing system in place, so I have no idea whatsoever what exactly you’d be benchmarking, other than simply whether it finds a good solution to your problem in reasonable time.
Aside from major updates, the system also updates itself over time, so there is no one version you are testing against.
All the network components of this are still very much in beta testing. You can fully expect the service to break in all sorts of unexpected ways, which will bias any metrics you are trying to quantify. If you do manage to break it, please help us make it better by contacting support.

How do i use it?

You can access our cloud service by creating a user account and downloading the Neural client for Linux or Windows. You can then retrieve an API key from your account page, which the client will use to send your problem to our servers and to retrieve the solution if one is found. Check out our documentation for tutorials on how to set that up.

The Neural client is currently supported for Pyomo on Windows and Linux. It’s not too hard to get it up and running on JuMP too, but we don’t officially support that yet.

As far as you are concerned, if you are using a framework with an ASL interface (e.g. Pyomo) you can install and run the client exactly as you would a regular solver.

Where can I use it?

Wherever you want. As long as you comply with our terms of use you can use it in any (legal) way you want and install it wherever you want.

Usage limits

Usage limits are in place to help us manage server load. These are very extremely likely to change over time as we figure out the best way to meet demand and expand our compute. There’s also a file size limit which you’re unlikely to encounter since you’re solving nonlinear problems. You can let us know if you do, so that we can look into increasing it in the future.

These are the current limits:

50 solves/day per user. This renews at midnight UK time.
15 second timeout between solves.
5 minute timeout per solve attempt.

Development notes

Since this is a demo of a service still under heavy development, there are a few things you should know:

The service may go down at any time, and for prolonged periods of time. This can be due to updates, maintenance, server issues, etc. Don’t use this for anything that requires constant uptime.
Versions of the Neural client are not backwards compatible. Once a new version is out, the old version will be rejected by the server and you’ll need to download the latest one. This makes it much easier for us to rapidly iterate while the service is in beta.
There’s only so much we can see in the logs. If for some reason you can’t access the server at all, we can’t see anything. If you do encounter issues, please contact support so that we can fix them.
To keep the scope of development as focused as possible, we currently only officially support Pyomo (there’s also a short tutorial on setting that up in the docs). Unofficially, it’s pretty straightforward to get it working with anything that has an ASL/.mps/.lp interface. If you would like support for another framework, let us know and we’ll consider adding it if there’s enough demand.
This is a free service, and is provided “AS IS”. Make sure to check the full Terms of Use before using the service.
We will consider adding MIP if there is significant interest. If this is a feature you really want, you can let us know by joining the waiting list by clicking the button below.

Octeract Neural overview