# What are best practices to make optimization user interfaces intuitive for the user?

For many operations research applications a user will often be in charge of making the final decision and will use the optimization algorithms software as a part of their planning flow.

Therefore, optimization software often needs a user interface that allows the user to:

• Input data required to do the optimization e.g. required demands and available resources that the optimizer should take into account
• Give priorities to different objectives e.g. making a trade-off between reducing cost and increasing the service levels for customers.
• Validate the resulting plan to ensure it is operationally feasible and look for potential improvements
• Iterate on the plan, e.g. based on the optimized solution they might realize they forgot to add a constraint and don't want to start the optimization from scratch again.

Often, a planner will not have an operations research background and the software needs to be easy and intuitive so the user (and organization) will capture the value from the optimization algorithms. I am, therefore, very interested in:

• What are examples of optimization software with an excellent and intuitive user interface? (screenshots would be great)
• Are there some good principles to use when building the user interface?
• Are there any research papers addressing this issue?
• To formulate it slightly differently: How can we design optimization applications that are as simple and powerful as an IPhone, to allow more people to get value out of optimization?

Example A simple user interface for a GPS that allows the user to change between different objectives (speed vs. fuel) and constraints (walking vs. highways)

I think it's a bit of general question. AFAIK, this subject can be surveyed in many aspects. Designing of an optimization software depends on its specific and related field. For example, architecting and developing of the mathematical programming software like CPLEX or Gurobi is quite different from developing navigation software.

Based on what problem you are trying to optimize and propose to develop its software solution, you might need to determine which kind of algorithms (exact or (meta)heuristic) could be applied. It may affect your software architecting, Specifically, on the software development and services level price.

To users/clients, it is so important to use the software easy and flexible. As you said, clients may not have any experience or educational background about that. It's about, input data, easy modifying, easy adjusting, flexible output based on what clients looking for and finally, having a nice user interface would be attractive.

As I am interested in planning and scheduling, specifically in industries and real situation, I try representing two optimization software (Indeed, I am aware many examples could be represented by others.). One, based on academic works and the other commercial software:

• based on academic work: LAKIN

It was developed by Prof. Michael Pinedo and his team at the Stern School of Business, NYU. It has a nice interface and using some rules and heuristics to solve the scheduling problems. It enables users to modify and adjust planning after solving the model and easily reoptimize the problem. I really enjoy it.

• Commercial: (Disclaimer: this is to introduce for academic.)

Much commercial software could be applied in practice but, I would like to represent a simulation software, ARENA. It has a flowchart interface which clients can use it easily. It has many specific features to modify and reoptimize the model.

It would be considered, Developing an optimization software may fail. One of the nice topics could be found here on or.stackexchange.

Finally, there are many academic and practical papers on the commercial software host like this or this to use and benchmark.

• Thank you for the answer and especially sharing some screenshots from applications you like. I especially like that you can easily modify and re-optimize which I think is very important. Can you share some more in-depth details or an example of how this user-flow works? How many clicks and inputs do the user need to make? how long time does it usually take to re-optimize? – Michael Lindahl Jan 4 at 15:59
• Thanks so much. I will try providing some useful information on the next days. – A.Omidi Jan 4 at 19:05

You mentioned: "Often, a planner will not have an operations research background and the software needs to be easy and intuitive so the user (and organization)...". So, I assume by optimization software you mean software with an OR algorithm in the background for an end-user.

I include two screenshots from some searches. I got the screenshots from their videos and I have not tested any of these myself. But their videos looked to have intuitive user-interface and I don't think it's very hard for someone to get a demo of them.

1. A container loading software that one can assume should be based on solutions of (3D) bin packing problems:
2. A routing app:

And in regards to good principles to use when building the user interface: you mentioned the right keywords yourself "principles of user interface design" or "user interface design". These are just Wikipedia links, but there are many great Youtube videos that talk about these design principles in action (for example, check Apple videos on Youtube).

• Thank you very much for finding and sharing these examples. It would be great to understand the practical user flow a bit further. One thing I noticed in both videos is that the decision flow looks quite linear. Put in data->Optimize->Done. Where in practice it is often very iterative and the user have to update the data and combine the optimal solution with some manual changes and updates to the data. Would be great to see if someone had perfected that flow. – Michael Lindahl Jan 5 at 19:49
• For that, I'll say also check gurobi demos. If you think it's worth it, I'll update my answer with some screenshots of their demo too. Also, there are companies that can exactly do that (including the one I work for, which you can find it on my profile): load your input data, optimize, see your outputs. If you need to change the data or some parameters and re-optimize or run other scenarios and compare them all together based on some metrics, that's doable. – EhsanK Jan 5 at 20:23
• What I am hoping for, is to see some above-average UX-flows for optimization applications, where there have been put some serious consideration into how it can be as easy and simple for the user as possible to make the power of optimization available to people without or-background. To formulate it a bit differently, "If Steve Jobs build optimization software, how it would work?" ;) – Michael Lindahl Jan 8 at 20:42

As well as the visual design, discussed in other answers, it's worth thinking about how back-end choices in the optimisation model can make for a more intuitive system.

One thing that can sometimes be helpful is to consider how the system will react to user decisions, and to try to make that as intuitive as possible.

For example, a couple of years ago I implemented an optimisation-based solution to an economic accounts balancing problem:

• We have tables containing tens of thousands of economic data points.
• This data should satisfy certain consistency rules (if you add up how much every economic sector spends buying cars, and add up how much every sector gets from selling cars, those should be the same number)
• Because of various measurement error issues, the initial estimates don't satisfy those rules.
• Subject matter experts resolve major discrepancies manually, but we need to remove thousands of small discrepancies by automated adjustment.

So the optimisation problem is "find values that satisfy consistency constraints (mostly linear) while minimising changes from the initial values". The big challenge here is that "minimising changes" is fuzzily defined:

• Do we use an absolute-value (linear) measure of change, or squared change (quadratic) for our OF?
• We need to weight these adjustments, because some values are more reliable than others, but this information isn't written down - we can set some reasonable default values but the end users (economic subject matter experts) will need to be able to fine-tune these weights when they spot unreasonable behaviour.

So I wanted to design the system in a way that would make it as intuitive as possible for the users in understanding how their weighting choices would affect the outputs.

This has a couple of implications:

From a usability perspective, a quadratic OF is better than a linear (abs-value) OF here. With a linear OF, solutions will always lie on the vertices of the feasible region. This means that when you make changes to the objective function weights, you might see no change at all to the solution. Or you might see a very large change as the solution moves from one vertex to another, even in response to a very small change in the weights.

By contrast, with a quadratic OF, solutions move gradually as you change the weights. In general, a small change in weights will result in a small but non-zero change to the outputs, and larger changes in weights will drive larger changes to the outputs.

This makes the quadratic OF much more intuitive for a user whose interest is "how do my decisions about the weights affect the final results?"

(There are other good reasons for using a quadratic OF in this problem, but those don't relate to usability.)

The next question is, how should weights be specified? Some back-of-the-envelope work suggests that on average, adjustments to an item will be roughly in proportion to 1/weight for that item. Since my users are more likely to think in terms of "how much can we adjust this?" than "how much should an adjustment cost?" I set things up so that they provide the weighting info in terms of "adjustability" and this is internally transformed into a weight.

Baking these choices into the optimisation model made it a lot easier to provide users with an intuitive interface.

Obviously, there will be many problems where you don't have the luxury of letting usability considerations influence the objective function, but when you do it's worth exploring!

The data in question is a system of interrelated tables. The full representation is about five dimensions, but users are normally looking at a two-dimensional slice of the problem. Rows = products (different kinds of goods and services), columns = economic sectors (household, government, export/import, non-profits, 67 different industries, etc. etc.)

Each cell represents the total value bought or sold for that product for that sector in the reference period. In any one of these two-dimensional slices, there are about 24,000 cells, each of which needs a weight.

Our users are familiar with spreadsheets, so that's how they interact with this. For each cell, they specify an "adjustability rating" indicating what they would consider a reasonable adjustment, in percentage terms, relative to the unadjusted value. (Rather than specifying 24,000 values individually, a lot of this is filled in by general rules - "all data from this source gets 10% adjustability", that sort of thing - with the most significant cells getting closer attention.)

A heatmap visualisation of adjustability ratings makes it easier to eyeball the weighting information and see a general pattern of weighting choices.

A macro then converts all the data from the spreadsheet to something the optimisation code can work with. "Percentage adjustability" is multiplied by the unadjusted value to get adjustability in dollars, and then weights are set as 1/adjustability.

In a simple system where we have one constraint $$x_1+...+x_n=c$$, and our objective function is a sum of $$w_ih_i^2$$ where $$h_i$$ is the adjustment made to each value, the $$h_i$$ will be in proportion to $$1/w_i$$.

In this complex economic system, any one cell is involved in several different constraints, so this relationship doesn't hold exactly, but it's good enough for an order-of-magnitude approximation.

Once the optimisation is done, we can then "score" the actual adjustments relative to expected adjustments, and then use another heat-map visualisation to give the big picture on what's going on in the table. For example, if we see a prominent horizontal red stripe, that means we're making a lot of big adjustments for one product (rows = products), so our analysts might want to double-check that product and see if anything weird is going on - for instance, there might be some issue that requires manual intervention. OTOH, a vertical stripe means something going on within the sector rather than the product.

Along with that, we do produce a list of unusually large adjustments at sector x product level. But often these are driven by something happening elsewhere, so the heat-map visualisation is helpful in understanding how these individual adjustments relate to the big picture.

The way I approached weighting is to ask users to indicate what they would consider a "reasonable adjustment" for each of these cells, as a percentage of the original value. .

• Can you elaborate on the process of choosing weights by giving an example? What users see, what they input, how weights are updated in the background. Thanks. – Henrik Alsing Friberg Jan 10 at 11:36
• @HenrikAlsingFriberg Unfortunately I'm not able to provide screenshots etc. at the moment (I no longer work in that area and don't have access to those systems, plus some of the data involved has sensitivities) but I've added some discussion. – Geoffrey Brent Jan 11 at 3:17
• Thanks for your answer. I agree that how you formulate the model also have a great impact on how intuitive it will be. Often you have multiple objectives, and I usually tend to use lexicographic optimization than weighted sum, as this makes it very easy for a user to understand how the trade-offs are made. – Michael Lindahl Jan 19 at 18:05