docs/source/tutorial/extend.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Extending Aggregation and Transformation Functions\n",
    "\n",
    "This tutorial serves as a guide for utilizing the extension tools for aggregation and transformer functions in Scikit-Criteria. After going through this tutorial, you will be able to implement your own multi-criteria decision models compatible with the data types and tools provided by the library.\n",
    "\n",
    "## 1. Introduction\n",
    "\n",
    "In Scikit-Criteria, leveraging the provided decorators (`@extend.mkagg` and `@extend.mktransformer`) for extending aggregation and transformation functions provides a powerful means to customize decision-making models allowing the creation of custom functions, enabling domain-specific logic implementation for diverse use cases. \n",
    "\n",
    "Decorators simplify the process of converting functions into model classes, promoting flexibility in model creation without complex class hierarchies. This facilitates quick prototyping and experimentation by allowing direct modification of functions. Additionally, the decorators handle hyperparameter initialization, encapsulating them within models, promoting clean, organized code and reducing the chances of errors related to parameter handling.\n",
    "\n",
    "\n",
    "Example Usage:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the decorators from the module\n",
    "from skcriteria.extend import mkagg, mktransformer\n",
    "\n",
    "# Define custom aggregation and transformation functions\n",
    "@mkagg\n",
    "def CustomAggregation(**kwargs):\n",
    "    # Implement aggregation logic\n",
    "    pass\n",
    "\n",
    "@mktransformer\n",
    "def CustomTransformation(**kwargs):\n",
    "    # Implement transformation logic\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this code is syntactically valid, attempting to use it may not work as intended since it doesn't return the required values.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. A New Aggregation Model\n",
    "\n",
    "To create a custom aggregation model, follow these steps:\n",
    "\n",
    "1. Declare a function with the name of your model using the [CapWords/UpperCamelCase/PascalCase](https://en.wikipedia.org/wiki/Camel_case) convention. While this is not mandatory, not adhering to this convention will trigger a warning message from scikit-criteria, notifying that the model name does not follow the Scikit-Criteria standard.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/juanbc/proyectos/skcriteria/src/skcriteria/extend.py:211: NonStandardNameWarning: Models names should normally use the 'CapWords' convention.try change 'bad_model_name' to 'Bad_Model_Name' or 'BAD_MODEL_NAME'\n",
      "  return _agg_maker if maybe_func is None else _agg_maker(maybe_func)\n"
     ]
    }
   ],
   "source": [
    "@mkagg\n",
    "def bad_model_name(**kwargs):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@mkagg\n",
    "def GodModelName(**kwargs):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. The function should take parameters representing the decomposed decision matrix after calling the `DecisionMatrix.to_dict()` method, and a parameter `hparams`, which will be explained later and contains the hyper-parameters of the model.\n",
    "\n",
    "\n",
    "- `hparams`: Model Hyperparameters.\n",
    "- `matrix`: Alternatives matrix as numpy array.\n",
    "- `objectives`: numpy array of objectives for criteria as integers: $maximize = 1$ and $minimize = -1$.\n",
    "- `weights`: Weights of the criteria as numpy array.\n",
    "- `dtypes`: Data types of the criteria as numpy array.\n",
    "- `alternatives`: Names of the alternatives as numpy array.\n",
    "- `criteria`: Names of the criteria as numpy array.\n",
    "\n",
    "Additionally, if you do not want to use any of those parameters of the matrix, you can declare the function with [Variable Keyword Arguments (**kwargs)](https://www.w3schools.com/python/gloss_python_function_arbitrary_keyword_arguments.asp).\n",
    "\n",
    "If any parameter is forgotten and `**kwargs` is not present, a [TypeError](https://docs.python.org/3/library/exceptions.html#TypeError) is raised.\n",
    "\n",
    "So this next two functions are a valid Aggregation functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "@mkagg\n",
    "def AllParameters(hparams, matrix, objectives, weights, dtypes, alternatives, criteria):\n",
    "    pass\n",
    "\n",
    "@mkagg\n",
    "def OnlyTwoWithKwargs(matrix, weights, **kwargs):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Utilizing the received parameters, the function should return two objects:\n",
    "\n",
    "    1. A `numpy.array`/`list`/`tuple` or any kind of sequence containing a valid ranking.\n",
    "       Where the `i`-th position in the returned sequence has the ranking value for\n",
    "       the `i`-th alternative in the array of alternatives received as a parameter.\n",
    "    2. A `dict` with extra values from the ranking (intermediate results or other useful data for decision-making analysis)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "**Note:** Understanding the Rankings\n",
    "\n",
    "A valid ranking has the following conditions:\n",
    "\n",
    "1. **Length:** It should have the same length as the number of alternatives received by the function.\n",
    "2. **Ascending and Consecutive Order:** The values must be in ascending order and consecutive. This means that values should start from 1 and increase by increments of 1 without skips  For example, `[1, 2, 3, 4]`  and `[1, 2, 1]` is valid, but `[4, 2, 4, 1]` is not valid because the value 3 is missing.\n",
    "3. **Integers Only:** Values must be integers. Fractional or other types of values are not allowed.\n",
    "\n",
    "---\n",
    "\n",
    "So if we have the alternatives `[\"banana\", \"apple\", \"orange\"]` and the ranking `[1, 2, 1]`\n",
    "\n",
    "The meaning of the ranking in relation to the alternatives is as follows:\n",
    "\n",
    "1. The first position in the ranking is 1, indicating that the alternative in the first position is the most preferred or the best choice.\n",
    "2. The second position in the ranking is 2, suggesting that the alternative in the second position is the second-best choice.\n",
    "3. The third position in the ranking is also 1, implying that the alternative in the third position is equally preferred to the alternative in the first position.\n",
    "\n",
    "Therefore, the ranking `[1, 2, 1]` could be interpreted as stating that \"Banana\" and \"Orange\" are equally preferred, and \"Apple\" is the second preferred choice. It's important to note that the ranking must adhere to the specific conditions mentioned in the definitions, such as the correct length, ascending and consecutive order, and integer values.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all of this, a complete and valid aggregation function would be:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "@mkagg\n",
    "def AllAlternativesAreFirst(alternatives, **kwargs):\n",
    "    # Assign a rank of 1 to each alternative\n",
    "    rank = [1] * len(alternatives)\n",
    "    \n",
    "    # Define extra information (example: some important value)\n",
    "    extra = {\"some_important_value\": \"the_important_value\"}\n",
    "    \n",
    "    # Return the rank and extra information\n",
    "    return rank, extra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test the new aggregation with a dataset.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ROE[▲ 2.0]</th>\n",
       "      <th>CAP[▲ 4.0]</th>\n",
       "      <th>RI[▼ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>PE</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JN</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AA</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FX</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MM</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GN</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    ROE[▲ 2.0]  CAP[▲ 4.0]  RI[▼ 1.0]\n",
       "PE           7           5         35\n",
       "JN           5           4         26\n",
       "AA           5           6         28\n",
       "FX           3           4         36\n",
       "MM           1           7         30\n",
       "GN           5           8         30\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import skcriteria as skc\n",
    "dm = skc.datasets.load_simple_stock_selection() # load the dataset\n",
    "dm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AllAlternativesAreFirst []>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Instantiate the new aggregation\n",
    "agg = AllAlternativesAreFirst()\n",
    "agg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='skcresult-rank skcresult'>\n",
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_48893\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >Alternatives</th>\n",
       "      <th id=\"T_48893_level0_col0\" class=\"col_heading level0 col0\" >PE</th>\n",
       "      <th id=\"T_48893_level0_col1\" class=\"col_heading level0 col1\" >JN</th>\n",
       "      <th id=\"T_48893_level0_col2\" class=\"col_heading level0 col2\" >AA</th>\n",
       "      <th id=\"T_48893_level0_col3\" class=\"col_heading level0 col3\" >FX</th>\n",
       "      <th id=\"T_48893_level0_col4\" class=\"col_heading level0 col4\" >MM</th>\n",
       "      <th id=\"T_48893_level0_col5\" class=\"col_heading level0 col5\" >GN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_48893_level0_row0\" class=\"row_heading level0 row0\" >Rank</th>\n",
       "      <td id=\"T_48893_row0_col0\" class=\"data row0 col0\" >1</td>\n",
       "      <td id=\"T_48893_row0_col1\" class=\"data row0 col1\" >1</td>\n",
       "      <td id=\"T_48893_row0_col2\" class=\"data row0 col2\" >1</td>\n",
       "      <td id=\"T_48893_row0_col3\" class=\"data row0 col3\" >1</td>\n",
       "      <td id=\"T_48893_row0_col4\" class=\"data row0 col4\" >1</td>\n",
       "      <td id=\"T_48893_row0_col5\" class=\"data row0 col5\" >1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<em class='skcresult-method'>Method: AllAlternativesAreFirst</em>\n",
       "</div>"
      ],
      "text/plain": [
       "Alternatives  PE  JN  AA  FX  MM  GN\n",
       "Rank           1   1   1   1   1   1\n",
       "[Method: AllAlternativesAreFirst]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate\n",
    "rank = agg.evaluate(dm)\n",
    "rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the_important_value'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank.e_.some_important_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Hyperparameters \n",
    "\n",
    "The [Hyper-parameters](https://en.wikipedia.org/wiki/Hyperparameter_(machine_learning)) (in the context of machine learning) are parameters that allow you to specify details on how the function will carry out its aggregation. In this sense, they are more similar to [Free-Parameters](https://en.wikipedia.org/wiki/Free_parameter) as they cannot be predicted or constrained by the model.\n",
    "\n",
    "In Scikit-Criteria, we define the concept of Hyper-parameters similar to the Hyper-parameters in Scikit-Learn: Parameters received by the model's (Aggregation function class) constructor and **always** should have some default value.\n",
    "\n",
    "For example, in the case of Scikit-Criteria's implementation of [TOPSIS](https://en.wikipedia.org/wiki/TOPSIS), it has a hyper-parameter for the metric it will use, and by default, it is set to `\"euclidean\"`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TOPSIS [metric='euclidean']>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from skcriteria.agg import similarity\n",
    "similarity.TOPSIS()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TOPSIS [metric='cityblock']>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similarity.TOPSIS(metric=\"cityblock\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The hyper-parameters can be provided as named parameters to the `@mkagg` decorator, and their values can be accessed using the `hparams` parameter.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "**Note:** Regarding the nature of <code>hparams</code>\n",
    "\n",
    "If you are familiar with how methods work in Python classes, `hparams` is essentially the `self` of the model.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, for example, if we want to create a model named `MaybeWSM`, which is a [weighted-sum-model](https://en.wikipedia.org/wiki/Weighted_sum_model) that uses weights only when the `use_weight` hyperparameter is set to `True`, and the default value is indeed `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from skcriteria.utils import rank\n",
    "\n",
    "@mkagg(use_weights=True)\n",
    "def MaybeWSM(hparams, matrix, objectives, weights, **kwargs):\n",
    "    \"\"\"The Maybe-Weighted Sum Model (WSM) to rank alternatives.\n",
    "\n",
    "    If the use_weights parameter in hparams is set to True, the \n",
    "    function applies weights to the decision matrix. This is done \n",
    "    by taking the inner product of the matrix and the weights vector.\n",
    "    \n",
    "    \"\"\"\n",
    "    # Check if objectives contain -1 (minimize objectives)\n",
    "    if -1 in objectives:\n",
    "        raise ValueError(\"'MaybeWSM' cant operate with minimize objectives\")\n",
    "\n",
    "    # If use_weights is True, apply weights to the matrix\n",
    "    if hparams.use_weights:\n",
    "        matrix = matrix * weights\n",
    "\n",
    "    # Calculate the scores by row/alternative\n",
    "    score = np.sum(matrix, axis=1)\n",
    "\n",
    "    # rank_values calculates the ranking based on the scores. \n",
    "    # `reverse = True` indicates that higher scores are closer to the 1st place.\n",
    "    # Additionally, we will return the calculated 'score' as extra information.\n",
    "    return rank.rank_values(score, reverse=True), {\"score\": score}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use our MaybeWSM model.\n",
    "\n",
    "First, let's see what happens if we create a `MaybeWSM` with the default (`use_weights=True`) and try to evaluate the available decision matrix (`dm`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MaybeWSM [use_weights=True]>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with_useweight = MaybeWSM()\n",
    "with_useweight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we use `dm` as it is right now, we will get an exception:  `'MaybeWSM' can't operate with minimize objectives` because, indeed, `dm` has some criteria to minimize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ROE    False\n",
       "CAP    False\n",
       "RI      True\n",
       "Name: minwhere, dtype: bool"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dm.minwhere  # the critetia to minimize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this reason, first, we will use the `InvertMinimize` transformer to eliminate criteria to minimize.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ROE    False\n",
       "CAP    False\n",
       "RI     False\n",
       "Name: minwhere, dtype: bool"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from skcriteria.preprocessing import invert_objectives\n",
    "\n",
    "dm = invert_objectives.InvertMinimize().transform(dm)\n",
    "dm.minwhere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='skcresult-rank skcresult'>\n",
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_ddb8b\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >Alternatives</th>\n",
       "      <th id=\"T_ddb8b_level0_col0\" class=\"col_heading level0 col0\" >PE</th>\n",
       "      <th id=\"T_ddb8b_level0_col1\" class=\"col_heading level0 col1\" >JN</th>\n",
       "      <th id=\"T_ddb8b_level0_col2\" class=\"col_heading level0 col2\" >AA</th>\n",
       "      <th id=\"T_ddb8b_level0_col3\" class=\"col_heading level0 col3\" >FX</th>\n",
       "      <th id=\"T_ddb8b_level0_col4\" class=\"col_heading level0 col4\" >MM</th>\n",
       "      <th id=\"T_ddb8b_level0_col5\" class=\"col_heading level0 col5\" >GN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_ddb8b_level0_row0\" class=\"row_heading level0 row0\" >Rank</th>\n",
       "      <td id=\"T_ddb8b_row0_col0\" class=\"data row0 col0\" >3</td>\n",
       "      <td id=\"T_ddb8b_row0_col1\" class=\"data row0 col1\" >5</td>\n",
       "      <td id=\"T_ddb8b_row0_col2\" class=\"data row0 col2\" >2</td>\n",
       "      <td id=\"T_ddb8b_row0_col3\" class=\"data row0 col3\" >6</td>\n",
       "      <td id=\"T_ddb8b_row0_col4\" class=\"data row0 col4\" >4</td>\n",
       "      <td id=\"T_ddb8b_row0_col5\" class=\"data row0 col5\" >1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<em class='skcresult-method'>Method: MaybeWSM</em>\n",
       "</div>"
      ],
      "text/plain": [
       "Alternatives  PE  JN  AA  FX  MM  GN\n",
       "Rank           3   5   2   6   4   1\n",
       "[Method: MaybeWSM]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_with_uw = with_useweight.evaluate(dm)\n",
    "rank_with_uw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's try `use_weights=False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<MaybeWSM [use_weights=False]>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "without_useweight = MaybeWSM(use_weights=False)\n",
    "without_useweight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='skcresult-rank skcresult'>\n",
       "<style type=\"text/css\">\n",
       "</style>\n",
       "<table id=\"T_ed8cf\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >Alternatives</th>\n",
       "      <th id=\"T_ed8cf_level0_col0\" class=\"col_heading level0 col0\" >PE</th>\n",
       "      <th id=\"T_ed8cf_level0_col1\" class=\"col_heading level0 col1\" >JN</th>\n",
       "      <th id=\"T_ed8cf_level0_col2\" class=\"col_heading level0 col2\" >AA</th>\n",
       "      <th id=\"T_ed8cf_level0_col3\" class=\"col_heading level0 col3\" >FX</th>\n",
       "      <th id=\"T_ed8cf_level0_col4\" class=\"col_heading level0 col4\" >MM</th>\n",
       "      <th id=\"T_ed8cf_level0_col5\" class=\"col_heading level0 col5\" >GN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_ed8cf_level0_row0\" class=\"row_heading level0 row0\" >Rank</th>\n",
       "      <td id=\"T_ed8cf_row0_col0\" class=\"data row0 col0\" >2</td>\n",
       "      <td id=\"T_ed8cf_row0_col1\" class=\"data row0 col1\" >4</td>\n",
       "      <td id=\"T_ed8cf_row0_col2\" class=\"data row0 col2\" >3</td>\n",
       "      <td id=\"T_ed8cf_row0_col3\" class=\"data row0 col3\" >6</td>\n",
       "      <td id=\"T_ed8cf_row0_col4\" class=\"data row0 col4\" >5</td>\n",
       "      <td id=\"T_ed8cf_row0_col5\" class=\"data row0 col5\" >1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<em class='skcresult-method'>Method: MaybeWSM</em>\n",
       "</div>"
      ],
      "text/plain": [
       "Alternatives  PE  JN  AA  FX  MM  GN\n",
       "Rank           2   4   3   6   5   1\n",
       "[Method: MaybeWSM]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_without_uw = without_useweight.evaluate(dm)\n",
    "rank_without_uw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be seen that depending on the configuration of the hyperparameter `use_weights`, the results are different.\n",
    "\n",
    "In addition to this, the `score` is available within `extra_`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([34.02857143, 26.03846154, 34.03571429, 22.02777778, 30.03333333,\n",
       "        42.03333333]),\n",
       " array([12.02857143,  9.03846154, 11.03571429,  7.02777778,  8.03333333,\n",
       "        13.03333333]))"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank_with_uw.e_.score, rank_without_uw.e_.score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. A New Transformer\n",
    "\n",
    "The only difference between creating a new aggregator and a transformer lies in the type of data returned by the decorated function. Everything else is exactly the same (received parameters, function names, and functionality of hyperparameters).\n",
    "\n",
    "The decorated function must return a dictionary that can have the same keys as the parameters received by the function except for `hparam`: `matrix`, `objectives`, `weights`, `dtypes`, `alternatives`, or `criteria`; and whose values must be the new values with which to replace the original ones in the transformation matrix.\n",
    "\n",
    "It is not necessary to return all values; only the ones that you want to change.\n",
    "\n",
    "\n",
    "For example, if we want to create a transformer `StrFormat` that converts the text of the names of each criterion and alternative using the methods of `str`, and by default, it converts texts to lowercase.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<StrFormat [operation=<method 'lower' of 'str' objects>]>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@mktransformer(operation=str.lower)\n",
    "def StrFormat(alternatives, criteria, hparams, **kwargs):\n",
    "    \"\"\"Applies a string formatting operation (lowercasing by default) to alternatives and criteria.\"\"\"\n",
    "    # Apply the string formatting operation to each alternative\n",
    "    new_alternatives = [hparams.operation(a) for a in alternatives]\n",
    "\n",
    "    # Apply the string formatting operation to each criterion\n",
    "    new_criteria = [hparams.operation(c) for c in criteria]\n",
    "\n",
    "    # Return the transformed alternatives and criteria in a dictionary\n",
    "    return {\"alternatives\": new_alternatives, \"criteria\": new_criteria}\n",
    "    \n",
    "trans = StrFormat()\n",
    "trans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>roe[▲ 2.0]</th>\n",
       "      <th>cap[▲ 4.0]</th>\n",
       "      <th>ri[▲ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>pe</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>0.028571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>jn</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0.038462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>aa</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0.035714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fx</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>0.027778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mm</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gn</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    roe[▲ 2.0]  cap[▲ 4.0]  ri[▲ 1.0]\n",
       "pe           7           5   0.028571\n",
       "jn           5           4   0.038462\n",
       "aa           5           6   0.035714\n",
       "fx           3           4   0.027778\n",
       "mm           1           7   0.033333\n",
       "gn           5           8   0.033333\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trans.transform(dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use any function provided by `str`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<StrFormat [operation=<method 'capitalize' of 'str' objects>]>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trans = StrFormat(operation=str.capitalize)\n",
    "trans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Roe[▲ 2.0]</th>\n",
       "      <th>Cap[▲ 4.0]</th>\n",
       "      <th>Ri[▲ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Pe</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>0.028571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jn</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0.038462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Aa</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0.035714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Fx</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>0.027778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Mm</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gn</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    Roe[▲ 2.0]  Cap[▲ 4.0]  Ri[▲ 1.0]\n",
       "Pe           7           5   0.028571\n",
       "Jn           5           4   0.038462\n",
       "Aa           5           6   0.035714\n",
       "Fx           3           4   0.027778\n",
       "Mm           1           7   0.033333\n",
       "Gn           5           8   0.033333\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trans.transform(dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, given our implementation, any arbitrary function that converts text can be used. For example, if we want to create our own function that adds exclamation marks to the end of each criterion and alternative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<StrFormat [operation=<function add_exclamation at 0x79a56af36f80>]>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_exclamation(text):\n",
    "    return text + \" !! \"\n",
    "\n",
    "trans = StrFormat(operation=add_exclamation)\n",
    "trans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ROE !! [▲ 2.0]</th>\n",
       "      <th>CAP !! [▲ 4.0]</th>\n",
       "      <th>RI !! [▲ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>PE !!</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>0.028571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JN !!</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>0.038462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AA !!</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>0.035714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FX !!</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>0.027778</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MM !!</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GN !!</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>0.033333</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "        ROE !! [▲ 2.0]  CAP !! [▲ 4.0]  RI !! [▲ 1.0]\n",
       "PE !!                7               5       0.028571\n",
       "JN !!                5               4       0.038462\n",
       "AA !!                5               6       0.035714\n",
       "FX !!                3               4       0.027778\n",
       "MM !!                1               7       0.033333\n",
       "GN !!                5               8       0.033333\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trans.transform(dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Special considerations regarding `dtypes`\n",
    "\n",
    "\n",
    "By design decision, scikitcriteria always attempts to **always** preserve the original data types, unless it needs to infer them again.\n",
    "\n",
    "This may not seem important to a user at first glance, so let's use an example of a transformer affected by this characteristic.\n",
    "\n",
    "First, let's reload the original decision matrix, where the values of all criteria are `int`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ROE[▲ 2.0]</th>\n",
       "      <th>CAP[▲ 4.0]</th>\n",
       "      <th>RI[▼ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>PE</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JN</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AA</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FX</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MM</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GN</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    ROE[▲ 2.0]  CAP[▲ 4.0]  RI[▼ 1.0]\n",
       "PE           7           5         35\n",
       "JN           5           4         26\n",
       "AA           5           6         28\n",
       "FX           3           4         36\n",
       "MM           1           7         30\n",
       "GN           5           8         30\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dm = skc.datasets.load_simple_stock_selection()\n",
    "dm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's create a transformer that converts all criteria to the `float` type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AsFloat []>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@mktransformer\n",
    "def AsFloat(matrix, **kwargs):\n",
    "    \"\"\"Converts the elements of a decision-matrix to floating-point numbers.\"\"\"\n",
    "    # Convert the elements of the matrix to floating-point numbers\n",
    "    new_matrix = matrix.astype(float)\n",
    "    \n",
    "    # Return the transformed matrix in a dictionary\n",
    "    return {\"matrix\": new_matrix}\n",
    "\n",
    "trans = AsFloat()\n",
    "trans\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's test its functionality.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ROE[▲ 2.0]</th>\n",
       "      <th>CAP[▲ 4.0]</th>\n",
       "      <th>RI[▼ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>PE</th>\n",
       "      <td>7</td>\n",
       "      <td>5</td>\n",
       "      <td>35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JN</th>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>26</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AA</th>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FX</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MM</th>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GN</th>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    ROE[▲ 2.0]  CAP[▲ 4.0]  RI[▼ 1.0]\n",
       "PE           7           5         35\n",
       "JN           5           4         26\n",
       "AA           5           6         28\n",
       "FX           3           4         36\n",
       "MM           1           7         30\n",
       "GN           5           8         30\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trans.transform(dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, the numbers are still integers. This is because the `dtypes` parameter of the matrix indicates that those columns are indeed integers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ROE    int64\n",
       "CAP    int64\n",
       "RI     int64\n",
       "dtype: object"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dm.dtypes  # check the dtypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest solution would be to ensure that the dtypes are inferred again based on the values of the new matrix. This is achieved by assigning the dtype values to None.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div class='decisionmatrix'>\n",
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ROE[▲ 2.0]</th>\n",
       "      <th>CAP[▲ 4.0]</th>\n",
       "      <th>RI[▼ 1.0]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>PE</th>\n",
       "      <td>7.0</td>\n",
       "      <td>5.0</td>\n",
       "      <td>35.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JN</th>\n",
       "      <td>5.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>26.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AA</th>\n",
       "      <td>5.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>28.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>FX</th>\n",
       "      <td>3.0</td>\n",
       "      <td>4.0</td>\n",
       "      <td>36.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>MM</th>\n",
       "      <td>1.0</td>\n",
       "      <td>7.0</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>GN</th>\n",
       "      <td>5.0</td>\n",
       "      <td>8.0</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div><em class='decisionmatrix-dim'>6 Alternatives x 3 Criteria</em>\n",
       "</div>"
      ],
      "text/plain": [
       "    ROE[▲ 2.0]  CAP[▲ 4.0]  RI[▼ 1.0]\n",
       "PE         7.0         5.0       35.0\n",
       "JN         5.0         4.0       26.0\n",
       "AA         5.0         6.0       28.0\n",
       "FX         3.0         4.0       36.0\n",
       "MM         1.0         7.0       30.0\n",
       "GN         5.0         8.0       30.0\n",
       "[6 Alternatives x 3 Criteria]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@mktransformer\n",
    "def AsFloat(matrix, **kwargs):\n",
    "    \"\"\"Converts the elements of a decision-matrix to floating-point numbers.\"\"\"\n",
    "    # Convert the elements of the matrix to floating-point numbers\n",
    "    new_matrix = matrix.astype(float)\n",
    "    \n",
    "    # Return the transformed matrix in a dictionary\n",
    "    # and assign the dtypes as None\n",
    "    return {\"matrix\": new_matrix, \"dtypes\": None}\n",
    "\n",
    "trans = AsFloat()\n",
    "trans.transform(dm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this may seem somewhat inconvenient, it gives the user complete control over the data types of the matrix without assuming default behaviors that may be undesirable.\n",
    "\n",
    "It's essential to consider that the original `dtypes` are also received by the transformer (in our case, they are inside `**kwargs`) and can be used to determine the new types."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}