Repository: mmschlk/iXAI (language: python)

Issue:
Development
fixed bug in sklearn wrapper - wrapper runs for predict and predict_proba


Discussion / hints:

Fix patch:
diff --git a/examples/agrawal_accuracy_loss.py b/examples/agrawal_accuracy_loss.py
index d51ae6f..ae31e76 100644
--- a/examples/agrawal_accuracy_loss.py
+++ b/examples/agrawal_accuracy_loss.py
@@ -8,7 +8,7 @@
 from ixai.explainer.sage import IncrementalSage, IntervalSage
 from ixai.imputer import MarginalImputer
 from ixai.storage import GeometricReservoirStorage
-from ixai.utils.wrappers.river import RiverPredictionFunctionWrapper
+from ixai.utils.wrappers.river import RiverWrapper
 
 N_SAMPLES = 10_000
 
@@ -22,7 +22,7 @@
     training_metric = Rolling(river.metrics.Accuracy(), window_size=1000)
 
     model = AdaptiveRandomForestClassifier(n_models=15, max_depth=10, leaf_prediction='mc')
-    model_function = RiverPredictionFunctionWrapper(model.predict_one)
+    model_function = RiverWrapper(model.predict_one)
 
     # Get imputer and explainers ---------------------------------------------------------------------------------------
     storage = GeometricReservoirStorage(
diff --git a/examples/agrawal_cross_entropy_loss.py b/examples/agrawal_cross_entropy_loss.py
index e4a1cdc..eaebcfd 100644
--- a/examples/agrawal_cross_entropy_loss.py
+++ b/examples/agrawal_cross_entropy_loss.py
@@ -8,7 +8,7 @@
 from ixai.explainer.sage import IncrementalSage, IntervalSage
 from ixai.imputer import MarginalImputer
 from ixai.storage import GeometricReservoirStorage
-from ixai.utils.wrappers.river import RiverPredictionFunctionWrapper
+from ixai.utils.wrappers.river import RiverWrapper
 
 N_SAMPLES = 10_000
 
@@ -22,7 +22,7 @@
     training_metric = Rolling(river.metrics.CrossEntropy(), window_size=1000)
 
     model = AdaptiveRandomForestClassifier(n_models=15, max_depth=10, leaf_prediction='mc')
-    model_function = RiverPredictionFunctionWrapper(model.predict_proba_one)
+    model_function = RiverWrapper(model.predict_proba_one)
 
     # Get imputer and explainers ---------------------------------------------------------------------------------------
     storage = GeometricReservoirStorage(
diff --git a/examples/basic_usage.ipynb b/examples/basic_usage.ipynb
index a94d198..1edb2c3 100644
--- a/examples/basic_usage.ipynb
+++ b/examples/basic_usage.ipynb
@@ -4,7 +4,9 @@
    "cell_type": "markdown",
    "source": [
     "# Basic Usage\n",
-    "This notebook illustrates the basic usage to create incremental explanations with our incremental explainers."
+    "---\n",
+    "This notebook illustrates the basic usage to create incremental explanations with our incremental explainers.\n",
+    "For further or more specific information, we refer to the other notebooks, the documentation, and this article."
    ],
    "metadata": {
     "collapsed": false,
@@ -16,8 +18,8 @@
   {
    "cell_type": "markdown",
    "source": [
-    "### Import Modules\n",
-    "Imports all necessary modules at once."
+    "#### Import Modules\n",
+    "Import all modules necessary for this tutorial at once."
    ],
    "metadata": {
     "collapsed": false,
@@ -28,30 +30,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
-    "from river.metrics import CrossEntropy, Accuracy\n",
+    "from river.metrics import Accuracy\n",
     "from river.utils import Rolling\n",
     "from river.ensemble import AdaptiveRandomForestClassifier\n",
     "\n",
     "from river.datasets.synth import Agrawal\n",
+    "from river.datasets.synth import ConceptDriftStream\n",
     "\n",
-    "from increment_explain.explainer import IncrementalPFI\n",
-    "from increment_explain.explainer.sage import IncrementalSage, IntervalSage\n",
-    "from increment_explain.imputer import MarginalImputer\n",
-    "from increment_explain.storage import GeometricReservoirStorage\n",
-    "from increment_explain.utils.wrappers.river import RiverPredictionFunctionWrapper\n",
-    "from increment_explain.visualization import FeatureImportancePlotter"
+    "from ixai.explainer import IncrementalPFI\n",
+    "from ixai.visualization import FeatureImportancePlotter"
    ]
   },
   {
    "cell_type": "markdown",
    "source": [
-    "### Setup data stream"
+    "#### Setup data stream\n",
+    "Initialize a concept drift data stream. The `river` package provides various data streams and utility functions. Here we create a synthetic concept drift data stream derived from the *agrawal* concepts (`classification_function=1` and `classification_function=2`).\n",
+    "The concept drift is centered at the middle of our data stream with a width of 10%.<br>\n",
+    "\n",
+    "For our explanation methods we also need a list of all `feature_names` to be used in the model and later to be explained."
    ],
    "metadata": {
     "collapsed": false,
@@ -62,12 +65,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
+   "execution_count": 29,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "['salary',\n 'commission',\n 'age',\n 'elevel',\n 'car',\n 'zipcode',\n 'hvalue',\n 'hyears',\n 'loan']"
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "n_samples = 15_000\n",
     "stream = Agrawal(classification_function=1, seed=42)\n",
+    "drift_stream = Agrawal(classification_function=2, seed=42)\n",
+    "stream = ConceptDriftStream(stream, drift_stream, position=int(n_samples * 0.5), width=int(n_samples * 0.1), seed=42)\n",
+    "\n",
     "feature_names = list([x_0 for x_0, _ in stream.take(1)][0].keys())\n",
-    "n_samples = 25_000"
+    "feature_names"
    ],
    "metadata": {
     "collapsed": false,
@@ -79,7 +95,11 @@
   {
    "cell_type": "markdown",
    "source": [
-    "### Setup model and loss function"
+    "#### Setup model and loss function\n",
+    "Now we set up our incremental learning model. Since *agrawal* is a classification problem, we utilize a `AdaptiveRandomForestClassifier`.\n",
+    "We need to provide the explainer object a `model_function` and a `loss_function`. Both of these functions need to match. A loss function that compares class probabilities (e.g. CrossEntropy) does not work with a prediction function that only provides the class labels and no probability scores and vice versa.\n",
+    "\n",
+    "For this example, we use the `predict_one` function of the river classifier and the `Accuracy()` metric. Note, that we could also use the `predict_proba_one` prediction function. This has a profound impact on the explanations."
    ],
    "metadata": {
     "collapsed": false,
@@ -90,14 +110,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "outputs": [],
    "source": [
-    "model = AdaptiveRandomForestClassifier(n_models=15, max_depth=10, leaf_prediction='mc')\n",
-    "model_function = RiverPredictionFunctionWrapper(model.predict_proba_one)\n",
+    "model = AdaptiveRandomForestClassifier(n_models=5, max_depth=10, leaf_prediction='nba', seed=42)  # incremental learning model\n",
+    "model_function = model.predict_one  # model function for the explainer object\n",
     "\n",
-    "loss_metric = CrossEntropy()\n",
-    "training_metric = Rolling(CrossEntropy(), window_size=1000)"
+    "loss_metric = Accuracy()  # river metric that will be transformed into a suitable loss function\n",
+    "training_metric = Rolling(Accuracy(), window_size=1000)  # only for tracking the performance, not used for explanations"
    ],
    "metadata": {
     "collapsed": false,
@@ -110,7 +130,11 @@
    "cell_type": "markdown",
    "source": [
     "### Setup Explainers\n",
-    "The explainer also require an imputer and a storage mechanism."
+    "For this basic example, we only illustrate how to create incremental explanations with the `IncrementalPFI` explainers. We further, do not go into the details of its implementations. For this, we strongly refer to this <a href=\"https://arxiv.org/abs/2209.01939\" target=\"_blank\">research paper</a>, the different tutorials, and the documentation.\n",
+    "\n",
+    "Here we calculate iPFI 5 times (`n_inner_samples=5`) for each explanation step to get a more realistic estimate. Note that a larger value linearly increases the computation time of the explanations.\n",
+    "\n",
+    "The `smoothing_alpha` is the most important parameter of our explanations. It controls how much emphasis is given to past observations and computed explanations. A higher value puts more emphasis on recent computations. A lower value distributes the emphasis onto more historic vales. The internal mechanism is an exponential smoothing. For further details, we again refer to the <a href=\"https://arxiv.org/abs/2209.01939\" target=\"_blank\">paper</a>."
    ],
    "metadata": {
     "collapsed": false,
@@ -121,50 +145,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "outputs": [],
    "source": [
-    "storage = GeometricReservoirStorage(\n",
-    "    size=200,\n",
-    "    store_targets=False\n",
-    ")\n",
-    "\n",
-    "imputer = MarginalImputer(\n",
-    "    model_function=model_function,\n",
-    "    storage_object=storage,\n",
-    "    sampling_strategy=\"joint\"\n",
-    ")\n",
-    "\n",
-    "incremental_sage = IncrementalSage(\n",
-    "    model_function=model_function,\n",
-    "    loss_function=loss_metric,\n",
-    "    imputer=imputer,\n",
-    "    storage=storage,\n",
-    "    feature_names=feature_names,\n",
-    "    smoothing_alpha=0.001,\n",
-    "    n_inner_samples=1\n",
-    ")\n",
-    "\n",
-    "interval_sage = IntervalSage(\n",
-    "    model_function=model_function,\n",
-    "    loss_function=loss_metric,\n",
-    "    feature_names=feature_names,\n",
-    "    interval_length=2000,\n",
-    "    n_inner_samples=1\n",
-    ")\n",
-    "\n",
     "incremental_pfi = IncrementalPFI(\n",
     "    model_function=model_function,\n",
     "    loss_function=loss_metric,\n",
-    "    imputer=imputer,\n",
-    "    storage=storage,\n",
     "    feature_names=feature_names,\n",
     "    smoothing_alpha=0.001,\n",
-    "    n_inner_samples=1\n",
-    ")\n",
-    "\n",
-    "sage_plotter = FeatureImportancePlotter(feature_names=feature_names)\n",
-    "pfi_plotter = FeatureImportancePlotter(feature_names=feature_names)"
+    "    n_inner_samples=5\n",
+    ")"
    ],
    "metadata": {
     "collapsed": false,
@@ -176,7 +166,8 @@
   {
    "cell_type": "markdown",
    "source": [
-    "### Train and explain the models"
+    "#### Setup Plotter\n",
+    "You can plot the importance values in form of a line plot with the `FeatureImportancePlotter` plotter. The plotter stores performance values and importance values. It can be controlled with multiple parameters."
    ],
    "metadata": {
     "collapsed": false,
@@ -189,35 +180,105 @@
    "cell_type": "code",
    "execution_count": null,
    "outputs": [],
+   "source": [
+    "pfi_plotter = FeatureImportancePlotter(feature_names=feature_names)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "### Train and explain the models\n",
+    "---\n",
+    "The main training and explanation loop. Each observation is used to update the incremental explainer once. Notice that the explainer uses the current sample always before the model is updated with it."
+   ],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1000: perf 0.665\n",
+      "1000: pfi  {'age': 0.043948233588075314, 'loan': -0.00028463358027166043, 'commission': 0.060447665718043365, 'car': 0.0024201450179420596, 'elevel': 0.004932456568660092, 'hyears': 0.00034406814813911046, 'salary': 0.02950357300077545, 'hvalue': 0.0066880922908391, 'zipcode': 0.0019556586321749876}\n",
+      "\n",
+      "2000: perf 0.761\n",
+      "2000: pfi  {'age': 0.1040104064497502, 'loan': -0.0023567167913120047, 'commission': 0.1285915926669017, 'car': -0.007841769600756401, 'elevel': -0.005051750639488242, 'hyears': -0.0019129555830152468, 'salary': 0.08360826351746756, 'hvalue': 0.001609305822611363, 'zipcode': 0.005715302734802906}\n",
+      "\n",
+      "3000: perf 0.787\n",
+      "3000: pfi  {'age': 0.1299645195382419, 'loan': 0.012514898112997039, 'commission': 0.16296928334946686, 'car': 0.00521286639499035, 'elevel': 0.012660720558292227, 'hyears': 0.006031483917120358, 'salary': 0.11877273386185921, 'hvalue': 0.018869504966240073, 'zipcode': 0.010313845938507524}\n",
+      "\n",
+      "4000: perf 0.791\n",
+      "4000: pfi  {'age': 0.1528837505576089, 'loan': 0.0047005288949039945, 'commission': 0.17791425405944436, 'car': 0.0028361021646583343, 'elevel': 0.0065045078900834, 'hyears': -0.0035606464702663963, 'salary': 0.13793256280981941, 'hvalue': 0.007202349280917228, 'zipcode': 0.007037161229680017}\n",
+      "\n",
+      "5000: perf 0.805\n",
+      "5000: pfi  {'age': 0.16777426859381286, 'loan': 0.010325095053105169, 'commission': 0.15951036818028014, 'car': -0.005196490489157084, 'elevel': 0.009532023709853841, 'hyears': -0.00787494610123733, 'salary': 0.17270093091099645, 'hvalue': 0.010099046068010303, 'zipcode': 0.006259629876587342}\n",
+      "\n",
+      "6000: perf 0.837\n",
+      "6000: pfi  {'age': 0.19058110127778174, 'loan': 0.001310552892550973, 'commission': 0.12982201076105765, 'car': -0.009097804800009969, 'elevel': -0.0027487473030794987, 'hyears': -0.009885412547919097, 'salary': 0.2186291523067272, 'hvalue': 0.007079285296605341, 'zipcode': 0.0020984111581174047}\n",
+      "\n",
+      "7000: perf 0.834\n",
+      "7000: pfi  {'age': 0.1999183539792274, 'loan': -0.0019277314378268605, 'commission': 0.1110328951682989, 'car': 0.002367033518851928, 'elevel': 0.0027681220655051586, 'hyears': -0.0006463872627807457, 'salary': 0.23510919760503038, 'hvalue': 0.006008758244312614, 'zipcode': -0.00433399674701779}\n",
+      "\n",
+      "8000: perf 0.694\n",
+      "8000: pfi  {'age': 0.14125816558972937, 'loan': 0.001956253327080347, 'commission': 0.08028318042253438, 'car': -0.0010500942523895306, 'elevel': 0.011479039224947049, 'hyears': -0.0016128938610452776, 'salary': 0.1696849232942196, 'hvalue': 0.0004107090102472874, 'zipcode': 0.0010755155217369824}\n",
+      "\n",
+      "9000: perf 0.667\n",
+      "9000: pfi  {'age': 0.1479920424613849, 'loan': 0.0028730836046891336, 'commission': 0.029194688663068732, 'car': -0.008726796449412419, 'elevel': 0.11395467108991209, 'hyears': -0.010150720980574972, 'salary': 0.061056435899215514, 'hvalue': 0.0032335813280179658, 'zipcode': -0.0018386181090987693}\n",
+      "\n",
+      "10000: perf 0.885\n",
+      "10000: pfi  {'age': 0.2912120496192835, 'loan': -0.00021768292439226073, 'commission': 0.01148852279371176, 'car': -0.00399795602483064, 'elevel': 0.27337649510070755, 'hyears': -0.007842320595883974, 'salary': 0.017795339412868885, 'hvalue': -0.003337217300658283, 'zipcode': -0.004372330449226977}\n",
+      "\n",
+      "11000: perf 0.911\n",
+      "11000: pfi  {'age': 0.32800814621575874, 'loan': -0.0003156052740598526, 'commission': 0.007182782717525048, 'car': 0.00029486275381791077, 'elevel': 0.3597253097453424, 'hyears': -0.007498814720784826, 'salary': 0.012820183244363705, 'hvalue': 0.003933691947146891, 'zipcode': -0.000776475478903031}\n",
+      "\n",
+      "12000: perf 0.849\n",
+      "12000: pfi  {'age': 0.3039576720683756, 'loan': -0.0037458627345345508, 'commission': 0.006427572187433064, 'car': 0.005084987157397584, 'elevel': 0.32912793240445376, 'hyears': -0.00011239626719345081, 'salary': 0.00837501108993709, 'hvalue': 0.012301154876723596, 'zipcode': 0.0027340332956182264}\n",
+      "\n",
+      "13000: perf 0.863\n",
+      "13000: pfi  {'age': 0.31061963427129846, 'loan': -0.0020813403011981715, 'commission': -0.0014083430431952274, 'car': 0.0006748161037468149, 'elevel': 0.32667612125881956, 'hyears': 0.00010652765856104387, 'salary': 0.012432341987008433, 'hvalue': 0.011699886022976695, 'zipcode': -0.0005765569822579931}\n",
+      "\n",
+      "14000: perf 0.873\n",
+      "14000: pfi  {'age': 0.3213456302526284, 'loan': -0.0031822416238425255, 'commission': 0.009859913419968228, 'car': -0.0008759017019706767, 'elevel': 0.3399739573061463, 'hyears': 0.004946455146609448, 'salary': 0.016471272702200553, 'hvalue': 0.012038615975290509, 'zipcode': 0.005767739738237013}\n",
+      "\n",
+      "15000: perf 0.89\n",
+      "15000: pfi  {'age': 0.32550327467088935, 'loan': 0.0018681902617038108, 'commission': 0.012527173936423906, 'car': 0.001242055444555175, 'elevel': 0.3618047951887281, 'hyears': 0.0032542916262338945, 'salary': 0.015645985150789587, 'hvalue': 0.024836350939732937, 'zipcode': 0.00719464476887379}\n",
+      "\n"
+     ]
+    }
+   ],
    "source": [
     "for (n, (x_i, y_i)) in enumerate(stream, start=1):\n",
     "    # predicting\n",
-    "    y_i_pred = model.predict_proba_one(x_i)\n",
+    "    y_i_pred = model.predict_one(x_i)\n",
     "    training_metric.update(y_true=y_i, y_pred=y_i_pred)\n",
     "\n",
-    "    # sage inc\n",
-    "    inc_fi_sage = incremental_sage.explain_one(x_i, y_i)\n",
-    "    int_fi_sage = interval_sage.explain_one(x_i, y_i)\n",
-    "    inc_fi_pfi = incremental_pfi.explain_one(x_i, y_i, update_storage=False)\n",
+    "    # explaining\n",
+    "    inc_fi_pfi = incremental_pfi.explain_one(x_i, y_i)\n",
     "\n",
     "    # visualize\n",
-    "    sage_plotter.update(inc_fi_sage, facet_name='inc-sage')\n",
-    "    sage_plotter.update(int_fi_sage, facet_name='int-sage')\n",
-    "    pfi_plotter.update(inc_fi_pfi, facet_name='inc-pfi')\n",
+    "    pfi_plotter.update_performance(training_metric.get(), facet_name='accuracy')\n",
+    "    pfi_plotter.update(inc_fi_pfi, facet_name='iPFI')\n",
     "\n",
     "    # learning\n",
     "    model.learn_one(x_i, y_i)\n",
     "\n",
     "    if n % 1000 == 0:\n",
-    "        print(f\"{n}: perf                {training_metric.get()}\\n\"\n",
-    "              f\"{n}: x_i                 {x_i}\\n\"\n",
-    "              f\"{n}: inc-sage            {incremental_sage.importance_values}\\n\"\n",
-    "              f\"{n}: int-sage            {interval_sage.importance_values}\\n\"\n",
-    "              f\"{n}: pfi-sage            {incremental_pfi.importance_values}\\n\"\n",
-    "              f\"{n}: diff                {incremental_sage.marginal_loss - incremental_sage.model_loss}\\n\"\n",
-    "              f\"{n}: marginal-loss       {incremental_sage.marginal_loss}\\n\"\n",
-    "              f\"{n}: model-loss          {incremental_sage.model_loss}\\n\"\n",
-    "              f\"{n}: sum-sage            {sum(list(incremental_sage.importance_values.values()))}\\n\")\n",
+    "        print(f\"{n}: perf {training_metric.get()}\\n\"\n",
+    "              f\"{n}: pfi  {incremental_pfi.importance_values}\\n\")\n",
     "\n",
     "    if n >= n_samples:\n",
     "        break"
@@ -232,7 +293,12 @@
   {
    "cell_type": "markdown",
    "source": [
-    "### Visualize the explanations"
+    "### Visualize the explanations\n",
+    "Lastly, the explanations can be visualized. Notice how we can clearly see the concept drift induced by changing the classification function. The model performance significantly drops and quickly recovers, as the incremental model easily adapts. With these explanations we can directly identify what happens inside the model and can understand what features are important for the model at any given time.\n",
+    "\n",
+    "At first, the model learns that `salary`, `commission` and `age` are important to discriminate between the classes of the data stream. For the classification function, only `salary` and `age` are important. However, `commission` is dependent on `salary`. Hence, the model picked up on that dependency and uses it internally, as all three features are important.\n",
+    "\n",
+    "After the concept drift, the Random Forest model quickly reacts to the changes and restructures its decision rules. After the change only the independent `age` and `elevel` features are relevant for the classification problem."
    ],
    "metadata": {
     "collapsed": false,
@@ -243,10 +309,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
+   "execution_count": 28,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 1000x500 with 2 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "# TODO add plotter"
+    "performance_kw = {\n",
+    "    \"y_min\": 0, \"y_max\": 1,\n",
+    "}\n",
+    "\n",
+    "fi_kw = {\n",
+    "    \"names_to_highlight\": [\"salary\", \"commission\", \"age\", \"elevel\"],\n",
+    "    \"legend_style\": {\n",
+    "        \"fontsize\": \"small\", 'title': 'features', \"ncol\": 1,\n",
+    "        \"loc\": 'upper left', \"bbox_to_anchor\": (0, 1)}\n",
+    "}\n",
+    "\n",
+    "pfi_plotter.plot(\n",
+    "    performance_kw=performance_kw,\n",
+    "    **fi_kw\n",
+    ")"
    ],
    "metadata": {
     "collapsed": false,
diff --git a/examples/neural_network.py b/examples/neural_network.py
index 5d86904..c7530ee 100644
--- a/examples/neural_network.py
+++ b/examples/neural_network.py
@@ -1,4 +1,5 @@
 import river.metrics
+import torch
 from river.utils import Rolling
 from river import preprocessing, compose
 from river.datasets import Elec2
@@ -11,8 +12,7 @@
 from ixai.explainer.sage import IncrementalSage, IntervalSage
 from ixai.imputer import MarginalImputer
 from ixai.storage import GeometricReservoirStorage
-from ixai.utils.wrappers.river import RiverPredictionFunctionWrapper
-from ixai.utils.wrappers.torch import TorchSupervisedLearningWrapper
+from ixai.utils.wrappers.torch import TorchSupervisedLearningWrapper, TorchWrapper
 
 N_SAMPLES = 10_000
 
@@ -34,7 +34,7 @@ def forward(self, x):
 if __name__ == "__main__":
 
     # Get Data ---------------------------------------------------------------------------------------------------------
-    stream = Elec2()#Agrawal(classification_function=1, seed=42)
+    stream = Elec2()
     feature_names = list([x_0 for x_0, _ in stream.take(1)][0].keys())
 
     N_INPUT = len(feature_names)
@@ -43,13 +43,18 @@ def forward(self, x):
     network_loss_function = nn.CrossEntropyLoss()
     network_optimizer = optim.SGD(network.parameters(), lr=0.001, momentum=0.9)
 
-    loss_metric = river.metrics.Accuracy()
+    loss_metric = river.metrics.CrossEntropy()
     training_metric = Rolling(river.metrics.Accuracy(), window_size=1000)
 
     model = TorchSupervisedLearningWrapper(
         model=network, loss_function=network_loss_function, optimizer=network_optimizer, n_classes=N_CLASSES)
-    model = compose.Pipeline(preprocessing.StandardScaler(), model)
-    model_function = RiverPredictionFunctionWrapper(model.predict_one)
+    scaler = preprocessing.StandardScaler()
+    model = compose.Pipeline(scaler, model)
+
+
+    def network_link_function(x):
+        return torch.softmax(network(x), dim=-1)
+    model_function = TorchWrapper(network_link_function)
 
     # Get imputer and explainers ---------------------------------------------------------------------------------------
     storage = GeometricReservoirStorage(
@@ -104,6 +109,10 @@ def forward(self, x):
         y_i_pred = model.predict_one(x_i)
         training_metric.update(y_true=y_i, y_pred=y_i_pred)
 
+        # transforming for explanation's model function
+        x_i_transformed = scaler.transform_one(x_i)
+        _ = incremental_sage.explain_one(x_i_transformed, y_i)
+
         # sage inc
         _ = incremental_sage.explain_one(x_i, y_i)
         _ = interval_sage.explain_one(x_i, y_i)
diff --git a/examples/pandas_example.py b/examples/pandas_example.py
index 6c8de31..da30797 100644
--- a/examples/pandas_example.py
+++ b/examples/pandas_example.py
@@ -13,7 +13,7 @@
 from ixai.explainer.sage import IncrementalSage, IntervalSage
 from ixai.imputer import MarginalImputer
 from ixai.storage import GeometricReservoirStorage
-from ixai.utils.wrappers import RiverPredictionFunctionWrapper
+from ixai.utils.wrappers import RiverWrapper
 
 if __name__ == "__main__":
 
@@ -28,7 +28,7 @@
     # model
     model = AdaptiveRandomForestRegressor(n_models=15)  # most important hyperparameter is n_models
     model = compose.Pipeline(preprocessing.StandardScaler(), model)
-    model_function = RiverPredictionFunctionWrapper(model.predict_one)
+    model_function = RiverWrapper(model.predict_one)
 
     # performance metric and loss
     loss_metric = MSE()  # real metric can be everything from river.metrics used for explanations
diff --git a/examples/sklearn_example.py b/examples/sklearn_example.py
index 8808661..a5ad3f7 100644
--- a/examples/sklearn_example.py
+++ b/examples/sklearn_example.py
@@ -80,7 +80,7 @@
 
     # main training loop data_x and data_y needs to be pd.DataFrames and / or pd.Series
     for n, (x_i, y_i) in enumerate(iter_pandas(data_x, data_y), start=1):
-        y_i_pred = model_function(x_i)[0][0]
+        y_i_pred = model_function(x_i)['output']
         training_metric.update(y_true=y_i, y_pred=y_i_pred)
 
         # sage inc
diff --git a/ixai/__init__.py b/ixai/__init__.py
index f38884b..3dc1f76 100644
--- a/ixai/__init__.py
+++ b/ixai/__init__.py
@@ -1,2 +1,1 @@
 __version__ = "0.1.0"
-
diff --git a/ixai/explainer/__init__.py b/ixai/explainer/__init__.py
index cb5b8ae..d6cf19d 100644
--- a/ixai/explainer/__init__.py
+++ b/ixai/explainer/__init__.py
@@ -1,3 +1,7 @@
+"""
+This modul gathers the explainers.
+"""
+
 from .pfi import IncrementalPFI
 from .sage import IncrementalSage, BatchSage, IntervalSage
 
diff --git a/ixai/explainer/base.py b/ixai/explainer/base.py
index bdf2d08..1225de1 100644
--- a/ixai/explainer/base.py
+++ b/ixai/explainer/base.py
@@ -71,7 +71,7 @@ def __init__(
             smoothing_alpha: typing.Optional[float] = None
     ):
         super().__init__(model_function, feature_names)
-        self._loss_function = validate_loss_function(loss_function, self._model_function)
+        self._loss_function = validate_loss_function(loss_function)
 
         self._smoothing_alpha = 0.001 if smoothing_alpha is None else smoothing_alpha
         if dynamic_setting:
@@ -82,11 +82,9 @@ def __init__(
             base_tracker = WelfordTracker()
         self._marginal_loss_tracker: Tracker = copy.deepcopy(base_tracker)
         self._model_loss_tracker: Tracker = copy.deepcopy(base_tracker)
-        self._marginal_prediction_tracker: Tracker = MultiValueTracker(base_tracker=copy.deepcopy(base_tracker))
-        self._importance_trackers: dict[str, Tracker] = {
-            feature_name: copy.deepcopy(base_tracker) for feature_name in feature_names}
-        self._variance_trackers: dict[str, Tracker] = {
-            feature_name: copy.deepcopy(base_tracker) for feature_name in feature_names}
+        self._marginal_prediction_tracker: MultiValueTracker = MultiValueTracker(copy.deepcopy(base_tracker))
+        self._importance_trackers: MultiValueTracker = MultiValueTracker(copy.deepcopy(base_tracker))
+        self._variance_trackers: MultiValueTracker = MultiValueTracker(copy.deepcopy(base_tracker))
         self._storage: BaseStorage = storage
         if self._storage is None:
             if dynamic_setting:
@@ -104,19 +102,18 @@ def explain_one(self, *args, **kwargs):
     @property
     def importance_values(self):
         """Incremental Importance Values property."""
-        return {feature_name: float(self._importance_trackers[feature_name].tracked_value)
-                for feature_name in self.feature_names}
+        return self._importance_trackers.get()
 
     @property
     def variances(self):
         """Incremental Variances values property."""
-        return {feature_name: self._variance_trackers[feature_name].get() for feature_name in self.feature_names}
+        return self._variance_trackers.get()
 
     def get_normalized_importance_values(self, mode: str = 'sum') -> dict[str, float]:
         """Normalizes the importance scores.
 
         Args:
-            mode (str): The normalization mode to be applied. Possible values are 'sum' and 'delta'.
+            mode (str): The normalization mode to be applied. Possible values are 'sum' and 'delta'. Defaults to 'sum'.
                 - sum: Normalizes the importance scores by division through the sum of importance scores.
                 - delta: Normalizes the importance scores by division through the difference between the max of the
                 importance scores and the min of the importance scores.
@@ -152,8 +149,27 @@ def _normalize_importance_values(importance_values: dict[str, float], mode: str
         elif mode == 'sum':
             factor = sum(importance_values_list)
         else:
-            raise NotImplementedError(f"mode must be either 'sum', or 'delta' not '{mode}'")
+            raise NotImplementedError(f"The mode must be either 'sum', or 'delta' not '{mode}'.")
         try:
             return {feature: importance_value / factor for feature, importance_value in importance_values.items()}
         except ZeroDivisionError:
             return {feature: 0.0 for feature, importance_value in importance_values.items()}
+
+    def update_storage(self, x_i: dict, y_i: typing.Optional[typing.Any] = None):
+        """Manually updates the data storage with the given observation."""
+        self._storage.update(x=x_i, y=y_i)
+
+
+def _get_mean_model_output(model_outputs: typing.List[typing.Dict]) -> dict:
+    """Calculates the mean values of a list of dict model outputs.
+
+    Args:
+        model_outputs (list[dict]): List of model outputs.
+
+    Returns:
+        (dict) The mean model output, where every label value is the average of all individual label values.
+    """
+    all_labels = {label for model_output in model_outputs for label in model_output}
+    mean_output = {label: sum([output.get(label, 0) for output in model_outputs]) / len(model_outputs)
+                   for label in all_labels}
+    return mean_output
diff --git a/ixai/explainer/pfi.py b/ixai/explainer/pfi.py
index b124844..1fc5e5c 100644
--- a/ixai/explainer/pfi.py
+++ b/ixai/explainer/pfi.py
@@ -43,13 +43,13 @@ def __init__(
         Args:
             model_function (Callable): The Model function to be explained.
             loss_function (Union[Callable, Metric]): The loss function for which the importance values are calculated.
-                This can either be a callable function or a predefined river.metric.base.Metric.
+                This can either be a callable function or a predefined river.metric.base.Metric.<br>
                 - callable function: The loss_function needs to follow the signature of loss_function(y_true, y_pred)
                     and handle the output dimensions of the model function. Smaller values are interpreted as being
                     better. y_pred needs to be an array / list with the shape corresponding to the output dimension
                     (e.g. single-value outputs (e.g. regression, classification): y_pred_1 = [0], y_pred_2 = [1],
                     etc.; for multi-label outputs (e.g. probability scores) y_pred_1 = [0.72, 0.28],
-                    y_pred_2 = [0.01, 0.99]).
+                    y_pred_2 = [0.01, 0.99]).<br>
                 - river.metric.base.Metric: Any Metric implemented in river (e.g. river.metrics.CrossEntropy() for
                     classification or river.metrics.MSE() for regression).
             feature_names (list): List of feature names to be explained for the model.
@@ -65,8 +65,6 @@ def __init__(
             dynamic_setting (bool): Flag to indicate if the modelling setting is dynamic `True` (changing model, and
                 adaptive explanation) or a static modelling setting `False` (all observations contribute equally to the
                 final importance) is assumed. Defaults to `True`.
-            loss_bigger_is_better (bool): Flag that indicates if a smaller loss value indicates a better fit ('True') or
-                not ('False'). This is only used to represent the marginal- and model-loss more sensibly.
         """
         super(IncrementalPFI, self).__init__(
             model_function=model_function,
@@ -94,19 +92,21 @@ def explain_one(
             y_i (Any): Target label of the current observation.
             update_storage (bool): Flag if the underlying incremental data storage mechanism is to be updated with the
                 new observation (`True`) or not (`False`). Defaults to `True`.
-            n_inner_samples (int): n_inner_samples (int): Number of model evaluation per feature for the current
-                explanation step (observation). Defaults to `None`.
+            n_inner_samples (int, optional): Number of model evaluation per feature for the current explanation step
+                (observation). Overrides the attribute `n_inner_samples` only for the current explanation step.
+                Defaults to `None`.
             update_storage: (bool): Flag that indicates if the current sample should also be added to the underling
                 data storage mechanism. Defaults to `True`.
 
         Returns:
-            (dict[str, float]): The current SAGE feature importance scores.
+            (dict[Any, float]): The current PFI feature importance scores.
         """
         if self.seen_samples >= 1:
             if n_inner_samples is None:
                 n_inner_samples = self.n_inner_samples
-            original_prediction = self._model_function(x_i)[0]
+            original_prediction = self._model_function(x_i)
             original_loss = self._loss_function(y_i, original_prediction)
+            pfi = {}
             for feature in self.feature_names:
                 feature_subset = [feature]
                 predictions = self._imputer.impute(
@@ -114,18 +114,14 @@ def explain_one(
                     x_i=x_i,
                     n_samples=n_inner_samples
                 )
-                losses = []
-                for prediction in predictions:
-                    loss = self._loss_function(y_i, prediction[0])
-                    losses.append(loss)
+                losses = [self._loss_function(y_i, prediction) for prediction in predictions]
                 avg_loss = np.mean(losses)
-                pfi = avg_loss - original_loss
-                self._update_pfi(pfi, feature)
-                self._variance_trackers[feature].update((pfi - self.importance_values[feature]) ** 2)
+                pfi[feature] = avg_loss - original_loss
+            self._importance_trackers.update(pfi)
+            variances = {feature: (pfi[feature] - self.importance_values[feature]) ** 2
+                         for feature in self.feature_names}
+            self._variance_trackers.update(variances)
         self.seen_samples += 1
         if update_storage:
             self._storage.update(x_i, y_i)
         return self.importance_values
-
-    def _update_pfi(self, value, feature):
-        self._importance_trackers[feature].update(value)
diff --git a/ixai/explainer/sage.py b/ixai/explainer/sage.py
index 99a9aa5..dcd820b 100644
--- a/ixai/explainer/sage.py
+++ b/ixai/explainer/sage.py
@@ -13,11 +13,11 @@
 import numpy as np
 from tqdm import tqdm
 
-from ixai.explainer.base import BaseIncrementalFeatureImportance
+from ixai.explainer.base import BaseIncrementalFeatureImportance, _get_mean_model_output
 from ixai.imputer import MarginalImputer, BaseImputer
 from ixai.storage import IntervalStorage, BatchStorage
 from ixai.storage.base import BaseStorage
-from ixai.utils.validators.loss import validate_loss_function
+from ixai.utils.validators import validate_loss_function, validate_model_function
 
 __all__ = [
     "IncrementalSage",
@@ -115,6 +115,7 @@ def explain_one(
             self,
             x_i: dict,
             y_i: Any,
+            n_inner_samples: Optional[int] = None,
             update_storage: bool = True
     ) -> dict[str, float]:
         """Explain one observation (x_i, y_i).
@@ -123,6 +124,8 @@ def explain_one(
             x_i (dict[str, Any]): The input features of the current observation as a dict of feature names to feature
                 values.
             y_i (Any): Target label of the current observation.
+            n_inner_samples (int, optional): Number of model evaluation per feature for the current explanation step
+                (observation). Defaults to `None`.
             update_storage (bool): Flag if the underlying incremental data storage mechanism is to be updated with the
                 new observation (`True`) or not (`False`). Defaults to `True`.
 
@@ -130,27 +133,33 @@ def explain_one(
             (dict[str, float]): The current SAGE feature importance scores.
         """
         if self.seen_samples >= 1:
+            if n_inner_samples is None:
+                n_inner_samples = self.n_inner_samples
             permutation_chain = np.random.permutation(self.feature_names)
-            y_i_pred = self._model_function(x_i)[0]
+            y_i_pred = self._model_function(x_i)
             model_loss = self._loss_function(y_i, y_i_pred)
             self._model_loss_tracker.update(model_loss)
             self.marginal_prediction = self._marginal_prediction_tracker.update(y_i_pred).get_normalized()
             sample_loss = self._loss_function(y_i, self.marginal_prediction)
             self._marginal_loss_tracker.update(sample_loss)
             features_not_in_S = set(self.feature_names)
+            marginal_contributions = {}
             for feature in permutation_chain:
                 features_not_in_S.remove(feature)
                 predictions = self._imputer.impute(
                     feature_subset=features_not_in_S,
                     x_i=x_i,
-                    n_samples=self.n_inner_samples
+                    n_samples=n_inner_samples
                 )
-                y = np.mean(np.asarray(predictions), axis=0)[0]
+                y = _get_mean_model_output(predictions)
                 feature_loss = self._loss_function(y_i, y)
                 marginal_contribution = sample_loss - feature_loss
                 sample_loss = feature_loss
-                self._importance_trackers[feature].update(marginal_contribution)
-                self._variance_trackers[feature].update((marginal_contribution - self.importance_values[feature])**2)
+                marginal_contributions[feature] = marginal_contribution
+            self._importance_trackers.update(marginal_contributions)
+            variances = {feature: (marginal_contributions[feature] - self.importance_values[feature])**2
+                         for feature in self.feature_names}
+            self._variance_trackers.update(variances)
         self.seen_samples += 1
         if update_storage:
             self._storage.update(x_i, y_i)
@@ -191,8 +200,8 @@ def __init__(
         """
         self.feature_names = feature_names
         self.n_inner_samples = n_inner_samples
-        self._model_function = model_function
-        self._loss_function = validate_loss_function(loss_function, model_function)
+        self._model_function = validate_model_function(model_function)
+        self._loss_function = validate_loss_function(loss_function)
         self._storage: BaseStorage = storage
         if self._storage is None:
             self._storage = BatchStorage(store_targets=True)
@@ -218,10 +227,14 @@ def explain_many(
             self,
             x_data: list[dict],
             y_data: list[Any],
+            n_inner_samples: Optional[int] = None
     ) -> dict[str, float]:
+        if n_inner_samples is None:
+            n_inner_samples = self.n_inner_samples
         sage_values = {feature: 0. for feature in self.feature_names}
         n_data = len(x_data)
-        marginal_prediction = sum(self._model_function(x_data)) / n_data
+        all_predictions = self._model_function(x_data)
+        marginal_prediction = _get_mean_model_output(all_predictions)
         for n, (x_i, y_i) in tqdm(enumerate(zip(x_data, y_data), start=1), total=n_data):
             permutation_chain = np.random.permutation(self.feature_names)
             loss_previous = self._loss_function(y_true=y_i, y_prediction=marginal_prediction)
@@ -231,9 +244,9 @@ def explain_many(
                 predictions = self._imputer.impute(
                     feature_subset=features_not_in_S,
                     x_i=x_i,
-                    n_samples=self.n_inner_samples
+                    n_samples=n_inner_samples
                 )
-                y = np.mean(np.asarray(predictions), axis=0)[0]
+                y = _get_mean_model_output(predictions)
                 feature_loss = self._loss_function(y_true=y_i, y_prediction=y)
                 marginal_contribution = loss_previous - feature_loss
                 sage_values[feature] += marginal_contribution
@@ -249,19 +262,20 @@ def explain_many_original(
     ) -> dict[str, float]:
         sage_values = {feature: 0. for feature in self.feature_names}
         n_data = len(x_data)
-        marginal_prediction = sum(self._model_function(x_data)) / n_data
+        all_predictions = self._model_function(x_data)
+        marginal_prediction = _get_mean_model_output(all_predictions)
         for n, (x_i, y_i) in tqdm(enumerate(zip(x_data, y_data), start=1), total=n_data):
             permutation_chain = np.random.permutation(self.feature_names)
             x_S = {}
             loss_previous = self._loss_function(y_true=y_i, y_prediction=marginal_prediction)
             for feature in permutation_chain:
                 x_S[feature] = x_i[feature]
-                y = 0
+                predictions = []
                 for k in range(1, self.n_inner_samples + 1):
                     x_marginal = x_data[random.randint(0, n_data - 1)]
                     x_marginal = {**x_marginal, **x_S}
-                    y += self._model_function(x_marginal)[0]
-                y /= k
+                    predictions.append(self._model_function(x_marginal))
+                y = _get_mean_model_output(predictions)
                 feature_loss = self._loss_function(y_true=y_i, y_prediction=y)
                 marginal_contribution = loss_previous - feature_loss
                 sage_values[feature] += marginal_contribution
@@ -286,7 +300,7 @@ def __init__(
 
         if storage is None:
             storage = IntervalStorage(store_targets=True, size=interval_length)
-        assert isinstance(storage, IntervalStorage), f"Only 'IntervalStorage' allowed not {type(storage)}."
+        assert isinstance(storage, IntervalStorage), f"Only 'IntervalStorage' expected not {type(storage)}."
 
         if imputer is None:
             imputer = MarginalImputer(model_function=model_function, sampling_strategy='joint', storage_object=storage)
diff --git a/ixai/explainer/shap.py b/ixai/explainer/shap.py
deleted file mode 100644
index 5bbb849..0000000
--- a/ixai/explainer/shap.py
+++ /dev/null
@@ -1,314 +0,0 @@
-"""
-This module gathers SHAP Explanation Methods
-"""
-
-# Authors: Maximilian Muschalik <maximilian.muschalik@lmu.de>
-#          Fabian Fumagalli <ffumagalli@techfak.uni-bielefeld.de>
-
-import copy
-import random
-from abc import ABCMeta
-from abc import abstractmethod
-from typing import Optional, Iterator, Any, Sequence, Callable
-from collections import Counter
-import itertools
-
-import numpy as np
-from scipy.special import binom
-
-from ixai.utils.permutations import get_n_feature_masks, get_all_feature_masks
-
-__all__ = [
-    "KernelSHAP",
-    "ImprovedSHAP",
-    "IncrementalSHAP"
-]
-
-# =============================================================================
-# Types and constants
-# =============================================================================
-
-EPS = 1e-10
-
-
-# =============================================================================
-# Base Explainer Class
-# =============================================================================
-
-
-class BaseSHAPExplainer(metaclass=ABCMeta):
-    """Base class for SHAP-based explainer algorithms.
-
-    Warning: This class should not be used directly.
-    Use derived classes instead.
-    """
-
-    @abstractmethod
-    def __init__(
-            self,
-            *,
-            model: Callable,
-            feature_names: list[str],
-            random_state: Optional[int] = None
-    ):
-        self.model_fn = model
-        self.feature_names = feature_names
-        self.random_state = random_state
-        self.n_features = len(feature_names)
-        self.paired_subsets, self.unpaired_subset = self._get_paired_subsets(self.n_features)
-        self.n_subsets = self.n_features - 1
-        self.sampling_weight_vector = np.array(
-            [(self.n_features - 1.0) / (i * (self.n_features - i)) for i in range(1, self.n_subsets + 1)])
-        self.sampling_weight_vector /= np.sum(self.sampling_weight_vector)
-        self.sampling_weight_dict = \
-            {subset_size: self.sampling_weight_vector[subset_size - 1] for subset_size in range(1, self.n_features)}
-
-    @abstractmethod
-    def explain_one(self, x, reference_set):
-        pass
-
-    @staticmethod
-    def _shapley_kernel(m: int, s: int) -> float:
-        if s == 0 or s == m:
-            return 10000.
-        return 1 / ((m - 1) * binom(m - 2, s - 1))
-
-    @staticmethod
-    def _shapley_weights(m: int, s: int) -> float:
-        if s > m - 1 or s < 0:
-            return 0
-        else:
-            return 1 / (binom(m - 1, s) * m)
-
-    @staticmethod
-    def _powerset(iterable: Iterator[Any]) -> Iterator[Any]:
-        s = list(iterable)
-        return itertools.chain.from_iterable(itertools.combinations(s, r) for r in range(len(s) + 1))
-
-    @staticmethod
-    def _get_paired_subsets(n_features: int) -> tuple[list[tuple[int, int]], Optional[int]]:
-        subset_sizes = list(range(1, n_features))
-        n_paired_subsets = int(len(subset_sizes) / 2)
-        paired_subsets = [(subset_sizes[subset_size - 1], subset_sizes[-subset_size])
-                          for subset_size in range(1, n_paired_subsets + 1)]
-        unpaired_subset = None
-        if n_paired_subsets < len(subset_sizes) / 2:
-            unpaired_subset = int(np.ceil(len(subset_sizes) / 2))
-        return paired_subsets, unpaired_subset
-
-    def _determine_complete_subsets(self, budget: int) -> tuple[list[int], list[int], int]:
-        complete_subsets = []
-        incomplete_subsets = list(range(1, self.n_subsets + 1))
-        weight_vector = copy.copy(self.sampling_weight_vector)
-        allowed_budget = weight_vector * budget
-        for subset_size_1, subset_size_2 in self.paired_subsets:
-            subset_budget = int(binom(self.n_features, subset_size_1))
-            if allowed_budget[subset_size_1 - 1] >= subset_budget:
-                complete_subsets.extend((subset_size_1, subset_size_2))
-                incomplete_subsets.remove(subset_size_1)
-                incomplete_subsets.remove(subset_size_2)
-                weight_vector[subset_size_1 - 1] = 0
-                weight_vector[subset_size_2 - 1] = 0
-                weight_vector /= np.sum(weight_vector)
-                budget -= subset_budget * 2
-            else:
-                return complete_subsets, incomplete_subsets, budget
-            allowed_budget = weight_vector * budget
-        if self.unpaired_subset is not None:
-            subset_budget = int(binom(self.n_features, self.unpaired_subset))
-            if budget - subset_budget >= 0:
-                complete_subsets.append(self.unpaired_subset)
-                incomplete_subsets.remove(self.unpaired_subset)
-                budget -= subset_budget
-        return complete_subsets, incomplete_subsets, budget
-
-    def _sample_from_weights(self,
-                             budget: int,
-                             subset_sizes: list[int],
-                             *,
-                             random_seed: Optional[int] = None
-                             ) -> dict[int, set[tuple[int]]]:
-        if not subset_sizes:
-            return {}
-        random.seed(random_seed)
-        subset_weight_vector = np.asarray(
-            [self.sampling_weight_vector[subset_size - 1] for subset_size in subset_sizes])
-        subset_weight_vector /= np.sum(subset_weight_vector)
-        subset_sizes_samples = random.choices(subset_sizes, k=budget, weights=subset_weight_vector)
-        subset_sizes_samples = Counter(subset_sizes_samples)
-        masks = {}
-        for subset_size, n_samples in subset_sizes_samples.items():
-            masks[subset_size] = get_n_feature_masks(subset_size, self.n_features, n=n_samples)
-        return masks
-
-    def _sample_complete_subsets(self, subset_sizes: list[int]) -> dict[int, set[tuple[int]]]:
-        masks = {}
-        for subset_size in subset_sizes:
-            masks[subset_size] = get_all_feature_masks(subset_size, self.n_features)
-        return masks
-
-    def _sample_masks(self,
-                      budget: int = 1024,
-                      *,
-                      random_seed: Optional[int] = None
-                      ) -> np.ndarray:
-        all_masks = {}
-        complete_subsets, incomplete_subsets, budget = self._determine_complete_subsets(budget)
-        all_masks.update(self._sample_complete_subsets(complete_subsets))
-        all_masks.update(self._sample_from_weights(budget, incomplete_subsets, random_seed=random_seed))
-        all_masks = np.asarray([mask for key in all_masks.keys() for mask in all_masks[key]])
-        return all_masks
-
-    @staticmethod
-    def _generate_samples(masks: np.ndarray,
-                          x_orig: Any,
-                          reference_set: Sequence[Any]
-                          ) -> np.ndarray:
-        n_masks = len(masks)
-        if hasattr(x_orig, "values"):
-            x_orig = x_orig.values
-        x_orig = np.repeat([x_orig], repeats=n_masks, axis=0)
-        reference_set = np.asarray(reference_set)
-        if len(reference_set) > 1:
-            permuted_samples = np.asarray(random.choices(reference_set, k=n_masks))
-        else:
-            permuted_samples = np.repeat(reference_set, repeats=n_masks, axis=0)
-        masks = masks.astype(bool)
-        permuted_samples[masks] = x_orig[masks]
-        return permuted_samples
-
-    def sample_with_budget(self,
-                           budget: int,
-                           x_orig: np.ndarray,
-                           reference_set: Sequence[np.ndarray],
-                           random_seed: Optional[int] = None
-                           ) -> tuple[np.ndarray, np.ndarray]:
-        masks = self._sample_masks(budget, random_seed=random_seed)
-        permuted_samples = self._generate_samples(masks=masks, x_orig=x_orig, reference_set=reference_set)
-        return permuted_samples, masks
-
-    @staticmethod
-    def _get_empty_sample(reference_set: Sequence[np.ndarray]) -> np.ndarray:
-        return np.asarray(random.choice(reference_set))
-
-    def _predict_with_samples(self, samples):
-        if hasattr(samples, "shape"):
-            if len(samples.shape) < 2:
-                try:
-                    samples = samples.reshape((1, samples.shape[0]))
-                except AttributeError:
-                    pass
-        try:
-            predictions = self.model_fn(samples)
-        except Exception as error:
-            raise error
-        return predictions
-
-
-# =============================================================================
-# Public Explainer Classes
-# =============================================================================
-
-
-class KernelSHAP(BaseSHAPExplainer):
-
-    def __init__(
-            self,
-            *,
-            model: object,
-            feature_names: list[str],
-            random_state: Optional[int] = None
-    ):
-        super(KernelSHAP, self).__init__(
-            model=model,
-            feature_names=feature_names,
-            random_state=random_state
-        )
-
-    def explain_one(self,
-                    x,
-                    reference_set: Sequence[Any],
-                    budget: int = 1024,
-                    random_seed: Optional[int] = None
-                    ) -> Any:
-        # TODO refactor into base class and methods
-        # masks = S_shap
-        empty_sample = self._get_empty_sample(reference_set)
-        permuted_samples, masks = self.sample_with_budget(budget=budget,
-                                                          x_orig=x,
-                                                          reference_set=reference_set,
-                                                          random_seed=random_seed)
-
-        y_full = self._predict_with_samples(x)
-        y_empty = self._predict_with_samples(empty_sample)
-        y_permuted = self._predict_with_samples(permuted_samples)
-
-        subset_sizes = np.sum(masks, axis=1)  # = S_sizes
-        subset_weights = [self.sampling_weight_dict[subset_size] for subset_size in subset_sizes]  # = weights_shap
-
-        empty_mask = np.zeros(shape=self.n_features, dtype=int)
-        full_mask = np.ones(shape=self.n_features, dtype=int)
-
-        tmp = np.concatenate(([empty_mask], masks, [full_mask]))
-        S_shap_bar = np.zeros((np.shape(tmp)[0], self.n_features + 1))
-        S_shap_bar[:, -1] = 1
-        S_shap_bar[:, :-1] = tmp
-        weights_shap_bar = np.concatenate(([10000], subset_weights, [10000]))
-        y_all = np.concatenate((y_empty, y_permuted, y_full))
-        y_all = np.reshape(y_all, (y_all.shape[0], 1))
-
-        tmp = np.linalg.inv(np.dot(np.dot(S_shap_bar.T, np.diag(weights_shap_bar)), S_shap_bar))
-        shap_values = np.dot(tmp, np.dot(np.dot(S_shap_bar.T, np.diag(weights_shap_bar)), y_all))
-
-        return shap_values
-
-
-class ImprovedSHAP(BaseSHAPExplainer):
-
-    def __init__(
-            self, *,
-            model,
-            feature_names,
-            random_state
-    ):
-        super(ImprovedSHAP, self).__init__(
-            model=model,
-            feature_names=feature_names,
-            random_state=random_state
-        )
-
-    def explain_one(self, x, reference_set):
-        pass
-
-
-class IncrementalSHAP(BaseSHAPExplainer):
-
-    def __init__(
-            self, *,
-            model,
-            feature_names,
-            random_state
-    ):
-        super(IncrementalSHAP, self).__init__(
-            model=model,
-            feature_names=feature_names,
-            random_state=random_state
-        )
-
-    def explain_one(self, x, reference_set):
-        pass
-
-
-class DummyModel:
-    def __init__(self, variant='regression'):
-        self.variant = variant
-
-    def predict(self, x_predict):
-        if self.variant == 'regression':
-            return [sum(x_i) for x_i in x_predict]
-        else:
-            return [sum(x_i) / len(x_i) for x_i in x_predict]
-
-
-if __name__ == "__main__":
-    pass
diff --git a/ixai/imputer/base.py b/ixai/imputer/base.py
index c4f6f68..48c738b 100644
--- a/ixai/imputer/base.py
+++ b/ixai/imputer/base.py
@@ -1,6 +1,8 @@
 from abc import abstractmethod, ABC
 import typing
 
+from ixai.utils.validators import validate_model_function
+
 
 class BaseImputer(ABC):
     """Base class for sampling algorithms.
@@ -14,7 +16,7 @@ def __init__(
             self,
             model_function: typing.Callable
     ):
-        self.model_function = model_function
+        self.model_function = validate_model_function(model_function)
 
     @abstractmethod
     def impute(self, feature_subset, x_i, n_samples=None):
diff --git a/ixai/imputer/tree_imputer.py b/ixai/imputer/tree_imputer.py
index fc448a7..937407d 100644
--- a/ixai/imputer/tree_imputer.py
+++ b/ixai/imputer/tree_imputer.py
@@ -9,6 +9,7 @@
 
 EPS = 0.0000001
 
+
 class TreeImputer(BaseImputer):
     def __init__(
             self,
@@ -75,7 +76,6 @@ def _sample_from_storages(self, feature_name, x_i, n_samples: int = 1):
         return sampled_feature_value
 
     def impute(self, feature_subset, x_i, n_samples: int = 1):
-        x_original_data = {feature_name: x_i[feature_name] for feature_name in x_i.keys() if feature_name not in feature_subset}
         predictions = []
         for _ in range(n_samples):
             sampled_values = {}
diff --git a/ixai/storage/base.py b/ixai/storage/base.py
index ec0747a..9592de0 100644
--- a/ixai/storage/base.py
+++ b/ixai/storage/base.py
@@ -40,4 +40,4 @@ def get_data(self):
         Returns:
             List of Features and targets in storage as tuple.
         """
-        return (self._storage_x, self._storage_y)
+        return self._storage_x, self._storage_y
diff --git a/ixai/storage/interval_storage.py b/ixai/storage/interval_storage.py
index 42c443f..ab6bdd6 100644
--- a/ixai/storage/interval_storage.py
+++ b/ixai/storage/interval_storage.py
@@ -12,6 +12,12 @@ def __init__(
             size: int,
             store_targets: bool = True
     ):
+        """
+        Args:
+            size (int): The length of the interval for which data points should be stored.
+            store_targets (bool): Flag if the target values should be stored (`True`) or not (`False`). Defaults to
+                `True`.
+        """
         self.size = size
         self.store_targets = store_targets
         self._storage_x = deque()
diff --git a/ixai/storage/tree_storage.py b/ixai/storage/tree_storage.py
index a9060e6..bd6706b 100644
--- a/ixai/storage/tree_storage.py
+++ b/ixai/storage/tree_storage.py
@@ -15,6 +15,20 @@
 from .base import BaseStorage
 
 
+def get_all_tree_paths(node, walked_path: str = '', paths=None) -> List[str]:
+    if paths is None:
+        paths = []
+    try:
+        children = node.children
+        for branch_no, child in enumerate(children):
+            child_path = walked_path + "|".join((str(node), str(node.repr_split), str(branch_no))) + "|STOP|"
+            _ = get_all_tree_paths(child, walked_path=child_path, paths=paths)
+    except AttributeError:
+        walked_path += str(node) + "|STOP|"
+        paths.append(walked_path)
+    return paths
+
+
 def walk_through_tree(node, x_i, until_leaf=True) -> typing.Iterable[typing.Union["Branch", "Leaf"]]:
     """Traverses a decision tree given a data point, and a starting node.
 
@@ -92,8 +106,15 @@ class TreeStorage(BaseStorage):
         data_reservoirs (dict[str, dict]): Dictionary of data reservoirs for each feature and leaf nodes.
     """
 
-    def __init__(self, cat_feature_names: List[str], num_feature_names: List[str],
-                 max_depth: int = 5, leaf_reservoir_length: int = 10):
+    def __init__(
+            self,
+            cat_feature_names: List[str],
+            num_feature_names: List[str],
+            max_depth: int = 5,
+            leaf_reservoir_length: int = 10,
+            grace_period: int = 200,
+            seed: Optional[int] = None
+    ):
         """ A Tree Storage that trains incremental decision trees for each feature.
 
         Args:
@@ -102,18 +123,23 @@ def __init__(self, cat_feature_names: List[str], num_feature_names: List[str],
             max_depth (int): Maximum tree depth for the incremental decision trees. Defaults to 5.
             leaf_reservoir_length (int): Size of the reservoir stored at each leaf node of each feature's incremental
                 decision tree. Defaults to 10.
+            grace_period (int): Grace period of the underlying river Hoeffding Adaptive Trees. Defaults to 200.
+            seed (int, optional): Random seed of the underlying river Hoeffding Adaptive Trees. Defaults to None.
         """
         self.feature_names = cat_feature_names + num_feature_names
         self.cat_feature_names = cat_feature_names
         self.num_feature_names = num_feature_names
         self._leaf_reservoir_length = leaf_reservoir_length
+        self._seen_samples = 0
 
         self._storage_x = {cat_feature: HoeffdingAdaptiveTreeClassifier(
-            max_depth=max_depth, leaf_prediction='nba', binary_split=True)
+            max_depth=max_depth, leaf_prediction='nba', binary_split=True,
+            grace_period=grace_period, seed=seed)
             for cat_feature in self.cat_feature_names}
         self._storage_x.update(
             {num_feature: HoeffdingAdaptiveTreeRegressor(
-                max_depth=max_depth, leaf_prediction='adaptive', binary_split=True)
+                max_depth=max_depth, leaf_prediction='adaptive', binary_split=True,
+                grace_period=grace_period, seed=seed)
                 for num_feature in self.num_feature_names})
 
         self.performances = {num_feature: Rolling(R2(), window_size=1000) for num_feature in self.num_feature_names}
@@ -127,7 +153,7 @@ def update(self, x: Dict, y: Optional[Any] = None):
 
         Args:
             x: Features as List of Dicts
-            y: Target as float or integer
+            y: Target as float or integer (not used)
 
         Returns:
             None
@@ -141,6 +167,7 @@ def update(self, x: Dict, y: Optional[Any] = None):
                 self._update_data_reservoirs(feature_name, x_i, x)
                 pred_i = feature_model.predict_one(x_i)
                 self.performances[feature_name].update(y_i, pred_i)
+        self._seen_samples += 1
 
     @staticmethod
     def get_path_through_tree(node, x_i) -> str:
@@ -176,7 +203,7 @@ def _update_data_reservoirs(self, feature_name, x_i, x):
         if leaf_id not in data_reservoir:
             data_reservoir[leaf_id] = GeometricReservoirStorage(
                 size=self._leaf_reservoir_length, store_targets=False, constant_probability=1.0)
-            self._delete_old_reservoir_if_necessary(leaf_id, feature_name)
+            self._delete_outdated_reservoirs(feature_name, root_node)
         data_reservoir[leaf_id].update(x)
 
     def __call__(self, feature_name: str) -> Tuple[Union[HoeffdingTreeRegressor, HoeffdingTreeClassifier], str]:
@@ -198,17 +225,19 @@ def __call__(self, feature_name: str) -> Tuple[Union[HoeffdingTreeRegressor, Hoe
         else:
             raise ValueError(f"The {feature_name} is not stored.")
 
-    def _delete_old_reservoir_if_necessary(self, leaf_id: str, feature_name: str):
-        """Delete the reservoir that is outdated if a new path is added.
+    def _delete_outdated_reservoirs(self, feature_name: str, root_node: typing.Union["Branch", "Leaf"]):
+        """Deletes the outdated reservoirs that no longer are part of all paths in the decision trees.
 
         Args:
-            leaf_id (str): The str path through the tree where each nodes are seperated with a `|STOP|`.
             feature_name (str): The feature name for which outdated leafs might be deleted.
+            root_node ("Branch", "Leaf"): The root node of the feature decision tree.
         """
-
-        steps = leaf_id.split('|STOP|')[0:-1]
-        previous_reservoir_id = '|STOP|'.join([*steps[0:-2], steps[-1]]) + '|STOP|'
-        if len(steps) > 1:
-            reservoir_ids = set(self.data_reservoirs[feature_name].keys())
-            if previous_reservoir_id in reservoir_ids:
-                del self.data_reservoirs[feature_name][previous_reservoir_id]
+        all_leafs = get_all_tree_paths(root_node)
+        reservoirs_labels = list(self.data_reservoirs[feature_name].keys())
+        for reservoirs_label in reservoirs_labels:
+            if reservoirs_label not in all_leafs:
+                del self.data_reservoirs[feature_name][reservoirs_label]
+
+    def __len__(self):
+        """Returns the number of samples observed in the storage object."""
+        return self._seen_samples
diff --git a/ixai/storage/uniform_reservoir_storage.py b/ixai/storage/uniform_reservoir_storage.py
index ae87daf..cf7ea3d 100644
--- a/ixai/storage/uniform_reservoir_storage.py
+++ b/ixai/storage/uniform_reservoir_storage.py
@@ -45,7 +45,7 @@ def update(self, x: Dict, y: Optional[Any] = None):
 
         Args:
             x (dict): Current observation's features.
-            y (Optional): Current observation's label. Defaults to None.
+            y (Any, optional): Current observation's label. Defaults to None.
         """
         self.stored_samples += 1
         if self.stored_samples <= self.size:
diff --git a/ixai/utils/tracker/base.py b/ixai/utils/tracker/base.py
index f43ca5a..aa57623 100644
--- a/ixai/utils/tracker/base.py
+++ b/ixai/utils/tracker/base.py
@@ -18,22 +18,22 @@ def __init__(self):
         self.tracked_value = 0
         self.N = 0
 
+    @abc.abstractmethod
+    def update(self, *args, **kwargs) -> "Tracker":
+        """Updates the tracker with a new value or values."""
+        raise NotImplementedError
+
     def __repr__(self):
         return f"{np.round(self.tracked_value, 2)}"
 
     def __call__(self, *args, **kwargs):
-        """Returns the current tracked value"""
+        """Returns the current tracked value."""
         return self.tracked_value
 
     def get(self):
-        """Returns the current tracked value"""
-        return self.tracked_value
-
-    @abc.abstractmethod
-    def update(self, *args, **kwargs) -> "Tracker":
-        """Updates the tracker with a new value or values."""
-        raise NotImplementedError
+        """Returns the current tracked value."""
+        return self()
 
     def get_normalized(self):
-        """Default returns the current tracked value"""
+        """Default normalization which only returns the current tracked value."""
         return self.get()
diff --git a/ixai/utils/tracker/exponential_smoothing.py b/ixai/utils/tracker/exponential_smoothing.py
index 7bd43f3..0d2fb02 100644
--- a/ixai/utils/tracker/exponential_smoothing.py
+++ b/ixai/utils/tracker/exponential_smoothing.py
@@ -4,7 +4,7 @@
 
 
 class ExponentialSmoothingTracker(Tracker):
-    """A Tracker that applies Exponential Smoothing on the numeric input values"""
+    """A Tracker that applies Exponential Smoothing on the numeric input values."""
 
     def __init__(self, alpha: float):
         assert 0 <= alpha <= 1, "Alpha must be set to a value in between zero and one. [0,1]."
@@ -14,10 +14,8 @@ def __init__(self, alpha: float):
     def update(self, value_i: Union[int, float]) -> "Tracker":
         """Adds one value to the Tracker
 
-        Parameters
-        ----------
-        value_i : number (int or float)
-            numeric value to be added to the tracker
+        Args:
+            value_i (int or float): The numeric value to be added to the tracker.
         """
         self.tracked_value = (1 - self.alpha) * self.tracked_value + self.alpha * value_i
         self.N += 1
diff --git a/ixai/utils/tracker/multi_value.py b/ixai/utils/tracker/multi_value.py
index c2b1984..cf12b42 100644
--- a/ixai/utils/tracker/multi_value.py
+++ b/ixai/utils/tracker/multi_value.py
@@ -1,40 +1,66 @@
 import copy
-
-import numpy as np
+import typing
 
 from ixai.utils.tracker.base import Tracker
 
 
 class MultiValueTracker(Tracker):
+    """A Tracker for storing multiple values at once in the form of a dict mapping from keys to individual Trackers.
+
+    Attributes:
+        tracked_value (dict): The dictionary containing the individual trackers for each value.
+    """
 
     def __init__(self, base_tracker: Tracker):
+        """
+        Args:
+            base_tracker (Tracker): The tracker object to be used for each new element to be tracked.
+        """
         super().__init__()
-        self.tracked_value: list[Tracker] = [0]
-        self._tracked_indices = 0
-        self._base_tracker = base_tracker
-
-    def update(self, values: list[float]) -> "Tracker":
-        if len(values) > self._tracked_indices:
-            if self._tracked_indices == 0:
-                self.tracked_value: list[Tracker] = []
-            for _ in range(len(values) - self._tracked_indices):
-                self.tracked_value.append(copy.deepcopy(self._base_tracker))
-                self._tracked_indices += 1
-        for i in range(self._tracked_indices):
-            self.tracked_value[i].update(values[i])
+        self.tracked_value: typing.Dict[Tracker] = {}
+        self._tracked_keys: typing.Set = set()
+        self._base_tracker = copy.deepcopy(base_tracker)
+
+    def update(self, values: dict[typing.Any, typing.Union[int, float]]) -> "Tracker":
+        """Adds one value for tracked object to the tracker.
+
+        Note:
+            Whenever the input dictionary contains a new key not stored in the Tracker, it will be added to its storage.
+
+        Args:
+            values (dict): A dictionary mapping from keys to numeric values to be added to the tracker.
+        """
+        keys_in_update = set(values.keys())
+        for key in keys_in_update:
+            try:
+                self.tracked_value[key].update(values[key])
+            except KeyError:
+                self.tracked_value[key] = copy.deepcopy(self._base_tracker)
+                self.tracked_value[key].update(values[key])
+                self._tracked_keys.add(key)
+        for key in self._tracked_keys - keys_in_update:
+            self.tracked_value[key].update(0)  # is zero the right value to add?
         self.N += 1
         return self
 
     def __call__(self):
-        return np.asarray([self.tracked_value[i].get() for i in range(self._tracked_indices)])
-
-    def get(self):
-        return self()
+        """Returns the current tracked values."""
+        return {key: self.tracked_value[key].get() for key in self._tracked_keys}
 
     def get_normalized(self):
-        if self._tracked_indices <= 1:
-            return self.get()
+        """Normalizes the tracked values by dividing them through the sum of the values."""
+        tracked_values: dict = self.get()
+        if len(self._tracked_keys) <= 1:
+            return tracked_values
         try:
-            return self.get() / sum(self.get())
+            tracked_values = {key: value / sum(tracked_values.values()) for key, value in tracked_values.items()}
         except ZeroDivisionError:
-            return 0.
+            tracked_values = {key: 0. for key in tracked_values.keys()}
+        return tracked_values
+
+    def __repr__(self):
+        return f"MultiValueTracker: {self.get()}"
+
+    def get(self) -> dict:
+        """Returns the current tracked values."""
+        return self()
diff --git a/ixai/utils/tracker/sliding_window.py b/ixai/utils/tracker/sliding_window.py
index 78ad626..b40b261 100644
--- a/ixai/utils/tracker/sliding_window.py
+++ b/ixai/utils/tracker/sliding_window.py
@@ -18,10 +18,8 @@ def __init__(self, k: int):
     def update(self, value_i: Union[int, float]) -> "Tracker":
         """Adds one value to the Tracker
 
-        Parameters
-        ----------
-        value_i : number (int or float)
-            numeric value to be added to the tracker
+        Args:
+            value_i (int or float): The numeric value to be added to the tracker.
         """
         if self.window_k < self.k:
             self.sliding_window[self.window_k] = value_i
@@ -32,7 +30,7 @@ def update(self, value_i: Union[int, float]) -> "Tracker":
         return self
 
     def __call__(self, *args, **kwargs):
-        """Returns the current mean of the sliding window"""
+        """Returns the current mean of the sliding window."""
         return self.mean
 
     def __repr__(self):
@@ -40,15 +38,15 @@ def __repr__(self):
 
     @property
     def mean(self):
-        """Returns the current mean of the sliding window"""
+        """Returns the current mean of the sliding window."""
         return float(np.nanmean(self.sliding_window, axis=0))
 
     @property
     def var(self):
-        """Returns the variance of the sliding window"""
+        """Returns the variance of the sliding window."""
         return float(np.nanvar(self.sliding_window, axis=0))
 
     @property
     def std(self):
-        """Returns the standard deviation of the sliding window"""
+        """Returns the standard deviation of the sliding window."""
         return float(np.nanstd(self.sliding_window, axis=0))
diff --git a/ixai/utils/tracker/welford.py b/ixai/utils/tracker/welford.py
index 10f4dc9..0c454f3 100644
--- a/ixai/utils/tracker/welford.py
+++ b/ixai/utils/tracker/welford.py
@@ -4,23 +4,20 @@
 
 
 class WelfordTracker(Tracker):
-    """ A Tracker that applies Welford's Algorithm to estimate the mean and variance of a sequence.
+    """A Tracker that applies Welford's Algorithm to estimate the mean and variance of a sequence.
 
-    Notes
-    -----
-    Taken and adapted from Ian Covert's SAGE implementation.
+    Notes:
+        Taken and adapted from Ian Covert's SAGE implementation.
     """
     def __init__(self):
         super().__init__()
         self.sum_squares = 0
 
     def update(self, value_i: Union[int, float]):
-        """Adds one value to the Tracker
+        """Adds one value to the Tracker.
 
-        Parameters
-        ----------
-        value_i : number (int or float)
-            numeric value to be added to the tracker
+        Args:
+            value_i (int or float): The numeric value to be added to the tracker.
         """
         self.N += 1
         difference_1 = value_i - self.tracked_value
@@ -31,15 +28,15 @@ def update(self, value_i: Union[int, float]):
 
     @property
     def var(self):
-        """Returns the variance of the stream"""
-        return self.sum_squares / (max(self.N, 1) ** 2)
+        """Returns the variance of the stream."""
+        return self.sum_squares / max(self.N, 1)
 
     @property
     def std(self):
-        """Returns the standard deviation of the stream"""
+        """Returns the standard deviation of the stream."""
         return self.var ** 0.5
 
     @property
     def mean(self):
-        """Returns the mean of the stream"""
+        """Returns the mean of the stream."""
         return self.tracked_value
diff --git a/ixai/utils/validators/__init__.py b/ixai/utils/validators/__init__.py
index e69de29..0e4836b 100644
--- a/ixai/utils/validators/__init__.py
+++ b/ixai/utils/validators/__init__.py
@@ -0,0 +1,7 @@
+from ixai.utils.validators.loss import validate_loss_function
+from ixai.utils.validators.model import validate_model_function
+
+__all__ = [
+    "validate_loss_function",
+    "validate_model_function"
+]
diff --git a/ixai/utils/validators/loss.py b/ixai/utils/validators/loss.py
index 85b7671..738feb3 100644
--- a/ixai/utils/validators/loss.py
+++ b/ixai/utils/validators/loss.py
@@ -3,72 +3,32 @@
 #          Rohit Jagtani
 
 import typing
-import abc
 
 from river.metrics.base import Metric
 
-
-class RiverMetricToLossFunction:
-
-    def __init__(self, river_metric: "Metric"):
-        self._river_metric = river_metric
-        self._sign = 1.
-        if hasattr(self._river_metric, "bigger_is_better") and self._river_metric.bigger_is_better:
-            self._sign = -1.
-
-    @abc.abstractmethod
-    def __call__(self, y_true, y_prediction):
-        pass
-
-
-class RiverDictLabelMetricToLossFunction(RiverMetricToLossFunction):
-
-    def __init__(self, river_metric: "Metric"):
-        super().__init__(river_metric)
-
-    def __call__(self, y_true, y_prediction):
-        y_prediction = {i: y_prediction[i] for i in range(0, len(y_prediction))}
-        loss_i = self._river_metric.update(y_true=y_true, y_pred=y_prediction).get()
-        self._river_metric.revert(y_true=y_true, y_pred=y_prediction)
-        return loss_i * self._sign
-
-
-class RiverSingletonMetricToLossFunction(RiverMetricToLossFunction):
-
-    def __init__(self, river_metric: "Metric"):
-        super().__init__(river_metric)
-
-    def __call__(self, y_true, y_prediction):
-        try:
-            y_prediction = float(y_prediction[0])
-        except (TypeError, IndexError):
-            y_prediction = float(y_prediction)
-        loss_i = self._river_metric.update(y_true=y_true, y_pred=y_prediction).get()
-        self._river_metric.revert(y_true=y_true, y_pred=y_prediction)
-        return loss_i * self._sign
+from ixai.utils.wrappers.river import RiverMetricToLossFunction
 
 
 def _get_loss_function_from_river_metric(river_metric: "Metric"):
-    try:
-        _ = river_metric.update(y_true=0, y_pred={0: 1}).revert(y_true=0, y_pred={0: 1})
-        validated_loss_function = RiverDictLabelMetricToLossFunction(river_metric=river_metric)
-        _ = validated_loss_function(0, [0])
-        _ = validated_loss_function(0, [0, 0])
-        return validated_loss_function
-    except:
-        pass
     try:
         _ = river_metric.update(y_true=0, y_pred=0).revert(y_true=0, y_pred=0)
-        validated_loss_function = RiverSingletonMetricToLossFunction(river_metric=river_metric)
-        _ = validated_loss_function(0, 0)
-        _ = validated_loss_function(0, [0])
+        validated_loss_function = RiverMetricToLossFunction(river_metric=river_metric, dict_input_metric=False)
+        _ = validated_loss_function(0, {'output': 0})
         return validated_loss_function
-    except:
-        pass
-    raise ValueError(f"Provided river metric cannot be transformed into a viable loss function.")
-
-
-def validate_loss_function(loss_function: typing.Union[typing.Callable, "Metric"], model_function: typing.Callable):
+    except AttributeError:  # river metric expects a dict as y_pred
+        try:
+            _ = river_metric.update(y_true=0, y_pred={0: 0}).revert(y_true=0, y_pred={0: 0})
+            validated_loss_function = RiverMetricToLossFunction(river_metric=river_metric, dict_input_metric=True)
+            _ = validated_loss_function(0, {'output_1': 0})
+            return validated_loss_function
+        except Exception as e:
+            raise e
+    except Exception as e:
+        raise ValueError(f"Provided river metric cannot be transformed into a viable loss function. "
+                         f"Error {e} was raised.")
+
+
+def validate_loss_function(loss_function: typing.Union[typing.Callable, "Metric"]):
     validated_loss_function = loss_function
     if isinstance(loss_function, Metric):  # loss function is a river metric object
         validated_loss_function = _get_loss_function_from_river_metric(river_metric=loss_function)
diff --git a/ixai/utils/validators/model.py b/ixai/utils/validators/model.py
index ce4d258..bb9f5cc 100644
--- a/ixai/utils/validators/model.py
+++ b/ixai/utils/validators/model.py
@@ -1,11 +1,27 @@
 import typing
+import warnings
 
-from ..wrappers.base import Wrapper
+from ixai.utils.wrappers.base import Wrapper
+from ixai.utils.wrappers import SklearnWrapper, TorchWrapper, RiverWrapper
 
 
 def validate_model_function(model_function: typing.Any) -> typing.Callable:
     if isinstance(model_function, Wrapper):
         return model_function  # we assume the wrapper is applied correctly
-    # TODO validate model_function
-    validated_model_function = model_function
-    return validated_model_function
+
+    function_name = str(type(model_function.__self__))
+    if 'sklearn' in function_name:
+        return SklearnWrapper(prediction_function=model_function)
+    elif 'river' in function_name:
+        return RiverWrapper(prediction_function=model_function)
+    elif 'torch' in function_name:
+        warnings.warn("Torch Model Function provided. Default device 'cpu' is used. If your module is not running on "
+                      "this device. Please manually apply the `ixai.utils.wrappers.TorchWrapper` and specify the "
+                      "correct device.", UserWarning)
+        return TorchWrapper(link_function=model_function)
+    else:  # no known model function
+        warnings.warn("The provided model function cannot be automatically wrapped and will be used directly. "
+                      "If you follow the internal logic of our model functions and designed your model function "
+                      "accordingly, this warning can be neglected. If not please investigate how the model functions "
+                      "need to be designed.", UserWarning)
+    return model_function
diff --git a/ixai/utils/wrappers/__init__.py b/ixai/utils/wrappers/__init__.py
index b92d50c..3dc473f 100644
--- a/ixai/utils/wrappers/__init__.py
+++ b/ixai/utils/wrappers/__init__.py
@@ -5,11 +5,13 @@
 """
 
 from .sklearn import SklearnWrapper
-from .river import RiverPredictionFunctionWrapper
-from .torch import TorchSupervisedLearningWrapper
+from .river import RiverWrapper, RiverMetricToLossFunction
+from .torch import TorchSupervisedLearningWrapper, TorchWrapper
 
 __all__ = [
+    "TorchWrapper",
     "TorchSupervisedLearningWrapper",
-    "RiverPredictionFunctionWrapper",
-    "SklearnWrapper"
+    "RiverWrapper",
+    "SklearnWrapper",
+    "RiverMetricToLossFunction"
 ]
diff --git a/ixai/utils/wrappers/base.py b/ixai/utils/wrappers/base.py
index c463380..b226846 100644
--- a/ixai/utils/wrappers/base.py
+++ b/ixai/utils/wrappers/base.py
@@ -1,4 +1,7 @@
 import abc
+import typing
+
+import numpy as np
 
 
 class Wrapper(metaclass=abc.ABCMeta):
@@ -6,12 +9,114 @@ class Wrapper(metaclass=abc.ABCMeta):
 
     Warning: This class should not be used directly.
     Use derived classes instead.
+
+    Attributes:
+        default_label (str): Default dict key for single value model outputs.
     """
 
-    @abc.abstractmethod
-    def __init__(self):
-        raise NotImplementedError
+    def __init__(self, prediction_function, feature_names):
+        self._feature_names: list = feature_names
+        self._prediction_function = prediction_function
+        self.default_label = 'output'
 
     @abc.abstractmethod
-    def __call__(self, *args, **kwargs):
+    def __call__(self, x: typing.Union[typing.List[dict], dict]) -> typing.Union[dict, typing.List[dict]]:
         raise NotImplementedError
+
+    # {features: values} -> [[values]]
+    def convert_1d_input_to_arr(self, x_dict: dict) -> np.ndarray:
+        """Transforms a 1d input (a single dict) into an array of shape (1, N_Features).
+
+        Note:
+            If the `feature_names` parameter is not None in the initialization of the Wrapper. The transformed output
+            array is resorted in this order and to only contain the specified features.
+
+        Args:
+            x_dict (dict): Input dictionary of type `{feature_name: feature_value}`.
+
+        Returns:
+            (np.ndarray): The transformed input array of shape (1, N_Features).
+
+        Examples:
+            Basic usage:
+            >>> x_input = {'feature_1': 'value_1', 'feature_2': 2}
+            >>> x_array = Wrapper.convert_1d_input_to_arr(x_input)
+            >>> print(x_array, x_array.shape)
+            >>> [['value_1', 2]], (1, 2)
+        """
+        if self._feature_names is not None:
+            x_dict = {feature: x_dict[feature] for feature in self._feature_names}
+        return np.asarray(list(x_dict.values())).reshape(1, -1)
+
+    # [{features: values_1}, {features: values_2}] -> [[values], [values_2]]
+    def convert_2d_input_to_arr(self, x_dicts: typing.Sequence[dict]) -> np.ndarray:
+        """Transforms a 2d input (a list of dicts) into an array of shape (N_Instances, N_Features).
+
+        Note:
+            If the `feature_names` parameter is not None in the initialization of the Wrapper. The transformed output
+            array is resorted in this order and to only contain the specified features.
+
+        Args:
+            x_dicts (list[dict]): List of input dictionaries of type `{feature_name: feature_value}`.
+
+        Returns:
+            (np.ndarray): The transformed input array of shape (N_Instances, N_Features).
+
+        Examples:
+            Basic usage:
+            >>> x_inputs = [{'feature_1': 'value_1', 'feature_2': 2}, {'feature_1': 'value_1', 'feature_2': 3}]
+            >>> x_array = Wrapper.convert_1d_input_to_arr(x_inputs)
+            >>> print(x_array, x_array.shape)
+            >>> [['value_1', 2], ['value_1', 3]], (2, 2)
+        """
+        x_input = []
+        for i in range(len(x_dicts)):
+            if self._feature_names is not None:
+                x_input_i = [x_dicts[i][feature] for feature in self._feature_names]
+            else:
+                x_input_i = list(x_dicts[i].values())
+            x_input.append(x_input_i)
+        return np.asarray(x_input)
+
+    # [[output]] or [output] -> {'output': output}, [[output_1, output_2]] -> {0: output_1, 1: output_2}
+    def convert_arr_output_to_dict(self, y_prediction: np.ndarray) -> dict:
+        """Transforms a prediction output into a dict of outputs.
+
+        Note:
+            If the `feature_names` parameter is not None in the initialization of the Wrapper. The transformed output
+            array is resorted in this order and to only contain the specified features.
+
+        Args:
+            y_prediction (np.ndarray): Output array from model, of shape (1, N_Outputs) or (N_Outputs)
+
+        Returns:
+            (dict): The transformed output dictionary. If the output dimension of the model is 1 (e.g. regression,
+                classification labels) the output dict contains one element mapping from 'output' key to the model
+                output (e.g. original output was `[[1]]` or `[1]` then `{'output': 1}` is the transformed output).
+
+        Examples:
+            Onedimensional Model Output (Labels):
+            >>> model_output = np.asarray([1])
+            >>> Wrapper.convert_arr_output_to_dict(model_output)
+            >>> {'output': 1}
+            >>> model_output = np.asarray([[1]])
+            >>> Wrapper.convert_arr_output_to_dict(model_output)
+            >>> {'output': 1}
+
+            Multidimnesnional Model Output (Probas):
+            >>> model_output = np.asarray([[0.05, 0.5, 0.45]])
+            >>> Wrapper.convert_arr_output_to_dict(model_output)
+            >>> {0: 0.05, 1: 0.5, 2: 0.45}
+
+        Raises:
+            ValueError: If the model outputs are strings.
+        """
+        try:
+            return {self.default_label: float(y_prediction)}
+        except TypeError:  # y_prediction is not a size-1 array or real_valued number
+            y_prediction = y_prediction.flatten()
+            y_prediction = {i: y_prediction[i] for i in range(y_prediction.shape[0])}
+        except ValueError as e:  # y_prediction is probably a size-1 array containing a string
+            raise ValueError(f"Prediction is probably a string: {y_prediction}. Only numeric values allowed. "
+                             f"Exception is raised: {e}.")
+        return y_prediction
diff --git a/ixai/utils/wrappers/river.py b/ixai/utils/wrappers/river.py
index 5f85f37..6b702e7 100644
--- a/ixai/utils/wrappers/river.py
+++ b/ixai/utils/wrappers/river.py
@@ -1,16 +1,14 @@
 """
 This module contains River Model Wrappers to turn the output of river models into lists or arrays.
 """
-
-import copy
 import typing
 
-import numpy as np
+from river.metrics.base import Metric
 
 from ixai.utils.wrappers.base import Wrapper
 
 
-class RiverPredictionFunctionWrapper(Wrapper):
+class RiverWrapper(Wrapper):
     """Wrapper for river prediction functions.
 
     This wrapper turns any prediction function ouput into an iterable (list or np.ndarray) output.
@@ -19,38 +17,72 @@ class RiverPredictionFunctionWrapper(Wrapper):
         Basic usage:
         >>> from river.ensemble import AdaptiveRandomForestClassifier
         >>> model = AdaptiveRandomForestClassifier()
-        >>> model_function = RiverPredictionFunctionWrapper(model.predict_one)
+        >>> model_function = RiverWrapper(model.predict_one)
 
         For classifiers returning probas:
-        >>> model_function = RiverPredictionFunctionWrapper(model.predict_proba_one)
+        >>> model_function = RiverWrapper(model.predict_proba_one)
     """
 
-    def __init__(self, river_predict_function: typing.Callable):
-        self._river_predict_function = river_predict_function
-        self._max_labels = 1
-        self._seen_labels = {0: 0, 1: 1, False: 0, True: 1}
-
-    def _reduce_dict(self, y_prediction):
-        """Transforms a prediction output into a list if it is a dictionary."""
-        if not isinstance(y_prediction, dict):
-            return np.asarray([y_prediction])
-        self._max_labels = max(self._max_labels, max(y_prediction))
-        y_arr = np.zeros(shape=self._max_labels + 1)
-        for key, value in y_prediction.items():
-            y_arr[self._seen_labels[key]] = value
-            if key not in self._seen_labels.keys():
-                self._seen_labels[key] = self._max_labels + 1
-                self._max_labels += 1
-        return y_arr
-
-    def __call__(self, x: typing.Union[typing.List[dict], dict]):
+    def __init__(self, prediction_function: typing.Callable):
+        super().__init__(prediction_function, feature_names=None)
+        self._seen_labels = set()
+
+    def _extend_dict(self, y_prediction):
+        """Transforms a prediction output into a dict of outputs."""
+        if isinstance(y_prediction, dict):
+            return y_prediction  # TODO dicts[str, str] as y_prediction can break this
+        try:
+            return {self.default_label: float(y_prediction)}
+        except ValueError:  # y_prediction is str
+            self._seen_labels.add(y_prediction)
+            output = {label: 0. for label in self._seen_labels}
+            output[y_prediction] = 1.
+            return output
+
+    def __call__(self, x: typing.Union[typing.List[dict], dict]) -> typing.Union[dict, typing.List[dict]]:
         """Runs the model and transforms the output into a list or ndarray.
 
         Args:
             x (Union[list, dict]): Input instance as a dictionary of feature value pairs or a list of dictionaries.
         """
-        x_input = copy.copy(x)
-        if isinstance(x_input, dict):
-            x_input = [x_input]
-        predictions = [self._reduce_dict(self._river_predict_function(x_i)) for x_i in x_input]
-        return predictions
+        if isinstance(x, dict):
+            return self._extend_dict(self._prediction_function(x))
+        return [self._extend_dict(self._prediction_function(x_i)) for x_i in x]
+
+
+class RiverMetricToLossFunction:
+    """Wrapper that transforms a river.metrics.base.Metric into a loss function.
+
+    This Wrapper turns metrics that expect a single value as predictions (e.g. river.metrics.MAE, or
+    river.metrics.Accuracy) or metrics that expect a dictionary as predictions (e.g. river.metrics.CrossEntropy) into
+    a similar interface.
+    """
+
+    def __init__(self, river_metric: "Metric", dict_input_metric: bool = False):
+        """
+        Args:
+            river_metric ("Metric"): The river metric to be used as a loss function.
+            dict_input_metric (bool): Flag if the metric expects dictionary (`True`) or single value (`False`) inputs.
+                Defaults to `False` and expects single values.
+        """
+        self._river_metric = river_metric
+        self._sign = 1.
+        if hasattr(self._river_metric, "bigger_is_better") and self._river_metric.bigger_is_better:
+            self._sign = -1.
+        self._dict_input_metric = dict_input_metric
+
+    def __call__(self, y_true, y_prediction: dict):
+        """Calculates the loss given for a single prediction given its true (expected) value.
+
+        Args:
+            y_true (Any): The true labels.
+            y_prediction (dict): The predicted values.
+
+        Returns:
+            The loss value given the true and predicted labels.
+        """
+        if not self._dict_input_metric:
+            y_prediction = y_prediction.get('output', 0)
+        loss_i = self._river_metric.update(y_true=y_true, y_pred=y_prediction).get()
+        self._river_metric.revert(y_true=y_true, y_pred=y_prediction)
+        return loss_i * self._sign
\ No newline at end of file
diff --git a/ixai/utils/wrappers/sklearn.py b/ixai/utils/wrappers/sklearn.py
index f9ed1ab..46870ec 100644
--- a/ixai/utils/wrappers/sklearn.py
+++ b/ixai/utils/wrappers/sklearn.py
@@ -1,6 +1,5 @@
 import typing
-
-import numpy as np
+import warnings
 
 from ixai.utils.wrappers.base import Wrapper
 
@@ -20,21 +19,27 @@ class SklearnWrapper(Wrapper):
         For classifiers returning probas:
         >>> model_function = SklearnWrapper(model.predict_proba)
 
+        If the dict-inputs may be in a different orderings
+        >>> feature_orderings: list = ['feature_1', 'feature_2', 'feature_3']
+        >>> model_function = SklearnWrapper(model.predict, feature_names=feature_orderings)
+
     Note:
         If the sklearn model is trained with access to the feature names (e.g. trained on a pandas DataFrame) it will
-        raise a warning, which can be suppressed.
+        usually raise a warning, if unnamed feature values are provided (e.g. in the form of a np.ndarray). Since
+        instantiating a pandas DataFrame for each input is computationally more expensive, the specific warning is
+        manually suppressed in this Wrapper.
     """
 
-    def __init__(self, prediction_function: typing.Callable):
-        self.prediction_function = prediction_function
-
-    def __call__(self, x: typing.Union[dict, typing.Sequence]):
-        if isinstance(x, dict):
-            x_list = [list(x.values())]
-            y_pred = np.asarray([self.prediction_function(x_list)])
-        else:
-            y_pred = np.empty(shape=len(x))
-            for i in range(len(x)):
-                x_list = [list(x[i].values())]
-                y_pred[i] = self.prediction_function(x_list)
-        return y_pred
+    def __init__(self, prediction_function: typing.Callable, feature_names: typing.Optional[list] = None):
+        super().__init__(prediction_function, feature_names)
+
+    def __call__(self, x: typing.Union[typing.List[dict], dict]) -> typing.Union[dict, typing.List[dict]]:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message="X does not have valid feature names, but")
+            if isinstance(x, dict):
+                x_input = self.convert_1d_input_to_arr(x)
+                return self.convert_arr_output_to_dict(self._prediction_function(x_input))
+            x_input = self.convert_2d_input_to_arr(x)
+            y_predictions = self._prediction_function(x_input)
+            y_prediction = [self.convert_arr_output_to_dict(y_predictions[i]) for i in range(len(y_predictions))]
+            return y_prediction
diff --git a/ixai/utils/wrappers/torch.py b/ixai/utils/wrappers/torch.py
index daeae98..01c16fe 100644
--- a/ixai/utils/wrappers/torch.py
+++ b/ixai/utils/wrappers/torch.py
@@ -1,3 +1,5 @@
+import typing
+
 from ixai.utils.wrappers.base import Wrapper
 
 try:
@@ -6,6 +8,75 @@
     pass
 
 
+class TorchWrapper(Wrapper):
+    """Wrapper for torch link functions.
+
+    This wrapper turns any torch ouput tensor into a dict output and allows for dict inputs.
+
+    Examples:
+        Basic usage:
+        >>> torch_module: torch.nn.Module = torch_module
+        >>> module_device = 'cpu'
+        >>> model_function = TorchWrapper(torch_module, device=module_device)
+
+        For classifiers returning class_labels:
+        >>> def link_function_class(x):
+        >>>     return torch.argmax(torch.softmax(torch_module(x), dim=-1), dim=-1)
+        >>> model_function = TorchWrapper(link_function_class)
+
+        For classifiers returning probas:
+        >>> def link_function_probas(x):
+        >>>     return torch.softmax(torch_module(x), dim=-1)
+        >>> model_function = TorchWrapper(link_function_probas)
+
+        If the dict-inputs may be in a different orderings
+        >>> feature_orderings: list = ['feature_1', 'feature_2', 'feature_3']
+        >>> model_function = TorchWrapper(link_function_probas, feature_names=feature_orderings)
+    """
+
+    def __init__(
+            self,
+            link_function: typing.Union[torch.nn.Module, typing.Callable],
+            feature_names: typing.Optional[list] = None,
+            device: str = 'cpu'
+    ):
+        """
+        Args:
+            link_function (Union[torch.nn.Module, Callable]): The function linking from the model input to the output.
+            device: (str): Torch device flag where the model is running. Defaults to `'cpu'`.
+            feature_names (list[str], optional): A ordered list of feature names what features should be provided.
+        """
+        super().__init__(link_function, feature_names)
+        self._device: str = device
+
+    def __call__(self, x: typing.Union[typing.List[dict], dict]) -> typing.Union[dict, typing.List[dict]]:
+        """Runs the torch model with the given input dictionary.
+
+        Args:
+            x (Union[list[dict], dict]): Input features in the form of a dict (1d-input) mapping from feature names to
+            feature values or a list of such dicts.
+
+        Returns:
+            (Union[list[dict], dict]): The model output as a dictionary following river conventions.
+
+        Examples:
+            >>> model_function: typing.Callable = TorchWrapper(link_function_probas)
+            >>> input_dict = {'feature_1': 1, 'feature_2': 0}
+            >>> model_function(input_dict)
+            >>> {0: 0.45, 1: 0.05, 2: 0.5}
+        """
+        if isinstance(x, dict):
+            x_input = self.convert_1d_input_to_arr(x)
+            x_input = torch.tensor(x_input, device=self._device, dtype=torch.float32)
+            output = self._prediction_function(x_input).detach().cpu().numpy()
+            return self.convert_arr_output_to_dict(output)
+        x_input = self.convert_2d_input_to_arr(x)
+        x_input = torch.tensor(x_input, device=self._device, dtype=torch.float32)
+        y_predictions = self._prediction_function(x_input).detach().cpu().numpy()
+        y_prediction = [self.convert_arr_output_to_dict(y_predictions[i]) for i in range(len(y_predictions))]
+        return y_prediction
+
+
 class TorchSupervisedLearningWrapper(Wrapper):
     """Basic wrapper for torch classification models.
 
@@ -16,6 +87,7 @@ class TorchSupervisedLearningWrapper(Wrapper):
     """
 
     def __init__(self, model, optimizer, loss_function, n_classes: int = 1, class_labels: list[str] = None):
+        super().__init__(prediction_function=None, feature_names=None)
         self.model = model
         self.optimizer = optimizer
         self.loss_function = loss_function
diff --git a/ixai/visualization/__init__.py b/ixai/visualization/__init__.py
index 8877090..b875888 100644
--- a/ixai/visualization/__init__.py
+++ b/ixai/visualization/__init__.py
@@ -2,4 +2,4 @@
 
 __all__ = [
     "FeatureImportancePlotter",
-]
\ No newline at end of file
+]
diff --git a/ixai/visualization/plotting.py b/ixai/visualization/plotting.py
index 02d4816..81ea674 100644
--- a/ixai/visualization/plotting.py
+++ b/ixai/visualization/plotting.py
@@ -1,6 +1,6 @@
 import copy
 from abc import ABCMeta, abstractmethod
-from typing import Optional, Union, Sequence
+from typing import Optional, Union, Sequence, Dict, List
 
 import matplotlib.pyplot as plt
 
@@ -37,12 +37,14 @@ def plot(self, *args, **kwargs) -> None:
 class FeatureImportancePlotter(BasePlotter):
 
     def __init__(self,
-                 feature_names: Optional[list[str]] = None):
+                 feature_names: Optional[List[str]] = None):
         super().__init__()
         self.feature_names = feature_names
         self.y_data = {}
         self.x_data = {}
+        self.performance_data = {}
         self.stored_facets = set()
+        self._default_performance_line_name = 'perf'
 
     def _create_new_facet(self, facet_name: str):
         self.stored_facets.add(facet_name)
@@ -50,7 +52,7 @@ def _create_new_facet(self, facet_name: str):
         self.x_data[facet_name] = []
 
     def update(self,
-               importance_values: dict[str, Union[int, float]],
+               importance_values: Dict[str, Union[int, float]],
                facet_name: Optional[str] = None,
                timestep: Optional[Union[int, float]] = None):
         if timestep is None:
@@ -62,10 +64,15 @@ def update(self,
         self.y_data[facet_name].append(importance_values)
         self.x_data[facet_name].append(timestep)
 
+    def update_performance(self, performance_value: float, facet_name: str):
+        if facet_name not in self.performance_data:
+            self.performance_data[facet_name] = []
+        self.performance_data[facet_name].append({'perf': performance_value})
+
     def plot(
             self,
             figsize: Optional[tuple[int, int]] = None,
-            model_performances: Optional[dict[str, Sequence]] = None,
+            model_performances: Optional[Dict[str, Sequence]] = None,
             performance_kw: Optional[dict] = None,
             save_name: Optional[str] = None,
             **plot_kw,
@@ -75,13 +82,22 @@ def plot(
             plot_kw['names_to_highlight'] = self.feature_names
         if 'line_names' not in plot_kw:
             plot_kw['line_names'] = self.feature_names
-
-        if model_performances is not None:
+        if 'x_label' not in plot_kw:
+            plot_kw['x_label'] = 'Samples'
+        if 'h_lines' not in plot_kw:
+            plot_kw['h_lines'] = [{'y': 0., 'ls': '--', 'c': 'grey', 'linewidth': 1}]
+        if 'y_label' not in plot_kw:
+            plot_kw['y_label'] = 'Feature Importance Values'
+        if figsize is None:
+            figsize = (5, 10)
+
+        if model_performances is not None or len(self.performance_data) > 0:
             fig, (performance_axis, fi_axis) = plt.subplots(
                 nrows=2, ncols=1, sharex='col', sharey='row',
                 figsize=figsize, gridspec_kw={'height_ratios': [1, 4]}
             )
             plt.subplots_adjust(hspace=0.000, wspace=0.000)
+
             title = None
             if 'title' in plot_kw:
                 title = copy.copy(plot_kw['title'])
@@ -90,6 +106,15 @@ def plot(
             if 'v_lines' in plot_kw:
                 v_lines = plot_kw['v_lines']
             performance_kw = {} if performance_kw is None else performance_kw
+            if model_performances is None:
+                model_performances = self.performance_data
+            if 'line_names' not in performance_kw:
+                performance_kw['line_names'] = [self._default_performance_line_name]
+            if 'color_list' not in performance_kw:
+                performance_kw['color_list'] = ["red", "black"]
+            if 'y_label' not in performance_kw:
+                performance_kw['y_label'] = "Perf."
+
             performance_axis = plot_multi_line_graph(
                 axis=performance_axis,
                 y_data=model_performances,


Test patch:
diff --git a/tests/test_storage.py b/tests/test_storage.py
index ac4e477..7f2daf2 100644
--- a/tests/test_storage.py
+++ b/tests/test_storage.py
@@ -1,23 +1,45 @@
 import pytest
+import numpy as np
+from river.tree import HoeffdingAdaptiveTreeClassifier, HoeffdingAdaptiveTreeRegressor
+
 from ixai.storage import (BatchStorage, IntervalStorage,
                           SequenceStorage,
                           UniformReservoirStorage,
-                          GeometricReservoirStorage)
+                          GeometricReservoirStorage, TreeStorage)
 
 
 @pytest.fixture
-def dummy_stream():
-    # TODO - make stream an iterator
+def dummy_stream_small():
     stream = []
     for i in range(10):
         stream.append(({'t': i}, i))
     return stream
 
 
+@pytest.fixture
+def dummy_cat_stream():
+    np.random.seed(42)
+    feature_names = ['cat_1', 'cat_2', 'num_1']
+    cat_feature_names = ['cat_1', 'cat_2']
+    num_feature_names = ['num_1']
+    x = np.zeros(shape=(1000, 3))
+    x[:, 2] = 100.
+    x[:250, 0] = 1
+    x[250:500, 0] = 2
+    x[500:750, 0] = 3
+    x[750:, 0] = 4
+    x[x[:, 0] >= 3, 1] = 1
+    np.random.shuffle(x)
+    stream = []
+    for t in range(len(x)):
+        stream.append({feature_names[i]: x[t][i] for i in range(len(feature_names))})
+    return stream, feature_names, cat_feature_names, num_feature_names
+
+
 @pytest.mark.parametrize("store_targets", [True, False])
-def test_batch_storage(dummy_stream, store_targets):
+def test_batch_storage(dummy_stream_small, store_targets):
     storage = BatchStorage(store_targets=store_targets)
-    for x_i, y_i in dummy_stream:
+    for x_i, y_i in dummy_stream_small:
         storage.update(x_i, y_i)
     assert len(storage) == 10
     if store_targets:
@@ -28,9 +50,9 @@ def test_batch_storage(dummy_stream, store_targets):
 
 @pytest.mark.parametrize("store_targets", [True, False])
 @pytest.mark.parametrize("size", [5, 8, 1])
-def test_interval_storage(dummy_stream, store_targets, size):
+def test_interval_storage(dummy_stream_small, store_targets, size):
     storage = IntervalStorage(store_targets=store_targets, size=size)
-    for x_i, y_i in dummy_stream:
+    for x_i, y_i in dummy_stream_small:
         storage.update(x_i, y_i)
     assert len(storage) == size
     assert storage.get_data()[0][size-1]['t'] == 9
@@ -44,9 +66,9 @@ def test_interval_storage(dummy_stream, store_targets, size):
 
 
 @pytest.mark.parametrize("store_targets", [True, False])
-def test_sequence_storage(dummy_stream, store_targets):
+def test_sequence_storage(dummy_stream_small, store_targets):
     storage = SequenceStorage(store_targets=store_targets)
-    for x_i, y_i in dummy_stream:
+    for x_i, y_i in dummy_stream_small:
         storage.update(x_i, y_i)
     assert len(storage) == 1
     assert storage.get_data()[0][0]['t'] == 9
@@ -59,10 +81,10 @@ def test_sequence_storage(dummy_stream, store_targets):
 
 @pytest.mark.parametrize("store_targets", [True, False])
 @pytest.mark.parametrize("size", [3, 5])
-def test_uniform_reservoir_storage(dummy_stream, store_targets, size):
+def test_uniform_reservoir_storage(dummy_stream_small, store_targets, size):
     storage = UniformReservoirStorage(store_targets=store_targets,
                                       size=size)
-    for x_i, y_i in dummy_stream:
+    for x_i, y_i in dummy_stream_small:
         storage.update(x_i, y_i)
     assert len(storage) == size
     if store_targets:
@@ -73,13 +95,50 @@ def test_uniform_reservoir_storage(dummy_stream, store_targets, size):
 
 @pytest.mark.parametrize("store_targets", [True, False])
 @pytest.mark.parametrize("size", [3, 5])
-def test_geometric_reservoir_storage(dummy_stream, store_targets, size):
+def test_geometric_reservoir_storage(dummy_stream_small, store_targets, size):
     storage = GeometricReservoirStorage(store_targets=store_targets,
                                         size=size)
-    for x_i, y_i in dummy_stream:
+    for x_i, y_i in dummy_stream_small:
         storage.update(x_i, y_i)
     assert len(storage) == size
     if store_targets:
         assert len(storage.get_data()[1]) == size
     else:
         assert len(storage.get_data()[1]) == 0
+
+
+def test_tree_storage(dummy_cat_stream):
+    stream, feature_names, cat_feature_names, num_feature_names = dummy_cat_stream
+    storage = TreeStorage(cat_feature_names=cat_feature_names,
+                          num_feature_names=num_feature_names,
+                          max_depth=3,
+                          leaf_reservoir_length=100,
+                          grace_period=10,
+                          seed=42)
+    assert len(storage) == 0
+
+    for x_i in stream:
+        storage.update(x=x_i)
+
+    assert len(storage.feature_names) == 3
+    assert len(storage.cat_feature_names) == 2
+    assert len(storage.num_feature_names) == 1
+    assert len(storage.data_reservoirs) == 3
+    assert len(storage.performances) == 3
+    assert storage._leaf_reservoir_length == 100
+    assert len(storage._storage_x) == 3
+    assert len(storage) == 1000
+
+    for feature_name in feature_names:
+        feature_model, feature_type = storage(feature_name)
+        if feature_type == 'cat':
+            assert type(feature_model) == HoeffdingAdaptiveTreeClassifier
+        else:
+            assert type(feature_model) == HoeffdingAdaptiveTreeRegressor
+        data_reservoirs = storage.data_reservoirs[feature_name]
+        assert len(data_reservoirs) > 0
+
+    try:
+        storage('cat_99')
+    except ValueError:
+        assert True
diff --git a/tests/test_tracker.py b/tests/test_tracker.py
new file mode 100644
index 0000000..7d76aa5
--- /dev/null
+++ b/tests/test_tracker.py
@@ -0,0 +1,31 @@
+import pytest
+import numpy as np
+
+from ixai.utils.tracker import WelfordTracker, SlidingWindowTracker, MultiValueTracker, ExponentialSmoothingTracker
+
+dummy_value_stream_1 = [i for i in range(1, 1001)]
+dummy_value_stream_2 = [0 for i in range(1, 1001)]
+
+
+@pytest.mark.parametrize("parameters", [(0.01, 901.0042739534927), (1., 1000.), (0., 0.)])
+def test_tracker_exponential_smoothing(parameters):
+    alpha, result_1 = parameters
+    tracker = ExponentialSmoothingTracker(alpha=alpha)
+    for value in dummy_value_stream_1:
+        tracker.update(value)
+    assert tracker.get() == pytest.approx(result_1)
+
+
+@pytest.mark.parametrize("data_stream", [dummy_value_stream_1, dummy_value_stream_2])
+def test_tracker_welford(data_stream):
+    values = data_stream
+    mean = np.mean(values)
+    std = np.std(values)
+    var = np.var(values)
+    tracker = WelfordTracker()
+    for value in data_stream:
+        tracker.update(value)
+    assert tracker.get() == pytest.approx(mean)
+    assert tracker.mean == pytest.approx(mean)
+    assert tracker.var == pytest.approx(var)
+    assert tracker.std == pytest.approx(std)
diff --git a/tests/test_wrappers.py b/tests/test_wrappers.py
new file mode 100644
index 0000000..42d3dc6
--- /dev/null
+++ b/tests/test_wrappers.py
@@ -0,0 +1,182 @@
+import numpy as np
+import pytest
+import torch
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+from sklearn.utils import shuffle
+from river.tree import HoeffdingAdaptiveTreeClassifier, HoeffdingAdaptiveTreeRegressor
+from river.metrics import Accuracy, MSE, MAE, CrossEntropy
+
+from ixai.utils.wrappers.river import RiverMetricToLossFunction
+from ixai.utils.wrappers import TorchWrapper, SklearnWrapper, RiverWrapper
+
+
+def dummy_torch_model_argmax(x: torch.Tensor):
+    x_input = torch.zeros(size=(1, 5), dtype=torch.float32, device='cpu')
+    x_input[:, 3] = 1.
+    return torch.argmax(x_input)
+
+
+def dummy_torch_model_probas(x: torch.Tensor):
+    x_input = torch.zeros(size=(1, 5), dtype=torch.float32, device='cpu')
+    x_input[:, 3] = 1.
+    return torch.softmax(x_input, dim=-1)
+
+
+def dummy_data(classification=True):
+    x = np.zeros(shape=(100, 4))
+    x[0:50, 0] = 1.
+    x[:, 1] = 1.
+    x[50:, 2] = 1.
+    y = np.zeros(shape=(100,))
+    if classification:
+        y[x[:, 0] == 1] = 1
+    else:
+        y[x[:, 0] == 1] = 100.
+    x, y = shuffle(x, y, random_state=42)
+    return x, y
+
+
+@pytest.mark.parametrize("model_function_id", ['argmax', 'probas'])
+def test_torch_wrapper(model_function_id):
+    test_input = {0: 0, 1: 0.5, 2: 1, 3: 1.5}
+    if model_function_id == 'argmax':
+        model_function = TorchWrapper(dummy_torch_model_argmax)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 1
+        assert output == {'output': 3.0}
+    else:
+        model_function = TorchWrapper(dummy_torch_model_probas)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 5
+        assert output[3] == pytest.approx(0.40460968)
+
+
+@pytest.mark.parametrize(
+    "sklearn_model",
+    [('dtc', DecisionTreeClassifier(max_depth=2, random_state=42)),
+     ('dtr', DecisionTreeRegressor(max_depth=2, random_state=42))]
+)
+def test_sklearn_wrapper(sklearn_model):
+    model_function_id, sklearn_model = sklearn_model
+    test_input = {0: 1, 1: 0, 2: 3, 3: 0}
+    feature_names_correct = [0, 1, 2, 3]
+    feature_names_half = [0, 1]
+    test_input_wrong_order = {1: 0, 3: 0, 2: 3, 0: 1}
+    if model_function_id == 'dtc':
+        x, y = dummy_data(classification=True)
+        model: DecisionTreeClassifier = sklearn_model
+        model.fit(x, y)
+        model_function = SklearnWrapper(model.predict)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 1
+        assert output == {'output': 1.0}
+        model_function = SklearnWrapper(model.predict_proba)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 2
+        assert output == {0: 0.0, 1: 1.0}
+        model_function = SklearnWrapper(model.predict_proba)
+        output = model_function(test_input_wrong_order)
+        assert output == {0: 1.0, 1: 0.0}
+        converted_input = model_function.convert_1d_input_to_arr(test_input_wrong_order)
+        assert (converted_input == np.asarray([[0, 0, 3, 1]])).all()
+        converted_input = model_function.convert_2d_input_to_arr([test_input, test_input])
+        assert (converted_input == np.asarray([[1, 0, 3, 0], [1, 0, 3, 0]])).all()
+        model_function = SklearnWrapper(model.predict_proba, feature_names=feature_names_correct)
+        converted_input = model_function.convert_1d_input_to_arr(test_input_wrong_order)
+        assert (converted_input == np.asarray([[1, 0, 3, 0]])).all()
+        model_function = SklearnWrapper(model.predict_proba, feature_names=feature_names_half)
+        converted_input = model_function.convert_1d_input_to_arr(test_input_wrong_order)
+        assert (converted_input == np.asarray([[1, 0]])).all()
+    else:  # dtr
+        x, y = dummy_data(classification=False)
+        model: DecisionTreeRegressor = sklearn_model
+        model.fit(x, y)
+        model_function = SklearnWrapper(model.predict)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 1
+        assert output == {'output': 100.}
+
+
+@pytest.mark.parametrize(
+    "river_model",
+    [('adtc', HoeffdingAdaptiveTreeClassifier(max_depth=2, seed=42)),
+     ('adtr', HoeffdingAdaptiveTreeRegressor(max_depth=2, seed=42))]
+)
+def test_river_wrapper(river_model):
+    model_function_id, river_model = river_model
+    test_input = {0: 1, 1: 0, 2: 3, 3: 0}
+    test_input_wrong_order = {1: 0, 3: 0, 2: 3, 0: 1}
+
+    x, y = dummy_data(classification=True)
+    for n in range(len(x)):
+        x_i, y_i = x[n], y[n]
+        x_i = {i: x_i[i] for i in range(len(x_i))}
+        river_model.learn_one(x=x_i, y=y_i)
+
+    if model_function_id == 'adtc':
+        model: HoeffdingAdaptiveTreeClassifier = river_model
+        x, y = dummy_data(classification=True)
+        for n in range(len(x)):
+            x_i, y_i = x[n], y[n]
+            x_i = {i: x_i[i] for i in range(len(x_i))}
+            model.learn_one(x=x_i, y=y_i)
+        model_function = RiverWrapper(model.predict_one)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 1
+        assert output == {'output': 1.0}
+        model_function = RiverWrapper(model.predict_proba_one)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 2
+        assert output == {0.0: 0.4734982332155477, 1.0: 0.5265017667844523}
+        model_function = RiverWrapper(model.predict_proba_one)
+        output = model_function(test_input_wrong_order)
+        assert output == {0.0: 0.4734982332155477, 1.0: 0.5265017667844523}
+    else:  # adtr
+        x, y = dummy_data(classification=False)
+        model: HoeffdingAdaptiveTreeRegressor = river_model
+        model_function = RiverWrapper(model.predict_one)
+        output = model_function(test_input)
+        assert type(output) == dict
+        assert len(output) == 1
+        assert list(output.keys())[0] == 'output'
+
+
+@pytest.mark.parametrize("river_metric", [('accuracy', Accuracy()), ('mse', MSE()), ('mae', MAE())])
+def test_single_value_river_metric(river_metric):
+    river_metric_id, river_metric = river_metric
+    loss_function = RiverMetricToLossFunction(river_metric=river_metric, dict_input_metric=False)
+    loss = loss_function(y_true=1, y_prediction={'output': 1})
+    if river_metric_id == 'accuracy':
+        assert loss == -1.0
+    else:
+        assert loss == 0
+    loss = loss_function(y_true=0, y_prediction={'output': 1})
+    if river_metric_id == 'accuracy':
+        assert loss == 0
+    else:
+        assert loss == 1
+    try:
+        loss_function(y_true=1, y_prediction={'class_0': 0.2, 'class_1': 0.8})
+        assert False
+    except Exception:
+        assert True
+
+
+@pytest.mark.parametrize("river_metric", [('cross_entropy', CrossEntropy())])
+def test_dict_value_river_metric(river_metric):
+    river_metric_id, river_metric = river_metric
+    loss_function = RiverMetricToLossFunction(river_metric=river_metric, dict_input_metric=True)
+    loss = loss_function(y_true='class_0', y_prediction={'class_0': 1.0, 'class_1': 0.0})
+    assert loss == pytest.approx(0)
+    _ = loss_function(y_true='class_1', y_prediction={'class_0': 0.2, 'class_1': 0.8})
+    try:
+        _ = loss_function(y_true='class_1', y_prediction=0.8)
+    except AttributeError:
+        assert True