Multi-Criteria Decision-Making using Python

Introduction to Decision-Making

Decision Making

• Should you make a purchase or not?

• Should you pursue a master's degree or enter the workforce after completing your bachelor's?

• Should you accept a job offer or decline it?

1. Identify alternatives: Accept or decline the offer.

2. Gather information: Consider salary, benefits, job responsibilities, company culture, etc.

3. Evaluate options: Weigh the pros and cons of accepting versus declining.

4. Consider consequences: Think about how each choice impacts your career and life.

5. Make a choice: Select the option that aligns best with your goals and values.

Multi-Criteria Decision-Making

Multi-Criteria Decision-Making Implementation using Python

Different MCDM Algorithms

Decision-making algorithms are systematic methods designed to assist individuals or systems in choosing among alternatives. They aim to:

 

These algorithms can be either quantitative or qualitative, drawing on disciplines such as mathematics, statistics, economics, and computer science. They vary from simple rule-based approaches to sophisticated machine learning models.

Key features of many decision-making algorithms include:

• Processing large amounts of data

• Considering multiple, often conflicting, criteria

• Incorporating stakeholder preferences

• Managing uncertainty and probabilistic outcomes

• Scaling to handle different problem sizes and complexities

The choice of algorithm depends on the problem’s nature, the available data, computational resources, and the desired balance between simplicity and accuracy. While these algorithms provide valuable insights and recommendations, they typically serve as tools to support human decision-makers, rather than replacing human judgment altogether.

Here's a brief overview of some common decision-making algorithms:

Algorithm	Overview
Decision Trees	• Graphical representation of decisions and their outcomes • Useful for sequential decision-making processes
Analytic Hierarchy Process (AHP)	• Breaks down complex decisions into hierarchies • Uses pairwise comparisons to establish priorities
TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)	Chooses alternatives closest to ideal solution and farthest from the negative-ideal solution
PROMETHEE (Preference Ranking Organization Method for Enrichment Evaluations)	• Outranking method using pairwise comparisons of alternatives • Considers preference functions for each criterion
ELECTRE (Elimination and Choice Expressing Reality)	• Family of outranking methods • Uses concordance and discordance indices

Each algorithm has its strengths and is suited to different types of decision problems. The choice of algorithm depends on the specific context, data availability, and complexity of the decision at hand.

MCDM Implementation Using Python

import pandas as pd
import skcriteria as skc
from skcriteria.pipeline import mkpipe
from skcriteria.preprocessing.invert_objectives import InvertMinimize, NegateMinimize
from skcriteria.preprocessing.scalers import SumScaler, VectorScaler
from skcriteria.agg.simple import WeightedProductModel, WeightedSumModel
from skcriteria.agg.similarity import TOPSIS

data = {
    "Phone": ["Samsung Galaxy S24", "Google Pixel 9", "Xiaomi 14", "Apple iPhone 15"],
    "Price (EUR)": [611, 830, 700, 700],
    "Weight (Gram)": [168, 198, 193, 171],
    "Battery Life (Hour)": [12, 13, 12, 13.5],
    "Storage (GB)": [128, 128, 512, 128],
    "RAM (GB)": [8, 12, 12, 6],
}
df_phones = pd.DataFrame(data).set_index("Phone")
df_phones

dm = skc.mkdm(
    df_phones,
    alternatives=df_phones.index,
    criteria=df_phones.columns,
    objectives=["min", "min", "max", "max", "max"],
    weights=[5, 3, 3, 2,1],
)
dm

ws_pipe = mkpipe(
    InvertMinimize(),
    SumScaler(target="both"),
    WeightedSumModel(),
)
df_ws_ranks = ws_pipe.evaluate(dm).to_series().to_frame("Rank").sort_values("Rank")
df_ws_ranks

Disclaimer: I am not affiliated with any of the brands mentioned above. Prices and phone specifications were quickly sourced from the internet for demonstration purposes only!

Ranking Using Various Algorithms

1. Weighted Product Model (WPM): Another relatively simple model that uses multiplication instead of addition.

2. Technique for Order of Preference by Similarity to Ideal Solution (TOPSIS): A popular model that considers the distance from both ideal and negative-ideal solutions.

• For WSM and WPM, we can continue using the SumScaler for normalization.

• TOPSIS, being based on distance calculations, requires the use of VectorScaler instead of SumScaler.

• Apart from this change in scaler, the implementation process remains similar across all three models.

ws_pipe = mkpipe(
    InvertMinimize(),
    SumScaler(target="both"),
    WeightedSumModel(),
)
wp_pipe = mkpipe(
    InvertMinimize(),
    SumScaler(target="both"),
    WeightedProductModel(),
)
tp_pipe = mkpipe(
    NegateMinimize(),
    SumScaler(target="weights"),
    VectorScaler(target="matrix"),
    TOPSIS(),
)
df_ws_ranks = ws_pipe.evaluate(dm).to_series().to_frame("Weigthet Sum Rank")
df_wp_ranks = wp_pipe.evaluate(dm).to_series().to_frame("Weighted Product Rank")
df_tp_ranks = tp_pipe.evaluate(dm).to_series().to_frame("TOPSIS Rank")

df_final = pd.concat([df_ws_ranks, df_wp_ranks, df_tp_ranks], axis=1)
df_final = df_final.merge(df_phones, left_index=True, right_index=True)
df_final = df_final.sort_values("Weigthet Sum Rank")
df_final

Conclusion

1. List all alternatives (options).

2. Gather as much information as possible for each.

3. Use ranking algorithms to guide your decision-making.

Do not value anything more than it deserves. Either you will lose it or you will ruin yourself. Rumi