aggregators

This module gathers MAVT aggregators.

class ChoquetIntegral(capacity, in_scales=None, out_scale=None)

Bases: Aggregator[QuantitativeScale, QuantitativeScale]

This class represents a Choquet integral aggregator.

Parameters

capacity (ISetFunction) – capacity used for aggregation (either in regular or Möbius representation)
in_scales (Union[QuantitativeScale, Mapping[Any, QuantitativeScale], None]) – input scales (inferred from input if not provided)
out_scale (Union[QuantitativeScale, None]) – output scales (inferred from output if not provided)

Note

Implementation is based on [GKM08].

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool

class NormalizedWeightedSum(criteria_weights, in_scales=None, out_scale=None)

Bases: WeightedSum

This class represents a normalized weighted sum aggregator.

Parameters

criteria_weights (Union[Dict[Any, float], Series]) –
in_scales (Union[QuantitativeScale, Mapping[Any, QuantitativeScale], None]) – input scales (inferred from input if not provided)
out_scale (Union[QuantitativeScale, None]) – output scales (inferred from output if not provided)

Attr weight_function

functions applying weights without aggregation

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool

class OWA(weights, in_scales=None, out_scale=None)

Bases: Aggregator[QuantitativeScale, QuantitativeScale]

This class represents an Ordered Weighted Aggregator (OWA).

Parameters

weights (List[float]) –
in_scales (Union[QuantitativeScale, Mapping[Any, QuantitativeScale], None]) – input scales (inferred from input if not provided)
out_scale (Union[QuantitativeScale, None]) – output scales (inferred from output if not provided)

Note

Implementation is based on [GKM08].

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

classmethod and_aggregator(size)

Return and OWA aggregator of given weights size.

Parameters: size (int) –
Returns
Return type: OWA

Note

\(W_*\) as defined in [Yag88]

property andness: float

Return andness measure of OWA weights.

Returns

Note

andness as defined in [Yag88]

property balance: float

Return OWA weights balance.

Returns

Note

balance as defined in [Yag96]

property dispersion: float

Return OWA weights dispersion (also called entropy).

Returns

Note

dispersion as defined in [Yag88]

property divergence: float

Return OWA weights divergence.

Returns

Note

divergence as defined in [Yag02]

classmethod from_quantifier(quantifier)

Return OWA aggregator corresponding to given quantifier.

Parameters: quantifier (List[float]) –
Returns
Return type: OWA

Note

quantifier as defined in [Yag88]

classmethod or_aggregator(size)

Return or OWA aggregator of given weights size.

Parameters: size (int) –
Returns
Return type: OWA

Note

\(W^*\) as defined in [Yag88]

property orness: float

Return orness measure of OWA weights.

Returns

Note

orness as defined in [Yag88]

property quantifier: List[float]

Return quantifier corresponding to OWA weights.

Returns

Note

quantifier as defined in [Yag88]

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool

class Sum(in_scales=None, out_scale=None, in_stype=None, out_stype=None)

Bases: Aggregator[QuantitativeScale, QuantitativeScale]

This class represents a simple sum aggregator.

Parameters

in_scales (Union[I_S, Mapping[Any, I_S], None]) – input scales (inferred from input if not provided)
out_scale (Union[O_S, None]) – output scales (inferred from output if not provided)
in_stype (Union[Type[I_S], None]) –
out_stype (Union[Type[O_S], None]) –

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool

class TOPSIS(criteria_weights)

Bases: BaseAggregator[QuantitativeScale, QuantitativeScale]

This class implements the TOPSIS algorithm.

(Technique for Order of Preference by Similarity to Ideal Solution).

It gives a score to alternatives based on comparison with ideal positive and negative values.

Parameters: criteria_weights (Union[Dict[Any, float], Series]) – weights applied to each criteria, are normalized internally before applying the algorithm.

Note

Implementation is based on [Cha22].

Example

First you need to create or import ordinal data, and make them quantitative:

>>> from mcda import PerformanceTable
>>> from mcda.scales import (QuantitativeScale, QualitativeScale,
... PreferenceDirection)
>>> data = [
...    [9500, 4.2, "**", "blue", 450],
...    [15600, 4.5, "****", "black", 900],
...    [6800, 4.1, "***", "grey", 700],
...    [10200, 5.6, "****", "black", 850],
...    [8100, 5.2, "***", "red", 750],
...    [12000, 4.9, "****", "grey", 850]
... ]
>>> alternatives = ["Fiat 500", "Peugeot 309", "Renault Clio",
... "Opel Astra", "Honda Civic", "Toyota Corolla"]
>>> criteria = ["cost", "fuel consumption", "comfort", "color",
... "range"]
>>> scale1 = QuantitativeScale(6000, 20000,
... preference_direction=PreferenceDirection.MIN)
>>> scale2 = QuantitativeScale(4, 6,
... preference_direction=PreferenceDirection.MIN)
>>> scale3 = QualitativeScale({"*": 1, "**": 2, "***": 3,
... "****": 4})
>>> scale4 = QualitativeScale({"red": 1, "blue": 2, "black": 3,
... "grey": 4}, preference_direction=PreferenceDirection.MIN)
>>> scale5 = QuantitativeScale(400, 1000)
>>> scales = {
...    criteria[0]: scale1,
...    criteria[1]: scale2,
...    criteria[2]: scale3,
...    criteria[3]: scale4,
...    criteria[4]: scale5
... }
>>> table = PerformanceTable(data, alternatives=alternatives,
... criteria=criteria, scales=scales)
>>> numeric_table = table.to_numeric

Then, you can setup the weights for TOPSIS and score each alternative:

>>> from mcda.mavt.aggregators import TOPSIS
>>> criteria_weights = {"cost": 3, "fuel consumption": 4, "comfort": 2,
... "color": 5, "range": 1}
>>> topsis = TOPSIS(criteria_weights)
>>> result = topsis(numeric_table).sort()
>>> print(result.data)
Honda Civic       0.823318
Fiat 500          0.634897
Opel Astra        0.413274
Renault Clio      0.362293
Peugeot 309       0.357782
Toyota Corolla    0.249553
dtype: float64

New in version 1.1.0.

__call__(data, *args, **kwargs)

Apply TOPSIS aggregation method to input data.

Parameters: data (IValueMatrix[QuantitativeScale]) –
Returns: aggregation result
Return type: CommensurableValues[QuantitativeScale]

classmethod negative_ideal_solution(matrix)

Compute ideal negative solution.

This fictive alternative corresponds to the worst criterion value for every criterion.

Parameters: matrix (IValueMatrix[I_OS]) –
Returns: ideal negative solution as an alternative value
Return type: Values[I_OS]

classmethod normalize(matrix)

Normalize performance table values.

Norm used is the euclidean norm applied on each criterion values.

Parameters: matrix (IValueMatrix[QuantitativeScale]) –
Returns: normalized table
Return type: PerformanceTable[QuantitativeScale]

Note

input scales preference direction are preserved

property normalized_weights: Dict[Any, float]: Normalized criteria weights

classmethod positive_ideal_solution(matrix)

Compute ideal positive solution.

This fictive alternative corresponds to the best criterion value for every criterion.

Parameters: matrix (IValueMatrix[I_OS]) –
Returns: ideal positive solution as an alternative value
Return type: Values[I_OS]

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (IValueMatrix[I_S]) –
Returns: True if data is within in_scales
Return type: bool

class ULOWA(weights, scale)

Bases: Aggregator[FuzzyScale, FuzzyScale]

This class represents an Unbalanced Linguistic Weighted Average (ULOWA) aggregator.

Parameters

weights (List[float]) –
scale (FuzzyScale) – fuzzy scale used for the average

Note

implementation based on [IMVM10]

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

delta(a, b, weight)

Returns ULOWA delta value.

Parameters

a (Any) – worst value
b (Any) – best value
weight (float) – ULOWA weight

Returns

Return type

float

most_similar(a, b, ref_fuzzy)

Returns label which fuzzy number is the most similar to the reference (between a and b labels).

Parameters

a (Any) –
b (Any) –
ref_fuzzy (FuzzyNumber) – fuzzy number that is being compared to

Returns

Return type

Any

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool

class WeightedSum(criteria_weights, in_scales=None, out_scale=None)

Bases: Sum

This class represents a weighted sum aggregator.

Parameters

criteria_weights (Union[Dict[Any, float], Series]) –
in_scales (Union[QuantitativeScale, Mapping[Any, QuantitativeScale], None]) – input scales (inferred from input if not provided)
out_scale (Union[QuantitativeScale, None]) – output scales (inferred from output if not provided)

Attr weight_function

functions applying weights without aggregation

__call__(data, *args, **kwargs)

Apply aggregation method to input data.

Parameters: data (Union[PartialValueMatrix[I_S], IValueMatrix[I_S], DataFrame, Series, Values[I_S]]) –
Returns: aggregation result
Return type: Union[Any, Series, CommensurableValues[O_S], AdjacencyValueMatrix[O_S]]

Note

aggregation is applied for each row in case of tabular data

within_in_scales(data)

Check potential input is inside input scales.

Parameters: data (Union[Series, Values[I_S], DataFrame, IValueMatrix[I_S], PartialValueMatrix[I_S]]) –
Returns: True if data is within in_scales
Return type: bool