Tunny Icon
TunnyDocs

The next-gen Grasshopper optimization tool.

Usage Guide

This page is a practical guide to when and which method to use when applying MCDM (Multi-Criteria Decision Making) to pick candidate trials from multi-objective optimization results. It contains no formulas or implementation details. For how each method works, see the individual pages (TOPSIS, VIKOR, PROMETHEE).

When to use MCDM

Multi-objective optimization rarely yields a single best solution. Instead you get a set of candidates that trade off against each other (the Pareto front): "the most accurate solution also costs the most", "the cheapest solution isn't accurate enough", and so on.

MCDM is used at the stage of selecting or ranking the "overall best" trial from that candidate set. Optimization finds candidates; MCDM chooses among them.

Aspect Multi-objective optimization MCDM
Role Search for good candidates Compare and select candidates
Input Search space, objectives, constraints Candidate set, criteria, weights
Output Pareto front, objective values Scores, ranking, selection rationale
Nature Algorithmic search Reflects the decision maker's values

MCDM does not automate the decision. It is a tool for organizing the evidence and making the rationale explainable. The top-ranked trial is not always the one you should adopt.

The overall flow

MCDM is normally applied after the optimization search finishes. The basic flow is:

flowchart TD
    A["1. Exclude infeasible / constraint-violating trials"] --> B["2. Use the Pareto front (non-dominated set) as the candidate set"]
    B --> C["3. Define the criteria and their directions"]
    C --> D["4. Decide the weights (manual / entropy)"]
    D --> E["5. Pick a method and rank"]
    E --> F["6. Compare top candidates visually and make the final choice"]

Which method to choose

Tunny Dashboard provides three ranking methods. When in doubt, start with TOPSIS + equal weights and try the others as needed.

flowchart TD
    r{"What matters most?"}
    r -- "A fast, intuitive overall score" --> rA["TOPSIS<br/>distance to the ideal, [0,1] score"]
    r -- "Both overall balance and worst case" --> rB["VIKOR<br/>tune utility/regret with v"]
    r -- "Detailed pairwise dominance" --> rC{"Number of trials"}
    rC -- "Few (up to ~10k)" --> rC1["PROMETHEE"]
    rC -- "Many (10k+)" --> rC2["watch compute time"]
Method Good for Characteristics
TOPSIS First-pass shortlisting by overall score Picks solutions close to the ideal; intuitive scores
VIKOR Avoiding extreme weaknesses; balanced compromise Separates overall utility from worst-case regret
PROMETHEE Comparing dominance relations in detail Pairwise comparison; heavy with many trials

Recommendations by scenario

Scenario Recommendation
Just getting started TOPSIS + equal weights
Objectives on very different scales TOPSIS / VIKOR + entropy weights
Cap the worst case of one objective VIKOR (smaller v)
Detailed pairwise comparison PROMETHEE

If the same trial stays near the top across multiple methods, it is a relatively stable choice. If the ranking shifts a lot between methods, revisit the criteria, weights, and data.

Deciding the weights

Weights express the relative importance of each objective, and the same candidate set can rank differently under different weights. Weights are not just a parameter—they are the value judgment itself.

Approach When to use Watch out for
Manual (sliders) When the objective to prioritize is clear Subjective—keep the rationale explainable
Equal weights Initial analysis, as a baseline Check whether "all equally important" is valid
Entropy weighting To decide objectively / from data spread Assumes "more spread = more important"

Entropy weighting avoids subjectivity, but an objective whose values are nearly identical across all trials (e.g. a safety metric that almost every solution satisfies) receives a small weight. It can be down-weighted even when it matters for the business.

Rather than committing to one weight vector, it is more effective to compare several scenarios (equal, performance-focused, cost-focused) and check whether the top candidates stay stable. If the #1 changes with a small weight tweak, the conclusion is unstable.

Points for defining criteria

If the criteria (the aspects you compare trials by) are wrong, no method will produce a useful decision.

  • Objectives can be used directly as criteria. You may also add derived metrics such as constraint margin or stability.
  • Always state the direction. Larger-is-better (performance, accuracy) is a benefit criterion; smaller-is-better (cost, time, risk) is a cost criterion. Getting the direction wrong flips the result entirely.
  • Do not make hard constraints into criteria—filter them out first. Conditions like "unusable if it exceeds the limit" belong in a pre-filter. The margin to the limit, however, can be added as a "larger-is-safer" criterion.
  • Avoid overlapping criteria. Including both "processing time" and "processing speed", for example, double-counts performance.

Reading the results

An MCDM ranking is a relative order based on the criteria, weights, and method. It is not the final decision—treat it as material for narrowing down the candidates to examine.

  • Don't take #1 at face value. If the score gap between #1 and #2 is small, treat them as equivalent and compare further.
  • Check ranking stability. Confirm that the same candidates stay on top under small changes to weights or method (sensitivity check).
  • Pair with visualizations. Use Pareto Scatter, Parallel Coordinates, and Radar Comparison to see where the top candidates sit on the front (an extreme solution vs. a balanced one).
  • Re-confirm the constraints. Even a top-ranked trial cannot be adopted if it fails a practical must-have condition.

Checklist before you start

  • Excluded infeasible / constraint-violating trials
  • Set the direction (larger- or smaller-is-better) for every criterion
  • Can explain the rationale for the weights
  • No overlapping criteria with the same meaning
  • Top candidates satisfy the constraints
  • Top candidates stay stable across weight/method changes