Repository: scikit-mine/scikit-mine (language: python)

Issue:
Return type of SLIM
SLIM algorithm returns a pandas Series but all other algorithm from scikit-mine return a pandas DataFrame.

As pandas DataFrame are more friendly to use than pandas Series it could be interesting to switch the return type of SLIM to a pandas DataFrame. It will improve the consistency of scikit-mine.
Question about parameter k of SLIM
#### Describe the issue linked to the documentation

The parameter k is described as the number of non-singleton itemsets to mine. 
While this is correct in the code, it is not very clear for the user of what is its interest, making the setting of this parameter tricky. 

#### Suggest a potential alternative/fix

In practice, the real use of k here is to control the number of iterations of SLIM. 
Putting higher values of k helps SLIM to test out more candidates, and thus to further refine the discovered itemsets. It will also allow SLIM to make more combinations of smaller itemsets to try and make bigger itemsets. 

In some ways, tol is also just a way to reduce execution time (at the cost of the quality of results). tol is not clean either as the 0.5 value has no real meaning (it depends too much on the dataset at hand).

I see two possible solutions:
  - small change: modify the behavior of k to make it a number of iterations, and state in doc that more iterations = possibly a better code table
  - more involved change: remove k and tol and replace them by a time budget, that could be set by default at 30 seconds. This requires more work, but has the advantage of having a clear semantics for the user, and also to let the algorithm perform unhindered until the time out. 



Discussion / hints:
Hi @quaaasaaar , thanks for raising this issue :)

I guess returning a dataframe with two columns, namely `itemset` and `usage`, would fit your needs, am I right ?

NB: there are also concerns about using discovered patterns (here the `itemset` column) as an index, so one could "query" the resulting dataframe to obtain information that corresponds to a specific pattern
Such a dataframe would be perfect for my needs. 
@quaaasaaar would you be OK to raise a PR for this ?
Hi there,

## Some context 
the k parameter is here to control the "dimension" of the outputted codetable. In discovery mode, we just control the number of patterns returns via `.discover()`, but if we use it as a feature extractor (for machine learning pipelines for example), we have to control the number of patterns themselves (eq to the dimension of the resulting matrix return by `.transform()`), and not the number of iteration.
The discovery mode is the one you are using, documented [here](https://scikit-mine.github.io/scikit-mine/reference/itemsets.html#slim)
The feature extractor is documented [here](https://scikit-mine.github.io/scikit-mine/reference/feature_extraction.html#slimvectorizer)

## To answer your question
### k parameter
I agree we could give control over the number of iteration. For compatibility with sklearn however, I think this param should be renamed to `n_iter` (see the sklearn [KMeans](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html) for example).
The only disadvantage is that we cannot guarantee a number of patterns to be returned to our user by `.discover()` (or we could pass this `k` parameter to `.discover` itself)

 In any case we should keep the `k` parameter as it is for the SLIMVectorizer class, which you are not using :)

### Time budget
IMO setting a time budget is not a good methodology if we strive for reproducible research. CPU time and memory consumption are metrics we want to optimise when setting specific parameters, not the other way around. In addition to that, this would make possible running the same method with the same parameters (the time budget) and obtaining different models on different physical environments (eg. machines or simply a different BLAS version). 

If users come to us for debugging, we will struggle to address the results they share with regard to a specific parameter setting.


Fix patch:
diff --git a/.coveragerc b/.coveragerc
index 312d573f..5559f69d 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -23,6 +23,7 @@ exclude_lines =
     raise NotImplementedError
     except ImportError
     if self.verbose
+    if verbose
     _get_tags
     warnings
     return self
diff --git a/.github/check_sklearn_compat.py b/.github/check_sklearn_compat.py
index d6a9be55..19436e6e 100644
--- a/.github/check_sklearn_compat.py
+++ b/.github/check_sklearn_compat.py
@@ -13,10 +13,7 @@
 import skmine.itemsets
 import skmine.preprocessing
 
-MODULES = [
-    skmine.itemsets,
-    skmine.preprocessing,
-]
+MODULES = [skmine.itemsets, skmine.preprocessing,]
 
 EXCLUDED_CHECKS = [
     "check_no_attributes_set_in_init",
@@ -47,12 +44,17 @@ def verify(e):
     ret_code = 0
     for module in MODULES:
         clsmembers = inspect.getmembers(module, inspect.isclass)
+        print('Modules ', module, '\n clsmembers ', clsmembers)
+
         estimators = filter(verify, clsmembers)
+        # print("estimators", list(estimators))
         for est_name, est in estimators:
             # from sklearn 0.23 check_estimator takes an instance as input
             obj = est() if sklearn.__version__[:4] >= "0.23" else est
             checks = check_estimator(obj, generate_only=True)
+            print("obj", type(obj))
             for arg, check in checks:
+                # print("check ", check.func)
                 check_name = check.func.__name__  # unwrap partial function
                 if check_name in EXCLUDED_CHECKS:
                     continue
diff --git a/.github/mdl_reconstruct/periodic.py b/.github/mdl_reconstruct/periodic.py
index 579db5f0..18f3f917 100644
--- a/.github/mdl_reconstruct/periodic.py
+++ b/.github/mdl_reconstruct/periodic.py
@@ -7,16 +7,11 @@
 from skmine.datasets.periodic import deduplicate
 
 if __name__ == "__main__":
-    Ds = [
-        fetch_health_app(),
-        fetch_canadian_tv(),
-    ]
+    Ds = [fetch_health_app(), fetch_canadian_tv(), ]
 
     for D in map(deduplicate, Ds):
         miner = PeriodicCycleMiner(keep_residuals=True)
-        print(
-            f"RUN CycleMiner RECONSTRUCTION ON {D.name} WITH PARAMS {miner.get_params()}"
-        )
+        print(f"RUN CycleMiner RECONSTRUCTION ON {D.name} WITH PARAMS {miner.get_params()}")
         miner.fit(D)
         r_D = miner.reconstruct()
         pandas.testing.assert_series_equal(D, r_D, check_names=False, check_dtype=False)
diff --git a/.github/mdl_reconstruct/slim.py b/.github/mdl_reconstruct/slim.py
index d9686e92..5fbf1605 100644
--- a/.github/mdl_reconstruct/slim.py
+++ b/.github/mdl_reconstruct/slim.py
@@ -15,12 +15,10 @@
 if __name__ == "__main__":
     Ds = [fetch_any(k) for k in ("chess.dat", "connect.dat", "mushroom.dat")]
 
-    miners = [SLIM(pruning=False, k=100), SLIM(pruning=True, k=100)]
+    miners = [SLIM(pruning=False, max_time=5), SLIM(pruning=True, max_time=5)]
     for D in Ds:
         for miner in miners:
-            print(
-                f"RUN {type(miner)} RECONSTRUCTION ON {D.name} WITH PARAMS {miner.get_params()}"
-            )
+            print(f"RUN {type(miner)} RECONSTRUCTION ON {D.name} WITH PARAMS {miner.get_params()}")
             start = time.time()
             miner.fit(D)
             print(f"fitted in {time.time() - start} seconds")
diff --git a/.github/workflows/ci-docs.yml b/.github/workflows/ci-docs.yml
index 85d0eb90..e4a919f2 100644
--- a/.github/workflows/ci-docs.yml
+++ b/.github/workflows/ci-docs.yml
@@ -1,8 +1,8 @@
 name: CI
 on:
   push:
-    tags:
-      - "v*"
+    branches:
+      - master
 jobs:
   docs:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/mdl_reconstruct.yml b/.github/workflows/mdl_reconstruct.yml
index 74653fc4..a5832275 100644
--- a/.github/workflows/mdl_reconstruct.yml
+++ b/.github/workflows/mdl_reconstruct.yml
@@ -8,7 +8,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@master
         with:
-          python-version: 3.7
+          python-version: 3.x
       - name: Install external dependencies
         run: pip install -U numpy
       - name: Install project
diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml
index aa8265bb..cb984cb3 100644
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -1,8 +1,8 @@
 name: publish on pypi
 on:
   push:
-    tags:
-      - "v*"
+    branches:
+      - master
 jobs:
   run:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/sklearn_compat.yml b/.github/workflows/sklearn_compat.yml
index 0c4fa6cb..98ca6d2e 100644
--- a/.github/workflows/sklearn_compat.yml
+++ b/.github/workflows/sklearn_compat.yml
@@ -8,7 +8,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@master
         with:
-          python-version: 3.7
+          python-version: 3.x
       - name: Install external dependencies
         run: pip install scikit-learn
       - name: check compatibility
diff --git a/LICENSE b/LICENSE
index 3bf834d9..48860f02 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2020, scikit-mine
+Copyright (c) 2022, scikit-mine
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/docs/HISTORY.rst b/docs/HISTORY.rst
index 172b0d5d..c2e018a7 100644
--- a/docs/HISTORY.rst
+++ b/docs/HISTORY.rst
@@ -2,6 +2,16 @@
 History
 =======
 
+
+0.0.8 (2022-11-28)
+------------------
+* Support python up to 3.11
+* add itemset length option for LCM
+
+0.0.7 (2022-11-04)
+------------------
+* Fix and improve LCM
+
 0.0.6 (2021-05-12)
 ------------------
 * SLIM has a k-parameters
diff --git a/docs/conf.py b/docs/conf.py
index 902ccbf3..750b8aa2 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -20,8 +20,8 @@
 
 # -- Project information -----------------------------------------------------
 project = 'scikit-mine'
-copyright = '2020, Rémi Adon'
-author = 'Rémi Adon'
+copyright = '2022, scikit-mine team'
+author = 'scikit-mine team'
 
 # The full version
 parsed_version = parse(skmine.__version__)
@@ -107,9 +107,7 @@
 
 html_theme = 'sphinx_rtd_theme'
 html_logo = 'skmine_logo.png'
-html_theme_options = {
-    'logo_only': True
-}
+html_theme_options = {'logo_only': True}
 html_scaled_image_link = False
 
 nbsphinx_execute = 'always'
diff --git a/docs/reference/itemsets.rst b/docs/reference/itemsets.rst
index 0e1224cf..c768af64 100644
--- a/docs/reference/itemsets.rst
+++ b/docs/reference/itemsets.rst
@@ -10,6 +10,9 @@ SLIM
 -------
 .. autoclass:: skmine.itemsets.SLIM
 
+SLIM Classifier
+-------
+.. autoclass:: skmine.itemsets.slim_classifier.SlimClassifier
 
 LCM
 -------
diff --git a/docs/tutorials/SLIMVectorizer.ipynb b/docs/tutorials/SLIMVectorizer.ipynb
index 5ccf2bf8..5b209302 100644
--- a/docs/tutorials/SLIMVectorizer.ipynb
+++ b/docs/tutorials/SLIMVectorizer.ipynb
@@ -9,16 +9,47 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 231,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'SLIMVectorizer' from 'skmine.preprocessing' (/home/tbetton/Documents/F-WIN/scikit-mine/skmine/preprocessing/__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn [13], line 6\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpreprocessing\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m FunctionTransformer\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msklearn\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmodel_selection\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m train_test_split\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mskmine\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpreprocessing\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m SLIMVectorizer\n",
+      "\u001b[0;31mImportError\u001b[0m: cannot import name 'SLIMVectorizer' from 'skmine.preprocessing' (/home/tbetton/Documents/F-WIN/scikit-mine/skmine/preprocessing/__init__.py)"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.linear_model import SGDClassifier\n",
     "from sklearn.pipeline import Pipeline\n",
     "from sklearn.preprocessing import FunctionTransformer\n",
     "from sklearn.model_selection import train_test_split\n",
     "\n",
-    "from skmine.preprocessing import SLIMTransformer"
+    "from skmine.preprocessing import SLIMVectorizer"
    ]
   },
   {
@@ -758,9 +789,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.8.1 64-bit ('skmine': conda)",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "python38164bitskmineconda3789c8cb22f842768473342c0ee32d2f"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -772,7 +803,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.10"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/Untitled.ipynb b/docs/tutorials/Untitled.ipynb
index d83b1445..13b3fd96 100644
--- a/docs/tutorials/Untitled.ipynb
+++ b/docs/tutorials/Untitled.ipynb
@@ -522,9 +522,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.8.1 64-bit ('skmine': conda)",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "python38164bitskmineconda3789c8cb22f842768473342c0ee32d2f"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -536,7 +536,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.10"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/callbacks/callbacks.ipynb b/docs/tutorials/callbacks/callbacks.ipynb
index df89c75d..0dd441ae 100644
--- a/docs/tutorials/callbacks/callbacks.ipynb
+++ b/docs/tutorials/callbacks/callbacks.ipynb
@@ -13,7 +13,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -33,11 +52,11 @@
     {
      "data": {
       "text/plain": [
-       "0    [3, 9, 13, 23, 25, 34, 36, 38, 40, 52, 54, 59,...\n",
-       "1    [3, 9, 14, 23, 26, 34, 36, 39, 40, 52, 55, 59,...\n",
-       "2    [4, 9, 15, 23, 27, 34, 36, 39, 41, 52, 55, 59,...\n",
-       "3    [3, 10, 15, 23, 25, 34, 36, 38, 41, 52, 54, 59...\n",
-       "4    [3, 9, 16, 24, 28, 34, 37, 39, 40, 53, 54, 59,...\n",
+       "0    [1, 3, 9, 13, 23, 25, 34, 36, 38, 40, 52, 54, ...\n",
+       "1    [2, 3, 9, 14, 23, 26, 34, 36, 39, 40, 52, 55, ...\n",
+       "2    [2, 4, 9, 15, 23, 27, 34, 36, 39, 41, 52, 55, ...\n",
+       "3    [1, 3, 10, 15, 23, 25, 34, 36, 38, 41, 52, 54,...\n",
+       "4    [2, 3, 9, 16, 24, 28, 34, 37, 39, 40, 53, 54, ...\n",
        "Name: mushroom, dtype: object"
       ]
      },
@@ -57,8 +76,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# set n_iter_no_change to a high value so learning takes longer\n",
-    "slim = SLIM(n_iter_no_change=200)"
+    "# set max_time to a limit value so that the dataset compression is not too long\n",
+    "slim = SLIM(max_time=30)"
    ]
   },
   {
@@ -122,8 +141,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 3.75 s, sys: 36.7 ms, total: 3.79 s\n",
-      "Wall time: 3.8 s\n"
+      "CPU times: user 30.1 s, sys: 112 ms, total: 30.2 s\n",
+      "Wall time: 30.1 s\n"
      ]
     },
     {
@@ -147,61 +166,86 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
+       "      <th>itemset</th>\n",
        "      <th>usage</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>(36, 39, 116, 23, 56, 28, 93)</th>\n",
-       "      <td>[305, 335, 384, 449, 632, 684, 873, 890, 917, ...</td>\n",
+       "      <th>0</th>\n",
+       "      <td>[2, 23, 28, 34, 36, 39, 53, 56, 59, 63, 85, 86...</td>\n",
+       "      <td>864</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(34, 85, 86, 90, 59, 63)</th>\n",
-       "      <td>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,...</td>\n",
+       "      <th>1</th>\n",
+       "      <td>[2, 23, 28, 34, 36, 39, 53, 56, 59, 63, 85, 86...</td>\n",
+       "      <td>864</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(110, 53, 102, 24, 58, 94)</th>\n",
-       "      <td>[4023, 4100, 4104, 4196, 4200, 4329, 4376, 442...</td>\n",
+       "      <th>2</th>\n",
+       "      <td>[1, 24, 29, 34, 36, 39, 52, 56, 61, 66, 85, 86...</td>\n",
+       "      <td>648</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(66, 61, 36, 101, 39, 29)</th>\n",
-       "      <td>[1816, 2128, 2178, 2238, 2385, 2443, 2533, 253...</td>\n",
+       "      <th>3</th>\n",
+       "      <td>[1, 24, 29, 34, 36, 39, 52, 56, 61, 66, 85, 86...</td>\n",
+       "      <td>648</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(67, 36, 39, 23, 76, 93)</th>\n",
-       "      <td>[1, 2, 5, 6, 7, 9, 10, 11, 12, 20, 22, 23, 24,...</td>\n",
+       "      <th>4</th>\n",
+       "      <td>[1, 24, 34, 36, 38, 48, 53, 58, 59, 63, 85, 86...</td>\n",
+       "      <td>432</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
        "      <td>...</td>\n",
+       "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(49)</th>\n",
-       "      <td>[5153, 5376, 5477, 5526, 5548, 5571, 5593, 560...</td>\n",
+       "      <th>157</th>\n",
+       "      <td>[22]</td>\n",
+       "      <td>16</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(82)</th>\n",
-       "      <td>[4494, 5131, 5154, 5162, 5239, 5241, 5259, 526...</td>\n",
+       "      <th>158</th>\n",
+       "      <td>[75]</td>\n",
+       "      <td>8</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(22)</th>\n",
-       "      <td>[4326, 4898, 5284, 5302, 5351, 5430, 5497, 552...</td>\n",
+       "      <th>159</th>\n",
+       "      <td>[89]</td>\n",
+       "      <td>8</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(8)</th>\n",
-       "      <td>[5126, 5508, 7401, 7706]</td>\n",
+       "      <th>160</th>\n",
+       "      <td>[8]</td>\n",
+       "      <td>4</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(12)</th>\n",
-       "      <td>[5107, 5126, 5128, 5717]</td>\n",
+       "      <th>161</th>\n",
+       "      <td>[12]</td>\n",
+       "      <td>4</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
-       "<p>236 rows × 1 columns</p>\n",
+       "<p>162 rows × 2 columns</p>\n",
        "</div>"
       ],
       "text/plain": [
-       "<skmine.itemsets.slim.SLIM at 0x12208cb00>"
+       "                                               itemset  usage\n",
+       "0    [2, 23, 28, 34, 36, 39, 53, 56, 59, 63, 85, 86...    864\n",
+       "1    [2, 23, 28, 34, 36, 39, 53, 56, 59, 63, 85, 86...    864\n",
+       "2    [1, 24, 29, 34, 36, 39, 52, 56, 61, 66, 85, 86...    648\n",
+       "3    [1, 24, 29, 34, 36, 39, 52, 56, 61, 66, 85, 86...    648\n",
+       "4    [1, 24, 34, 36, 38, 48, 53, 58, 59, 63, 85, 86...    432\n",
+       "..                                                 ...    ...\n",
+       "157                                               [22]     16\n",
+       "158                                               [75]      8\n",
+       "159                                               [89]      8\n",
+       "160                                                [8]      4\n",
+       "161                                               [12]      4\n",
+       "\n",
+       "[162 rows x 2 columns]"
       ]
      },
      "execution_count": 6,
@@ -210,7 +254,7 @@
     }
    ],
    "source": [
-    "%time slim.fit(mushroom)"
+    "%time slim.fit(mushroom).discover()"
    ]
   },
   {
@@ -234,22 +278,18 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "df = pd.DataFrame(sizes, columns=['data_size', 'model_size'])\n",
-    "ax = df.data_size.plot()\n",
-    "for s in np.cumsum(candidate_sizes):\n",
-    "    ax.axvline(s, color='r')"
+    "ax = df.data_size.plot()"
    ]
   },
   {
@@ -257,7 +297,7 @@
    "metadata": {},
    "source": [
     "------------------\n",
-    "And here is how the model size goes up"
+    "Here is how the model size goes up"
    ]
   },
   {
@@ -268,7 +308,7 @@
     {
      "data": {
       "text/plain": [
-       "<AxesSubplot:>"
+       "<AxesSubplot: >"
       ]
      },
      "execution_count": 8,
@@ -277,25 +317,89 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "df.model_size.plot()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "And finally the evolution of the total size of our dataset after compression via SLIM following MDL"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot: >"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df['total_size'] = df['model_size']+df['data_size']\n",
+    "df.total_size.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From the sizes saved in df, we can determine the compression ratio of our dataset after applying SLIM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "35.97993591669107"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "compression_percentage = df['total_size'].iloc[-1]/df['total_size'].iloc[0]*100\n",
+    "compression_percentage"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -309,7 +413,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.12"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/datasets/data.dat b/docs/tutorials/datasets/data.dat
new file mode 100644
index 00000000..62300daa
--- /dev/null
+++ b/docs/tutorials/datasets/data.dat
@@ -0,0 +1,3 @@
+0 1 2
+0 1
+1 2 3
\ No newline at end of file
diff --git a/docs/tutorials/datasets/fetch_fimi_datasets.ipynb b/docs/tutorials/datasets/fetch_fimi_datasets.ipynb
index c93a871a..bde24f28 100644
--- a/docs/tutorials/datasets/fetch_fimi_datasets.ipynb
+++ b/docs/tutorials/datasets/fetch_fimi_datasets.ipynb
@@ -4,10 +4,29 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## fetch [FIMI](http://fimi.uantwerpen.be/data/) datasets\n",
+    "## Fetch [FIMI](http://fimi.uantwerpen.be/data/) datasets\n",
     "`FIMI` is a popular repository referencing standard datasets and algorithms in pattern mining\n",
     "\n",
-    "### load datasets separately "
+    "### Load datasets separately "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
    ]
   },
   {
@@ -18,7 +37,8 @@
    "source": [
     "from skmine.datasets.fimi import fetch_chess\n",
     "from skmine.datasets.fimi import fetch_accidents\n",
-    "from skmine.datasets.fimi import fetch_kosarak"
+    "from skmine.datasets.fimi import fetch_kosarak\n",
+    "from skmine.datasets.fimi import fetch_iris"
    ]
   },
   {
@@ -31,11 +51,11 @@
     {
      "data": {
       "text/plain": [
-       "0    [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n",
-       "1    [1, 3, 5, 7, 9, 12, 13, 15, 17, 19]\n",
-       "2    [1, 3, 5, 7, 9, 12, 13, 16, 17, 19]\n",
-       "3    [1, 3, 5, 7, 9, 11, 13, 15, 17, 20]\n",
-       "4    [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n",
+       "0    [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25...\n",
+       "1    [1, 3, 5, 7, 9, 12, 13, 15, 17, 19, 21, 23, 25...\n",
+       "2    [1, 3, 5, 7, 9, 12, 13, 16, 17, 19, 21, 23, 25...\n",
+       "3    [1, 3, 5, 7, 9, 11, 13, 15, 17, 20, 21, 23, 25...\n",
+       "4    [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25...\n",
        "Name: chess, dtype: object"
       ]
      },
@@ -46,7 +66,7 @@
    ],
    "source": [
     "chess = fetch_chess()\n",
-    "chess.str[:10].head()\n",
+    "chess.head()\n",
     "# .str accessor allows horizontal slicing"
    ]
   },
@@ -58,11 +78,11 @@
     {
      "data": {
       "text/plain": [
-       "0            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
-       "1        [2, 5, 7, 8, 9, 10, 12, 13, 14, 15]\n",
-       "2    [7, 10, 12, 13, 14, 15, 16, 17, 18, 20]\n",
-       "3      [1, 5, 8, 10, 12, 14, 15, 16, 17, 18]\n",
-       "4     [5, 8, 10, 12, 14, 15, 16, 17, 18, 21]\n",
+       "0    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14...\n",
+       "1    [2, 5, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18...\n",
+       "2    [7, 10, 12, 13, 14, 15, 16, 17, 18, 20, 25, 28...\n",
+       "3    [1, 5, 8, 10, 12, 14, 15, 16, 17, 18, 19, 20, ...\n",
+       "4    [5, 8, 10, 12, 14, 15, 16, 17, 18, 21, 22, 24,...\n",
        "Name: accidents, dtype: object"
       ]
      },
@@ -73,20 +93,122 @@
    ],
    "source": [
     "accidents = fetch_accidents()\n",
-    "accidents.str[:10].head()"
+    "accidents.head()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Describe those datasets"
+    "You also have access to other known datasets from https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/dataSets.html that have been **discretized** as the **iris** dataset."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0     [2, 9, 12, 15, 18]\n",
+       "1    [1, 10, 11, 14, 17]\n",
+       "2    [5, 10, 13, 16, 19]\n",
+       "3     [2, 6, 12, 15, 18]\n",
+       "4     [1, 8, 11, 14, 17]\n",
+       "Name: iris.D19.N150.C3.num, dtype: object"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "iris = fetch_iris()\n",
+    "iris.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Some datasets like iris also allow **classification and have a target column**. To get X and y, use the *return_y* parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0     [2, 9, 12, 15]\n",
+      "1    [1, 10, 11, 14]\n",
+      "2    [5, 10, 13, 16]\n",
+      "3     [2, 6, 12, 15]\n",
+      "4     [1, 8, 11, 14]\n",
+      "Name: iris.D19.N150.C3.num, dtype: object 0    18\n",
+      "1    17\n",
+      "2    19\n",
+      "3    18\n",
+      "4    17\n",
+      "Name: iris.D19.N150.C3.num, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "X, y = fetch_iris(return_y=True)\n",
+    "print(X.head(), y.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load your own files in FIMI format\n",
+    "\n",
+    "With the **fetch_file** method, load your file. You can indicate if the values in the file are **integers or not**. The performance of the algorithms is better with integers. You can also **specify the separator** between the different items with 'separator'. By default, it's a blank space. (Example FIMI format [here](http://fimi.uantwerpen.be/data/chess.dat))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    [0, 1, 2]\n",
+       "1       [0, 1]\n",
+       "2    [1, 2, 3]\n",
+       "Name: data, dtype: object"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from skmine.datasets.fimi import fetch_file\n",
+    "db = fetch_file('data.dat', int_values=True)\n",
+    "db"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Describe those datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [
     {
      "data": {
@@ -97,7 +219,7 @@
        " 'density': 0.49333333333333335}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -110,7 +232,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -124,7 +246,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.10"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/datasets/synthetic_transactions.ipynb b/docs/tutorials/datasets/synthetic_transactions.ipynb
index 0d4e3262..dcc11548 100644
--- a/docs/tutorials/datasets/synthetic_transactions.ipynb
+++ b/docs/tutorials/datasets/synthetic_transactions.ipynb
@@ -11,6 +11,25 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -19,7 +38,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -28,6 +47,31 @@
     "                     density=.2)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0       [4, 9]\n",
+       "1    [8, 5, 6]\n",
+       "2       [6, 8]\n",
+       "3    [1, 6, 2]\n",
+       "4           []\n",
+       "dtype: object"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "D.head()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -38,29 +82,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7fa3216e34a8>"
+       "<AxesSubplot: >"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -70,7 +112,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -79,19 +121,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "{'n_items': 10,\n",
-       " 'avg_transaction_size': 2.08,\n",
+       " 'avg_transaction_size': 2.07,\n",
        " 'n_transactions': 100,\n",
-       " 'density': 0.20800000000000002}"
+       " 'density': 0.207}"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -110,7 +152,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -119,7 +161,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -128,7 +170,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
@@ -136,17 +178,17 @@
       "text/plain": [
        "class                      \n",
        "0      n_items                 100.0000\n",
-       "       avg_transaction_size     19.9500\n",
+       "       avg_transaction_size     20.0500\n",
        "       n_transactions           60.0000\n",
-       "       density                   0.1995\n",
+       "       density                   0.2005\n",
        "1      n_items                 100.0000\n",
-       "       avg_transaction_size     50.6500\n",
+       "       avg_transaction_size     50.5500\n",
        "       n_transactions           40.0000\n",
-       "       density                   0.5065\n",
+       "       density                   0.5055\n",
        "Name: transaction, dtype: float64"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -158,9 +200,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3.8.1 64-bit ('skmine': conda)",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
-   "name": "python38164bitskmineconda3789c8cb22f842768473342c0ee32d2f"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
@@ -172,7 +214,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.10"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/graph/GraphMDLTest.ipynb b/docs/tutorials/graph/GraphMDLTest.ipynb
index f6d1c949..6980cc5c 100644
--- a/docs/tutorials/graph/GraphMDLTest.ipynb
+++ b/docs/tutorials/graph/GraphMDLTest.ipynb
@@ -2,61 +2,81 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "source": [
-    "# GraphMDL for graph pattern mining"
-   ],
+   "id": "b217ed15",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "# GraphMDL for graph pattern mining"
+   ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4c2d5ee8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
    "source": [
-    "In this example, we are going to use the GraphMDL+ approach for mining a small set of graph patterns from graph data.\n",
+    "import skmine\n",
     "\n",
-    "GraphMDL+ is a heuristic anytime algorithm that uses the Minimum Description Length principle to select small but descriptive sets of patterns from graph data. The resulting set of patterns is significantly smaller than the complete set of patterns that can be generated by classic complete algorithms.\n"
-   ],
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "275d8981",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "In this example, we are going to use the GraphMDL+ approach for mining a small set of graph patterns from graph data.\n",
+    "\n",
+    "GraphMDL+ is a heuristic anytime algorithm that uses the Minimum Description Length principle to select small but descriptive sets of patterns from graph data. The resulting set of patterns is significantly smaller than the complete set of patterns that can be generated by classic complete algorithms.\n"
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
+   "id": "8bcf5617",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [],
    "source": [
     "# First we import the needed modules\n",
     "import networkx as nx\n",
     "from skmine.graph.graphmdl.graph_mdl import GraphMDL\n",
     "from skmine.graph.graphmdl import utils"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
+   "id": "d84522ac",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
    "source": [
     "First, we create a data graph, from which the patterns will be extracted.\n",
     "\n",
     "\n",
     "GraphMDL need edges to have exactly one label."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
@@ -95,15 +115,15 @@
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "We can automatically draw the graph."
-   ],
+   "id": "48b5198a",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "We can automatically draw the graph."
+   ]
   },
   {
    "cell_type": "code",
@@ -117,8 +137,10 @@
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -130,37 +152,48 @@
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "The automatic drawing is not always clear. For illustration purposes, here is a hand-made illustration as well.\n",
-    "\n",
-    "![example_data_graph.jpg](example_directed_graph.png)\n"
-   ],
+   "id": "fd0855d6",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "The automatic drawing is not always clear. For illustration purposes, here is a hand-made illustration as well.\n",
+    "\n",
+    "![example_data_graph.jpg](example_directed_graph.png)\n"
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "Now we can run the GraphMDL+ approach on the data graph."
-   ],
+   "id": "30393387",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "Now we can run the GraphMDL+ approach on the data graph."
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
+   "id": "52ff38e6",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "<skmine.graph.graphmdl.graph_mdl.GraphMDL at 0x1b314a037c0>"
+      "text/html": [
+       "<style>#sk-container-id-1 {color: black;background-color: white;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>GraphMDL()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">GraphMDL</label><div class=\"sk-toggleable__content\"><pre>GraphMDL()</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "GraphMDL()"
+      ]
      },
      "execution_count": 4,
      "metadata": {},
@@ -170,30 +203,30 @@
    "source": [
     "graphmdl = GraphMDL() # Initialize the approach\n",
     "graphmdl.fit(data_graph, timeout=2.5) # Run the approach on the data graph. Timeout is optional and in seconds."
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "markdown",
-   "source": [
-    "Now we can process the extracted patterns, the initial and the final description length.\n",
-    "For example, we can draw the extracted patterns, as each pattern is a graph, and compute a compression ratio with the description lengths."
-   ],
+   "id": "56f78d6b",
    "metadata": {
-    "collapsed": false,
     "pycharm": {
      "name": "#%% md\n"
     }
-   }
+   },
+   "source": [
+    "Now we can process the extracted patterns, the initial and the final description length.\n",
+    "For example, we can draw the extracted patterns, as each pattern is a graph, and compute a compression ratio with the description lengths."
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
+   "id": "f429aabb",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -206,22 +239,24 @@
    "source": [
     "patterns = list(graphmdl.patterns())\n",
     "print(\"Number of selected patterns\",len(patterns))"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
+   "id": "d493b18f",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQPklEQVR4nO3df2ychX3H8Y8Tp3FEcMOvQVCgaKWLoUCAtB3t6EinNZQf6ohEV+jYprZKJkFVaSpb16JJXVv6Y2Wi6gqbyB/QH9LK6latkACFViRai5gKhIROSWjYsuE1SQMicRxiY8e3P24xCY4dx/bdPc89r9c/vjz33On7T/TV++65u45arVYLAFTEnFYPAADNZPEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCkWHwCVYvEBUCmdrR5gql4aGErv033Zuqs//YMj6e7qTM9Z3fnQ8iU5beH8Vo8HQEl01Gq1WquHmMymF/fmnvXbs+H5PUmSoZHRsfu6OueklmTF0jNy61XnZ9k5i1ozJAClUejF990nd+TOh7dmcORQJpuyoyPp6pybO67tyS1XnNe0+QAon8K+1FlfeltycHj0uOfWasnB4UO58+EtSWL5ATChQhbfphf35qa1T+bg8KGxY/1PP5QDz/00r+3ZkZMuuCqnX/+Xx3zsgnlz8+CaK3LJkkVNmhaAMinkVZ33rN+ewZH60vvGj/8+O75yfR576qG8+T0fzsJL3p8kefC7n86Or1yff/zxV4967ODIody7fnvTZwagHAq3+F4aGMqG5/eMvaf37cuvS5Isf+XXWXbK2ZmzoDu/NTyUd/xv/WXN3ov/8KjH12rJ49v25OWBoabODUA5FG7x9T7dd9S/nzrn7dlyxnlJkg9vXpck+WD/nsytjWbXwlPzb+ddOu45OpL0PtM37jgAFG7xbd3Vf9RHFpLk28uvT5Lc8B/r0zk6mhv6f5Mk+dHb35fROXPHPcfgyGi27tzf+GEBKJ3CLb7+wZFxx3504Yr0zz8pp7+6L3/6m//MlQf2Jkm+/4aXOY9+nuFGjQhAiRVu8XV3jf+ExcE3deUHF/1BkuSLOzalM7U8u/hteeH0cyZ5nnkNmxGA8irc4us5qzvzO8eP9e1LP5DRdGThaL0Iey9ckdrooXHnJfVvdOlZfHJD5wSgnAq3+G5cvuSYxzdu/Vl+mvqlnoNJ7v3p2uz7+feOeW4tyY2XH/t5AKi2wn1zy+kL5+eq3zkjj23ZfdTXlC1675+kb3Agefqh/KTnynTf8DfHfoLaaK787dN8cTUAx1S44kuS21acn67O16/WvPnZR7O29wu5ZePDGU1H1r5r1YSPnZPR/OQbf5V169Y1Y1QASqaQi2/ZOYtyx7U9WTCvPt7yvi15//Z/z0snLcpnrvlENp299JiPWzBvTj5/w7Ks/erfZvXq1VmzZk36+/ubOToABVfI7+o8bCa/zrBv377cfvvtWbduXdauXZuVK1c2Z2gACq3Qiy9JNvftzb3rt+fxbXvSkfqH0w87/Ht871t6Rm5dcf4xv5h63bp1Wb16da6++urcdddd6e7ubtrsABRP4RffYS8PDKX3mb5s3bk//YPD6e6al57FJ+fGy4//C+zqD4DDSrP4ZoP6A6CQF7c0ysqVK7N58+bUarVcfPHFrvwEqKBKFd+R1B9ANVWq+I6k/gCqqbLFdyT1B1AdlS2+I6k/gOpQfG+g/gDam+J7A/UH0N4U3yTUH0D7UXyTUH8A7UfxTZH6A2gPim+K1B9Ae1B806D+AMpL8U2D+gMoL8U3Q+oPoFwU3wypP4ByUXyzSP0BFJ/im0XqD6D4FF+DqD+AYlJ8DaL+AIpJ8TWB+gMoDsXXBOoPoDgUX5OpP4DWUnxNpv4AWkvxtZD6A2g+xddC6g+g+RRfQag/gOZQfAWh/gCaQ/EVkPoDaBzFV0DqD6BxFF/BqT+A2aX4Ck79AcwuxVci6g9g5hRfiag/gJlTfCWl/gCmR/GVlPoDmB7F1wbUH8DUKb42oP4Apk7xtRn1BzA5xddm1B/A5BRfG1N/AOMpvjam/gDGU3wVof4A6hRfRag/gDrFV0HqD6gyxVdB6g+oMsVXceoPqBrFV3HqD6gaxccY9QdUgeJjjPoDqkDxcUzqD2hXio9jUn9Au1J8HJf6A9qJ4uO41B/QThQfJ0T9AWWn+Dgh6g8oO8XHtKk/oIwUH9Om/oAyUnzMCvUHlIXiY1aoP6AsFB+zTv0BRab4mHXqDygyxUdDqT+gaBQfDaX+gKJRfDSN+gOKQPHRNOoPKALFR0uoP6BVFB8tof6AVlF8tJz6A5pJ8dFy6g9oJsVHoag/oNEUH4Wi/oBGU3wUlvoDGkHxUVjqD2gExUcpqD9gtig+SkH9AbNF8VE66g+YCcVH6ag/YCYUH6Wm/oATpfgoNfUHnCjFR9tQf8BUKD7ahvoDpkLx0ZbUHzARxUdbUn/ARBQfbU/9AUdSfLQ99QccSfFRKeoPUHxUivoDFB+Vpf6gmhQflaX+oJoUH0T9QZUoPoj6gypRfPAG6g/am+KDN1B/0N4UH0xC/UH7UXwwCfUH7UfxwRSpP2gPig+mSP1Be1B8MA3qD8pL8cE0qD8oL8UHM6T+oFwUH8zQjOrvW99Kvv71hs0GjKf4YBYdWX933313TjrppIlP3r07Wby4fvszn0k+//lk7tzmDAoVpvhgFh2uv/nz52dwcHDiE2u15Kab6rcvuii54AJLD5pE8UGDHDp0KHMnWmb33598/OPJmWcmH/1o8qUv1Y+PjCSdnc0bEipI8UGDTLj0du1Kbrst6ehIenqSSy9N+vvr93V2JqOjTZsRqsjig2aq1ZKbb04GB+u3N25Mbr01Ofvs5Gtfq58zx39LaCT/w6CZHngg2bAhefObk1Wrkl/+MvnsZ5ODB5NPfzr54Q9bPSG0PYsPmmXXruQTn6i/xLl8eXLnncmSJcnHPpa88531c7Zurf/11js0jHfRoRlqteQDH6iXXZK897319/eGhuofa3jllfrxV1+t/+3oaM2cUAGKD5ph//7XK+7UU5Nt2+q3+/qSb34z+dWv6sdXrWrdjFARig+aobs72bQpeeSR+t8vfCF517vqZfeLX9TPWb06ectbWjsnVIDP8UGz7d2bfOQjyaOPvn7s5pvrV3WefXbLxoKqsPigVe6/P9m5M7nwwuS665J588buGh4ezsDAQE455ZQWDgjtyeKDoqjVxi5qGRkZyZVXXplLLrnELz7ALHNxCxTFEVdydnZ2jv3Kg9/7g9ml+KDg/N4fzC7FBwW3cuXKPPfcc0nUH8wGxQclov5g5hQflIj6g5lTfFBS6g+mR/FBSak/mB7FB21A/cHUKT5oA+oPpk7xQZtRfzA5xQdtRv3B5BQftDH1B+MpPmhj6g/GU3xQEeoP6hQfVIT6gzrFBxWk/qgyxQcVpP6oMsUHFaf+qBrFBxWn/qgaxQeMUX9UgeIDxqg/qkDxAcek/mhXig84JvVHu1J8wHGpP9qJ4gOOS/3RThQfcELUH2Wn+IATov4oO8UHTJv6o4wUHzBt6o8yUnzArFB/lIXiA2aF+qMsFB8w69QfRab4gFmn/igyxQc0lPqjaBQf0FDqj6JRfEDTqD+KQPEBTaP+KALFB7SE+qNVFB/QEuqPVlF8QMupP5pJ8QEtp/5oJsUHFIr6o9EUH1Ao6o9GU3xAYak/GkHxAYWl/mgExQeUgvpjtig+oBTUH7NF8QGlo/6YCcUHlI76YyYUH1Bq6o8TpfiAUlN/nCjFB7QN9cdUKD6gbag/pkLxAW1J/TERxQe0JfXHRBQf0PbUH0dSfEDbU38cSfEBlaL+UHxApag/FB9QWeqvmhQfUFnqr5oUH0DUX5UoPoCovypRfABvoP7am+IDeAP1194UH8Ak1F/7UXwAk1B/7UfxAUyR+msPig9gitRfe1B8ANOg/spL8QFMg/orL8UHMEPqr1wUH8AMqb9yUXwAs0j9FZ/iA5hF6q/4FB9Ag6i/YlJ8AA2i/opJ8QE0gforDsUH0ATqrzgUH0CTqb/WUnwATab+WkvxAbSQ+ms+xQfQQuqv+RQfQEGov+ZQfAAFof6aQ/EBFJD6axzFB1BA6q9xFB9Awam/2aX4AApO/c0uxQdQIupv5hQfQImov5lTfAAlpf6mR/EBlJT6mx7FB9AG1N/UKT6ANqD+pk7xAbQZ9Tc5xQfQZtTf5BQfQBtTf+MpPoA2pv7GU3wAFaH+6hQfQEWovzrFB1BBVa4/xQdQQVWuP4sPoKK6u7tz3333Ze3atVm9enXWrFmT/v7+bNiwIUuXLs2BAwdaPWJDeKkTgPT39+f222/PI488kgMHDmRgYCCf+tSn8uUvf/mY5780MJTep/uydVd/+gdH0t3VmZ6zuvOh5Uty2sL5TZ7+xFh8AIy55ppr8uijjyZJurq6sm3btpx77rlj9296cW/uWb89G57fkyQZGhkdu6+rc05qSVYsPSO3XnV+lp2zqJmjT5nFB0CS5Nlnn81ll1121LF3v/vdeeKJJ5Ik331yR+58eGsGRw5lss3R0ZF0dc7NHdf25JYrzmvgxNNj8QGQJNm/f396e3vzwgsvZMuWLdm4cWN2796dffv25XtP9eXOh7fk4PDo8Z/o/y2YNyd3XHtB4ZafxQfApDa9uDc3rX0yB4cPjR2rjQzn5XX3ZnDHsxkdHEjnorNyylV/ngVvfcdRj10wb24eXHNFLlmyqMlTT8xVnQBM6p712zM48vrSW7J3d/77rlUZ2PxYRvr3ZPS1g3ntN/+V3d//XD752H1HPXZw5FDuXb+92SNPqrPVAwBQXC8NDGXD83uOek9vqHNeNp69dOzfpx3Ym3P37U6SDBzsP+rxtVry+LY9eXlgqDBXe1p8AEyo9+m+ccf2LDw1q/7sH5Ikpx94Jb3f+eskyRPpyLd+d9W48zuS9D7Tl7/4/bc2dNapsvgAmNDWXf1HfWThSCcNvZoH/vVzOW/vzmzrnJ+be34vHWeOX26DI6PZunN/o0edMu/xATCh/sGRYx5/08hw1v7gi7lo9wvZNXdePrj4bck1n5zkeYYbNeIJs/gAmFB31/gXBjtqo7n7obvynv/ZnP45c/NHZ7wlB//479Ixd+IXEbu75jVyzBPipU4AJtRzVnfmd+466uXO67b+LNdt+3mS5GCSf0pHOv7ls0mS7y1bmQeXXX3Uc3R1zknP4pObNvPxKD4AJnTj8iXjjnUNvzZ2+8zRQ7l8169y2a+35bJfb8tpLzw17vxakhsvH/88reID7ABMas13nspjW3ZP+jVlE+noSK6+8Mz88y3vOP7JTaL4AJjUbSvOT1fn3Gk9tqtzbm5dcf4sTzQzFh8Ak1p2zqLccW1PFsw7sZVR/67OnkJ9XVni4hYApuDwF037dQYAKmVz397cu357Ht+2Jx2pfzj9sMO/x/e+pWfk1hXnF670DrP4ADhhLw8MpfeZvmzduT/9g8Pp7pqXnsUn58bL/QI7ABSKi1sAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqBSLD4BKsfgAqJT/AxxtLFP9Z5XVAAAAAElFTkSuQmCC\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -229,22 +264,24 @@
    ],
    "source": [
     "utils.draw_graph(patterns[0])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
+   "id": "a9513282",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "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\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -252,22 +289,24 @@
    ],
    "source": [
     "utils.draw_graph(patterns[1])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
+   "id": "d26782c0",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "data": {
-      "text/plain": "<Figure size 432x288 with 1 Axes>",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAIB0lEQVR4nO3dQYwVBx3H8d+yu3Zp6UJCKZBQ2kTarqZCUtDUXoonDTYeFBMPPfeAJ889N6mJ11YTEy960XAwMeGitvTQgLFtUrRlIZjQsBUIrcAWyi7s7vPQLg0Sa7R9u6a/z+f0dt7M5P8Ok29m35uZkcFgMAgAlFiz2gMAwEoSPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQJWx1R4Amrx7ZT4HX5vJ9LnZzM4tZHJiLFNbJvP93duycd0dqz0eVBgZDAaD1R4CPu/eOHMpzx8+lZdPXkiSzC8s3XxvYmxNBkn2PrwpB57YkV33bVidIaGE8MGQ/ero6Tx7aDpzC4v5pKNtZCSZGBvNM/um8tRjD6zYfNDGvzphiD6M3vFcu7H0H9cdDJJrNxbz7KHjSSJ+MCTO+GBI3jhzKT/4+dFcu7F4y/LZ136Xq3/5Y65fOJ27vvRE7nnyR7dtu3Z8NL9++rHs3LZhhaaFHn7VCUPy/OFTmVtYzP5jf8jp557M9E++m/HFGxlbtzG/GR3PYHEhL8y8lSS5a/6DnPrxd3L6uSfzrelXMrewmBcOn1rlTwCfT8IHQ/Dulfm8fPJCBoPkyP07kyQTC9fzyLm/5c6HH89jl88nSb7+waUkye53jmdssJSljORP2x/JYJC8dOJC3rsyv1ofAT63hA+G4OBrMzdfv7P+3pxZvzlJsmfmrWy/eDabr/wjl0fH8+D1a9l49VK++tGZ34lN9+fineuTJCNJDr4+c9u+gU9H+GAIps/N3nLJwpHtX0nyYfiWI/eLLV+8uexrZ95Mkhz9aL0kmVtYyvTZ91dqZKghfDAEs3MLt/y9HLTd7xzPnpk3Mz86np9ufShLSR5/+43sOnvylvU+3s+NFZkXmggfDMHkxK1XCi1/z3fPB5fz7elXcmzrgzn/hbU5fsdd+d5fX8zEwvUsZeS28E1OjK/YzNBC+GAIprZM5o6xjw+vs5Ob8vaGLUmSyfmreXXrQ8nSYo7cuT7rrl9Lkkzf+0Aur7375jYTY2sytfXuAJ8t4YMh2L97223LjmzfefP1oT//NrNHD+bFi3+/uexfz/YGSfY/evt+gE/HBewwJE//8tX8/vj5T7xN2b8zMpJ888ub87On9nz2g0E5Z3wwJD/cuyMTY6P/07YTY6M5sHfHZzwRkAgfDM2u+zbkmX1TWTv+3x1ma8fX5Jl9U25XBkPiJtUwRMs3mvZ0Bvj/4Ts+WAHHZi7lhcOn8tKJCxnJhxenL1t+Ht83Ht6UA3t3ONODIRM+WEHvXZnPwddnMn32/czO3cjkxHimtt6d/Y96AjusFOEDoIoftwBQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKoIHwBVhA+AKsIHQBXhA6CK8AFQRfgAqCJ8AFQRPgCqCB8AVYQPgCrCB0AV4QOgivABUEX4AKgifABUET4AqggfAFWED4AqwgdAFeEDoIrwAVBF+ACoInwAVBE+AKr8E4crN/88oDy/AAAAAElFTkSuQmCC\n"
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -275,17 +314,17 @@
    ],
    "source": [
     "utils.draw_graph(patterns[2])"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
+   "id": "cef42eef",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
    "outputs": [
     {
      "name": "stdout",
@@ -301,13 +340,7 @@
     "print(f\"initial description length = {graphmdl.initial_description_length()}\")\n",
     "print(f\"Final description length = {graphmdl.description_length()}\")\n",
     "print(f\"Compression ratio = {round((graphmdl.description_length()/ graphmdl.initial_description_length())*100, 2)} %\")"
-   ],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
+   ]
   }
  ],
  "metadata": {
@@ -326,9 +359,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.12"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/docs/tutorials/itemsets/LCM_on_chess.ipynb b/docs/tutorials/itemsets/LCM_on_chess.ipynb
index 4a9cbd62..b8a0fc97 100644
--- a/docs/tutorials/itemsets/LCM_on_chess.ipynb
+++ b/docs/tutorials/itemsets/LCM_on_chess.ipynb
@@ -8,6 +8,25 @@
     "LCM looks for closed itemset with respect to an input minimum support"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -80,8 +99,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 473 ms, sys: 410 ms, total: 883 ms\n",
-      "Wall time: 9.56 s\n"
+      "CPU times: user 49.2 ms, sys: 28.9 ms, total: 78.1 ms\n",
+      "Wall time: 1.51 s\n"
      ]
     }
    ],
@@ -153,29 +172,29 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>12</th>\n",
-       "      <td>(5, 7, 17, 58)</td>\n",
-       "      <td>2204</td>\n",
+       "      <th>14</th>\n",
+       "      <td>[29, 40, 52, 58]</td>\n",
+       "      <td>3143</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>14</th>\n",
-       "      <td>(5, 9, 17, 58)</td>\n",
-       "      <td>2088</td>\n",
+       "      <th>22</th>\n",
+       "      <td>[29, 52, 58, 60]</td>\n",
+       "      <td>3124</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>18</th>\n",
-       "      <td>(5, 7, 21, 58)</td>\n",
-       "      <td>2034</td>\n",
+       "      <th>26</th>\n",
+       "      <td>[40, 52, 58, 60]</td>\n",
+       "      <td>3112</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>22</th>\n",
-       "      <td>(5, 7, 25, 58)</td>\n",
-       "      <td>2539</td>\n",
+       "      <th>28</th>\n",
+       "      <td>[29, 40, 58, 60]</td>\n",
+       "      <td>3110</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>24</th>\n",
-       "      <td>(5, 9, 25, 58)</td>\n",
-       "      <td>2365</td>\n",
+       "      <th>29</th>\n",
+       "      <td>[29, 40, 52, 60]</td>\n",
+       "      <td>3100</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>...</th>\n",
@@ -183,28 +202,28 @@
        "      <td>...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>68956</th>\n",
-       "      <td>(29, 40, 48, 52, 54)</td>\n",
-       "      <td>2012</td>\n",
+       "      <th>68960</th>\n",
+       "      <td>[15, 52, 58, 60]</td>\n",
+       "      <td>2003</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>68957</th>\n",
-       "      <td>(36, 40, 48, 52, 54)</td>\n",
-       "      <td>2012</td>\n",
+       "      <th>68962</th>\n",
+       "      <td>[15, 29, 58, 60]</td>\n",
+       "      <td>2002</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>68964</th>\n",
-       "      <td>(29, 40, 52, 70)</td>\n",
-       "      <td>2001</td>\n",
+       "      <td>[29, 40, 58, 70]</td>\n",
+       "      <td>2006</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>68965</th>\n",
-       "      <td>(29, 40, 58, 70)</td>\n",
-       "      <td>2006</td>\n",
+       "      <td>[29, 40, 52, 70]</td>\n",
+       "      <td>2001</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>68966</th>\n",
-       "      <td>(29, 40, 52, 58, 70)</td>\n",
+       "      <td>[29, 40, 52, 58, 70]</td>\n",
        "      <td>2000</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -214,17 +233,17 @@
       ],
       "text/plain": [
        "                    itemset  support\n",
-       "12           (5, 7, 17, 58)     2204\n",
-       "14           (5, 9, 17, 58)     2088\n",
-       "18           (5, 7, 21, 58)     2034\n",
-       "22           (5, 7, 25, 58)     2539\n",
-       "24           (5, 9, 25, 58)     2365\n",
+       "14         [29, 40, 52, 58]     3143\n",
+       "22         [29, 52, 58, 60]     3124\n",
+       "26         [40, 52, 58, 60]     3112\n",
+       "28         [29, 40, 58, 60]     3110\n",
+       "29         [29, 40, 52, 60]     3100\n",
        "...                     ...      ...\n",
-       "68956  (29, 40, 48, 52, 54)     2012\n",
-       "68957  (36, 40, 48, 52, 54)     2012\n",
-       "68964      (29, 40, 52, 70)     2001\n",
-       "68965      (29, 40, 58, 70)     2006\n",
-       "68966  (29, 40, 52, 58, 70)     2000\n",
+       "68960      [15, 52, 58, 60]     2003\n",
+       "68962      [15, 29, 58, 60]     2002\n",
+       "68964      [29, 40, 58, 70]     2006\n",
+       "68965      [29, 40, 52, 70]     2001\n",
+       "68966  [29, 40, 52, 58, 70]     2000\n",
        "\n",
        "[67716 rows x 2 columns]"
       ]
@@ -289,52 +308,52 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>(58,)</td>\n",
+       "      <td>[58]</td>\n",
        "      <td>3195</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>8824</th>\n",
-       "      <td>(52,)</td>\n",
+       "      <th>1</th>\n",
+       "      <td>[52]</td>\n",
        "      <td>3185</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>2670</th>\n",
-       "      <td>(52, 58)</td>\n",
+       "      <th>2</th>\n",
+       "      <td>[52, 58]</td>\n",
        "      <td>3184</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>10651</th>\n",
-       "      <td>(29,)</td>\n",
+       "      <th>3</th>\n",
+       "      <td>[29]</td>\n",
        "      <td>3181</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>29</th>\n",
-       "      <td>(29, 58)</td>\n",
+       "      <th>4</th>\n",
+       "      <td>[29, 58]</td>\n",
        "      <td>3180</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>8853</th>\n",
-       "      <td>(29, 52)</td>\n",
+       "      <th>5</th>\n",
+       "      <td>[29, 52]</td>\n",
        "      <td>3170</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>10686</th>\n",
-       "      <td>(40,)</td>\n",
+       "      <th>7</th>\n",
+       "      <td>[40]</td>\n",
        "      <td>3170</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>386</th>\n",
-       "      <td>(40, 58)</td>\n",
+       "      <th>6</th>\n",
+       "      <td>[29, 52, 58]</td>\n",
        "      <td>3169</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>2699</th>\n",
-       "      <td>(29, 52, 58)</td>\n",
+       "      <th>8</th>\n",
+       "      <td>[40, 58]</td>\n",
        "      <td>3169</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>9036</th>\n",
-       "      <td>(40, 52)</td>\n",
+       "      <th>9</th>\n",
+       "      <td>[40, 52]</td>\n",
        "      <td>3159</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -342,17 +361,17 @@
        "</div>"
       ],
       "text/plain": [
-       "            itemset  support\n",
-       "0             (58,)     3195\n",
-       "8824          (52,)     3185\n",
-       "2670       (52, 58)     3184\n",
-       "10651         (29,)     3181\n",
-       "29         (29, 58)     3180\n",
-       "8853       (29, 52)     3170\n",
-       "10686         (40,)     3170\n",
-       "386        (40, 58)     3169\n",
-       "2699   (29, 52, 58)     3169\n",
-       "9036       (40, 52)     3159"
+       "        itemset  support\n",
+       "0          [58]     3195\n",
+       "1          [52]     3185\n",
+       "2      [52, 58]     3184\n",
+       "3          [29]     3181\n",
+       "4      [29, 58]     3180\n",
+       "5      [29, 52]     3170\n",
+       "7          [40]     3170\n",
+       "6  [29, 52, 58]     3169\n",
+       "8      [40, 58]     3169\n",
+       "9      [40, 52]     3159"
       ]
      },
      "execution_count": 6,
@@ -367,7 +386,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -381,7 +400,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.10"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/itemsets/SLIM.ipynb b/docs/tutorials/itemsets/SLIM.ipynb
index b76d3568..c922a65a 100644
--- a/docs/tutorials/itemsets/SLIM.ipynb
+++ b/docs/tutorials/itemsets/SLIM.ipynb
@@ -13,6 +13,25 @@
     "You end up having less data to consider, and your life just gets easier"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -89,32 +108,41 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
+       "      <th>itemset</th>\n",
        "      <th>usage</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>(milk, bananas)</th>\n",
-       "      <td>[0, 1, 4]</td>\n",
+       "      <th>0</th>\n",
+       "      <td>[bananas, milk]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(tea)</th>\n",
-       "      <td>[2, 3, 4]</td>\n",
+       "      <th>1</th>\n",
+       "      <td>[tea]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(cookies)</th>\n",
-       "      <td>[1, 2]</td>\n",
+       "      <th>2</th>\n",
+       "      <td>[cookies]</td>\n",
+       "      <td>2</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(butter)</th>\n",
-       "      <td>[2]</td>\n",
+       "      <th>3</th>\n",
+       "      <td>[butter]</td>\n",
+       "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "<skmine.itemsets.slim.SLIM at 0x123317278>"
+       "           itemset  usage\n",
+       "0  [bananas, milk]      3\n",
+       "1            [tea]      3\n",
+       "2        [cookies]      2\n",
+       "3         [butter]      1"
       ]
      },
      "execution_count": 3,
@@ -124,7 +152,7 @@
    ],
    "source": [
     "slim = SLIM(pruning=True)\n",
-    "slim.fit(D)"
+    "slim.fit(D).discover()"
    ]
   },
   {
@@ -195,40 +223,47 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
+       "      <th>itemset</th>\n",
        "      <th>usage</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>(milk, bananas)</th>\n",
-       "      <td>[0, 1, 4]</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>(tea, butter)</th>\n",
-       "      <td>[2]</td>\n",
+       "      <th>0</th>\n",
+       "      <td>[bananas, milk]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(bananas)</th>\n",
-       "      <td>[5]</td>\n",
+       "      <th>1</th>\n",
+       "      <td>[bananas, jelly]</td>\n",
+       "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(cookies)</th>\n",
-       "      <td>[1, 2, 5]</td>\n",
+       "      <th>2</th>\n",
+       "      <td>[cookies]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(tea)</th>\n",
-       "      <td>[3, 4]</td>\n",
+       "      <th>3</th>\n",
+       "      <td>[tea]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(jelly)</th>\n",
-       "      <td>[5]</td>\n",
+       "      <th>4</th>\n",
+       "      <td>[butter]</td>\n",
+       "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "<skmine.itemsets.slim.SLIM at 0x123317e80>"
+       "            itemset  usage\n",
+       "0   [bananas, milk]      3\n",
+       "1  [bananas, jelly]      1\n",
+       "2         [cookies]      3\n",
+       "3             [tea]      3\n",
+       "4          [butter]      1"
       ]
      },
      "execution_count": 5,
@@ -237,13 +272,13 @@
     }
    ],
    "source": [
-    "SLIM().fit(D)"
+    "SLIM().fit(D).discover()"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -257,7 +292,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.12"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/docs/tutorials/itemsets/symbolic_classifier.ipynb b/docs/tutorials/itemsets/symbolic_classifier.ipynb
index d88e13ec..c0e8e001 100644
--- a/docs/tutorials/itemsets/symbolic_classifier.ipynb
+++ b/docs/tutorials/itemsets/symbolic_classifier.ipynb
@@ -7,6 +7,25 @@
     "## Building a symbolic classifier"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This tutorial was tested with the following version of skmine : 0.0.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "import skmine\n",
+    "\n",
+    "print(\"This tutorial was tested with the following version of skmine :\", skmine.__version__)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -20,10 +39,278 @@
     "to make some predictions**"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SLIM Classifier\n",
+    "\n",
+    "An **integrated classifier in scikit mine is available** and allows to **solve binary and multiclass problems**. It uses the SLIM compression algorithm. \n",
+    "\n",
+    "To use it, we need to have **discretized dataset**. Let's take for example the **discretized iris dataset**."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X shape: (150,)\n",
+      "y shape: (150,)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0     [2, 9, 12, 15]\n",
+       "1    [1, 10, 11, 14]\n",
+       "2    [5, 10, 13, 16]\n",
+       "3     [2, 6, 12, 15]\n",
+       "4     [1, 8, 11, 14]\n",
+       "Name: iris.D19.N150.C3.num, dtype: object"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from skmine.datasets.fimi import fetch_iris\n",
+    "X, y = fetch_iris(return_y=True)  # without return_y=True, the method would have returned the whole dataset in one variable\n",
+    "print(\"X shape:\", X.shape)\n",
+    "print(\"y shape:\", y.shape)\n",
+    "X.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    18\n",
+       "1    17\n",
+       "2    19\n",
+       "3    18\n",
+       "4    17\n",
+       "Name: iris.D19.N150.C3.num, dtype: int64"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The purpose of this dataset is to **predict the last column of db from the other 4**. The possible targets are: 17, 18, 19. We can prepare our train and test data set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X_train shape: (120,) y_train shape: (120,)\n",
+      "X_test shape: (30,) y_test shape: (30,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "(X_train, X_test, y_train, y_test) = train_test_split(X, y, random_state=1, test_size=0.2, shuffle=True)\n",
+    "print(\"X_train shape:\", X_train.shape, \"y_train shape:\", y_train.shape)\n",
+    "print(\"X_test shape:\", X_test.shape, \"y_test shape:\", y_test.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can use our **SlimClassifier**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8333333333333334"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from skmine.itemsets.slim_classifier import SlimClassifier\n",
+    "\n",
+    "# You can pass in parameter of your classifier the set of your items. \n",
+    "# This will improve its performance especially on small data sets like iris.\n",
+    "items = set(item for transaction in X for item in transaction)\n",
+    "\n",
+    "clf = SlimClassifier(items=items)  # You can also enable or disable the pruning of SLIM compressors via the `pruning` parameter\n",
+    "clf.fit(X_train, y_train)\n",
+    "clf.score(X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can use many functions of sckit learn that are compatible with classifiers. For example, build a **confusion matrix**, use **GridSearchCV** or **cross validation**.\n",
+    "\n",
+    "- **Confusion matrix**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[13,  1,  0],\n",
+       "       [ 0,  8,  1],\n",
+       "       [ 0,  3,  4]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import confusion_matrix\n",
+    "\n",
+    "y_pred = clf.predict(X_test)\n",
+    "confusion_matrix(y_test, y_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "- **GridSearchCV** (this method allows us to test many parameters for a classifier and to retain the best combination)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "GridSearchCV(estimator=SlimClassifier(items={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\n",
+      "                                             12, 13, 14, 15, 16}),\n",
+      "             param_grid={'items': [None,\n",
+      "                                   {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,\n",
+      "                                    14, 15, 16}],\n",
+      "                         'pruning': [False, True]})\n",
+      "{'items': {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, 'pruning': False}\n",
+      "0.9833333333333333\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import GridSearchCV\n",
+    "\n",
+    "parameters = {'pruning': [False, True], 'items': [None, items]}\n",
+    "grid = GridSearchCV(clf, parameters)\n",
+    "print(grid.fit(X_train,y_train))\n",
+    "print(grid.best_params_)\n",
+    "print(grid.score(X_train, y_train))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With GridSearchCV we get with the best parameters an **accuracy of more than 98%**, much better than the previous score. With this combination, the item list is passed as a parameter and pruning is disabled. Since pruning does not improve the compression of codetables in the SLIM algorithm on iris, it does not matter whether it is enabled or not.\n",
+    "\n",
+    "To be more sure of the quality of our results, we can use the cross validation of sklearn.\n",
+    "- **Cross validation**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.93333333 0.93333333 0.86666667 0.93333333 0.93333333 0.93333333\n",
+      " 1.         1.         1.         0.93333333]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0.9466666666666667"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from sklearn.model_selection import cross_val_score\n",
+    "\n",
+    "cross_validation = cross_val_score(clf, X, y, cv=10)\n",
+    "print(cross_validation)\n",
+    "cross_validation.mean()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "After cross validation, we see that the **accuracy is almost 95% on average**. So in 95% of the cases, the right type of flower is given."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "----------\n",
+    "\n",
+    "### OneVsRest classifier\n",
+    "\n",
+    "The **SLIM algorithm** is also compatible with **scikit-learn** to be used from other classifiers like **One-vs-the-rest (OvR)** (https://scikit-learn.org/stable/modules/generated/sklearn.multiclass.OneVsRestClassifier.html). The limitation of this method is that the classifier **only works for multiclass classification** problems while the embedded classifier works for both binary and multiclass problems."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "import pandas as pd\n",
@@ -33,7 +320,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -45,7 +332,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -130,7 +417,7 @@
        "4        1       0        0     1    1"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -150,7 +437,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -174,42 +461,51 @@
        "  <thead>\n",
        "    <tr style=\"text-align: right;\">\n",
        "      <th></th>\n",
+       "      <th>itemset</th>\n",
        "      <th>usage</th>\n",
        "    </tr>\n",
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>(bananas, milk)</th>\n",
-       "      <td>[0, 1, 4]</td>\n",
+       "      <th>0</th>\n",
+       "      <td>[bananas, milk]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(tea)</th>\n",
-       "      <td>[2, 3, 4]</td>\n",
+       "      <th>1</th>\n",
+       "      <td>[tea]</td>\n",
+       "      <td>3</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(cookies)</th>\n",
-       "      <td>[1, 2]</td>\n",
+       "      <th>2</th>\n",
+       "      <td>[cookies]</td>\n",
+       "      <td>2</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>(butter)</th>\n",
-       "      <td>[2]</td>\n",
+       "      <th>3</th>\n",
+       "      <td>[butter]</td>\n",
+       "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "<skmine.itemsets.slim.SLIM at 0x1a1e0b7e80>"
+       "           itemset  usage\n",
+       "0  [bananas, milk]      3\n",
+       "1            [tea]      3\n",
+       "2        [cookies]      2\n",
+       "3         [butter]      1"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "slim = SLIM()\n",
-    "slim.fit(D)"
+    "slim.fit(D).discover()"
    ]
   },
   {
@@ -224,22 +520,22 @@
    "metadata": {},
    "source": [
     "----------\n",
-    "### First \"predictions\" \n",
+    "#### First \"predictions\" \n",
     "\n",
     "We define a new transactional dataset, and can call our ``decision_function`` on it. This will yield ``distances`` w.r.t the encoding scheme provided by our codetable"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/usr/local/Caskroom/miniconda/base/envs/scikit-mine/lib/python3.6/site-packages/sklearn/preprocessing/_label.py:995: UserWarning: unknown class(es) ['sirup'] will be ignored\n",
-      "  .format(sorted(unknown, key=str)))\n"
+      "/home/tbetton/Documents/F-WIN/scikit-mine/venv_3.11/lib64/python3.11/site-packages/sklearn/preprocessing/_label.py:895: UserWarning: unknown class(es) ['sirup'] will be ignored\n",
+      "  warnings.warn(\n"
      ]
     },
     {
@@ -324,7 +620,7 @@
        "4        1       0        0     1    1"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -343,7 +639,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -352,7 +648,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -384,27 +680,27 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>[bananas, milk]</td>\n",
-       "      <td>-1.58496</td>\n",
+       "      <td>-1.906891</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>[milk, sirup, cookies]</td>\n",
-       "      <td>-2.16992</td>\n",
+       "      <td>-6.228819</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>[butter, tea]</td>\n",
-       "      <td>-1.16992</td>\n",
+       "      <td>-4.813781</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>[tea]</td>\n",
-       "      <td>-1.58496</td>\n",
+       "      <td>-1.906891</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
        "      <td>[milk, bananas, tea]</td>\n",
-       "      <td>-0.584962</td>\n",
+       "      <td>-3.813781</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -412,14 +708,14 @@
       ],
       "text/plain": [
        "              transaction  distance\n",
-       "0         [bananas, milk]  -1.58496\n",
-       "1  [milk, sirup, cookies]  -2.16992\n",
-       "2           [butter, tea]  -1.16992\n",
-       "3                   [tea]  -1.58496\n",
-       "4    [milk, bananas, tea] -0.584962"
+       "0         [bananas, milk] -1.906891\n",
+       "1  [milk, sirup, cookies] -6.228819\n",
+       "2           [butter, tea] -4.813781\n",
+       "3                   [tea] -1.906891\n",
+       "4    [milk, bananas, tea] -3.813781"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -432,8 +728,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "---------------\n",
-    "### Built-in interpretations\n",
+    "#### Built-in interpretations\n",
     "Now we can interpret codes for the new data, directly by **looking at the codetable inferred from training data**\n",
     "\n",
     "First observations\n",
@@ -449,8 +744,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "--------------\n",
-    "### Shortest code wins !!\n",
+    "#### Shortest code wins !!\n",
     "Next, we are going to use an ensemble of SLIM encoding schemes, and utilize them via a ``OneVsRest`` methodology, to perform **multi-class classification**.\n",
     "The methodology is very simple\n",
     "\n",
@@ -462,7 +756,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -472,7 +766,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -484,7 +778,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -510,7 +804,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
@@ -646,7 +940,7 @@
        "6     1    0  "
       ]
      },
-     "execution_count": 11,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -659,7 +953,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -668,18 +962,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[<skmine.itemsets.slim.SLIM at 0x1a1e392cc0>,\n",
-       " <skmine.itemsets.slim.SLIM at 0x1a1e392908>,\n",
-       " <skmine.itemsets.slim.SLIM at 0x1a1e3a8ba8>]"
+       "[SLIM(), SLIM(), SLIM()]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -691,7 +983,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -723,62 +1015,62 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>-inf</td>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-inf</td>\n",
+       "      <td>-7.169925</td>\n",
+       "      <td>-4.584963</td>\n",
+       "      <td>-7.614710</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-2.0</td>\n",
+       "      <td>-10.754888</td>\n",
+       "      <td>-9.754888</td>\n",
+       "      <td>-7.252140</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>-inf</td>\n",
-       "      <td>-inf</td>\n",
-       "      <td>-2.0</td>\n",
+       "      <td>-3.584963</td>\n",
+       "      <td>-3.584963</td>\n",
+       "      <td>-2.222392</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>-inf</td>\n",
-       "      <td>-inf</td>\n",
-       "      <td>-1.0</td>\n",
+       "      <td>-7.169925</td>\n",
+       "      <td>-7.169925</td>\n",
+       "      <td>-5.029747</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-0.584962</td>\n",
-       "      <td>-inf</td>\n",
+       "      <td>-7.169925</td>\n",
+       "      <td>-4.584963</td>\n",
+       "      <td>-6.614710</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>5</th>\n",
-       "      <td>-0.584962</td>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-inf</td>\n",
+       "      <td>-2.584963</td>\n",
+       "      <td>-6.169925</td>\n",
+       "      <td>-6.614710</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>6</th>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-1.584962</td>\n",
-       "      <td>-inf</td>\n",
+       "      <td>-2.584963</td>\n",
+       "      <td>-9.169926</td>\n",
+       "      <td>-11.422065</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
-       "     bakery  foodstore  newspaper\n",
-       "0      -inf  -1.584962       -inf\n",
-       "1 -1.584962  -1.584962       -2.0\n",
-       "2      -inf       -inf       -2.0\n",
-       "3      -inf       -inf       -1.0\n",
-       "4 -1.584962  -0.584962       -inf\n",
-       "5 -0.584962  -1.584962       -inf\n",
-       "6 -1.584962  -1.584962       -inf"
+       "      bakery  foodstore  newspaper\n",
+       "0  -7.169925  -4.584963  -7.614710\n",
+       "1 -10.754888  -9.754888  -7.252140\n",
+       "2  -3.584963  -3.584963  -2.222392\n",
+       "3  -7.169925  -7.169925  -5.029747\n",
+       "4  -7.169925  -4.584963  -6.614710\n",
+       "5  -2.584963  -6.169925  -6.614710\n",
+       "6  -2.584963  -9.169926 -11.422065"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -789,17 +1081,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array(['foodstore', 'foodstore', 'newspaper', 'newspaper', 'foodstore',\n",
-       "       'bakery', 'foodstore'], dtype='<U9')"
+       "array(['foodstore', 'newspaper', 'newspaper', 'newspaper', 'foodstore',\n",
+       "       'bakery', 'bakery'], dtype='<U9')"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 22,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -811,7 +1103,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -825,7 +1117,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.12"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,
diff --git a/requirements.txt b/requirements.txt
index 49ab8e9c..847e499e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,8 +1,9 @@
 scipy>=1.2.1
 pandas>=1.0.0
-pyroaring
+pyroaring~=0.3.4
 joblib>=0.11.1
 sortedcontainers>=2.1.0
-dataclasses
+dataclasses~=0.6
 networkx~=2.5.1
-wget
+wget~=3.2
+scikit-learn
\ No newline at end of file
diff --git a/setup.py b/setup.py
index c75417fb..b0cce4d7 100644
--- a/setup.py
+++ b/setup.py
@@ -11,8 +11,8 @@
 
 DISTNAME = 'scikit-mine'
 DESCRIPTION = 'Pattern mining in Python'
-MAINTAINER = 'R. Adon'
-MAINTAINER_EMAIL = 'remi.adon@gmail.com'
+MAINTAINER = 'scikit-mine team'
+MAINTAINER_EMAIL = 'skm-dev@inria.fr'
 URL = 'https://github.com/scikit-mine/scikit-mine'
 LICENSE = 'new BSD'
 DOWNLOAD_URL = 'https://github.com/scikit-mine/scikit-mine'
diff --git a/skmine/__init__.py b/skmine/__init__.py
index 5eb983c8..cfa2191a 100644
--- a/skmine/__init__.py
+++ b/skmine/__init__.py
@@ -7,6 +7,6 @@
 # see : https://github.com/joblib/joblib/issues/634#issuecomment-367321025
 # joblib currently disable logging inside delayed functions
 __author__ = """scikit-mine team"""
-__email__ = """remi.adon@gmail.com"""
-__version__ = "0.0.8"  # pylint: disable= undefined-variable, pointless-statement
-__credits__ = "Centre Inria Rennes - Bretagne Atlantique"
+__email__ = """skm-dev@inria.fr"""
+__version__ = "0.0.9"  # pylint: disable= undefined-variable, pointless-statement
+__credits__ = "Centre Inria de l'Université de Rennes"
diff --git a/skmine/base.py b/skmine/base.py
index fb25f97e..9aa8aca3 100644
--- a/skmine/base.py
+++ b/skmine/base.py
@@ -60,11 +60,10 @@ def _get_param_names(cls):
         # to represent
         init_signature = inspect.signature(init)
         # Consider the constructor parameters excluding 'self'
-        parameters = [
-            p
-            for p in init_signature.parameters.values()
-            if p.name != "self" and p.kind != p.VAR_KEYWORD
-        ]
+        parameters = [p
+                      for p in init_signature.parameters.values()
+                      if p.name != "self" and p.kind != p.VAR_KEYWORD
+                      ]
         # Extract and sort argument names excluding 'self'
         return sorted([p.name for p in parameters])
 
@@ -108,12 +107,9 @@ def set_params(self, **params):
 
         for key, value in params.items():
             if key not in valid_params:
-                raise ValueError(
-                    "Invalid parameter %s for estimator %s. "
-                    "Check the list of available parameters "
-                    "with `estimator.get_params().keys()`." % (key, self)
-                )
-
+                raise ValueError("Invalid parameter %s for estimator %s. Check the list of available parameters "
+                                 "with `estimator.get_params().keys()`." % (key, self)
+                                 )
             setattr(self, key, value)
             valid_params[key] = value
 
@@ -138,14 +134,15 @@ def fit_discover(self, D, y=None, **kwargs):
         """
         if y is None:
             return self.fit(D).discover(**kwargs)
-        return self.fit(D, y=y).discover(**kwargs)
+        else:
+            return self.fit(D, y=y).discover(**kwargs)
 
 
 class TransformerMixin:
     """Base Mixin for transformers in scikit-mine"""
 
     def fit_transform(self, X, y=None):
-        "fit on X and y, then transform X"
+        """fit on X and y, then transform X"""
         return self.fit(X, y).transform(X)
 
     decision_function = None
@@ -193,17 +190,15 @@ def evaluate(self, candidate, *args, **kwargs):
             usage of `(two-part) crude MDL
             <https://en.wikipedia.org/wiki/Minimum_description_length#Two-Part_Codes>`_.
         """
-        return (
-            0,
-            0,
-        )
+        return (0, 0,)
 
     def _repr_html_(self):
         s = self.discover()  # call discover with default parameters
         df = s.to_frame(name="usage")
         if not df.empty:
             return df._repr_html_()  # pylint: disable=protected-access
-        return repr(self)
+        else:
+            return repr(self)
 
 
 class InteractiveMiner(ABC):
diff --git a/skmine/datasets/_instacart.py b/skmine/datasets/_instacart.py
index 908a36f6..1c816675 100644
--- a/skmine/datasets/_instacart.py
+++ b/skmine/datasets/_instacart.py
@@ -15,8 +15,8 @@
 except ImportError:
     LXML_INSTALLED = False
 
-from ._base import get_data_home
-from .conf import urlopen
+from skmine.datasets._base import get_data_home # TODO . relative import
+from skmine.datasets.conf import urlopen
 
 _IMPORT_MSG = """
 lxml is required to install the instacart dataset.
@@ -141,3 +141,13 @@ def _download(data_home):
         with open(tar_filename, "wb") as f:
             f.write(targz_data)
     return tar_filename
+
+
+if __name__ == '__main__':
+    # data = fetch_instacart()
+    data_link = "https://www.kaggle.com/c/instacart-market-basket-analysis/data"
+    tree = html.fromstring(urlopen(data_link).read())
+    buttons = tree.xpath("//*[contains(@class, 'ic-btn ic-btn-success ic-btn-lg')]")
+    download_link = buttons[0].attrib["href"]
+    instacart_filedata = urlopen(download_link)
+    targz_data = instacart_filedata.read()
\ No newline at end of file
diff --git a/skmine/datasets/fimi.py b/skmine/datasets/fimi.py
index 754e8a7b..6e4078e0 100644
--- a/skmine/datasets/fimi.py
+++ b/skmine/datasets/fimi.py
@@ -4,15 +4,17 @@
 """
 import os
 import wget
+import gzip
 
 import pandas as pd
 
 from ._base import get_data_home
 
-BASE_URL = "http://fimi.uantwerpen.be/data/"
+BASE_URL_FIMI = "http://fimi.uantwerpen.be/data/"
+BASE_URL_CGI = "https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/"
 
 
-def _read_dat(filepath, int_values=True, separator=' '):
+def _read_dat(filepath, int_values=True, separator=' ', zip=False):
     """Read a local dataset file whose separator can be customized and whose values are either integers or strings.
 
     Parameters
@@ -31,24 +33,24 @@ def _read_dat(filepath, int_values=True, separator=' '):
     list
         Return a transaction list composed for each transaction of a list of items
     """
-    with open(filepath, 'r') as f:
-        try:
-            lines = f.read().splitlines()
-        except UnicodeDecodeError:
-            print(f"The file {filepath} is already present in your data_home but it is a binary file, it must be "
-                  f"deleted.")
-            raise
-
-    transactions = []
-    for line in lines:
-        tmp = line.rstrip()
-        tmp = list(map(int, tmp.split(separator))) if int_values else tmp.split(separator)
-        transactions.append(tmp)
+    try:
+        if zip:
+            with gzip.open(filepath, 'rt') as f:
+                lines = f.read().splitlines()
+        else:
+            with open(filepath, 'r') as f:
+                lines = f.read().splitlines()
+    except UnicodeDecodeError:
+        print(f"The file {filepath} is already present in your data_home but it is a binary file, it must be "
+              f"deleted.")
+        raise
+
+    transactions = [[int(item) if int_values else item for item in line.rstrip().split(separator)] for line in lines]
 
     return transactions
 
 
-def fetch_file(filepath, separator=' '):
+def fetch_file(filepath, separator=' ', int_values=False):
     """Loader for files in FIMI format
 
     Parameters
@@ -59,33 +61,41 @@ def fetch_file(filepath, separator=' '):
     separator : str
         Indicate a custom separator between the items. By default, it is a space.
 
+    int_values : bool, default=False
+        Specify if the items in the file are all integers. If not, then the items are considered as strings.
+        With integers, the algorithms are more efficient.
+
     Returns
     -------
     pd.Series
         Transactions from the requested dataset,
         as an in-memory pandas Series
     """
-    transactions = _read_dat(filepath, int_values=False, separator=separator)
+    transactions = _read_dat(filepath, int_values=int_values, separator=separator)
     s = pd.Series(transactions, name=os.path.splitext(os.path.basename(filepath))[0])
 
     return s
 
 
-def fetch_any(filename, data_home=None):
-    """Base loader for all datasets from the FIMI repository
+def fetch_any(filename, base_url=BASE_URL_FIMI, data_home=None):
+    """Base loader for all datasets from the FIMI and CGI repository
     Each unique transaction will be represented as a Python list in the resulting pandas Series
 
     see: http://fimi.uantwerpen.be/data/
+    https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/dataSets.html
 
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `~/scikit_mine_data/` subfolders.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `~/scikit_mine_data/` subfolders.
 
     filename : str
         Name of the file to fetch
 
+    base_url : str
+        URL indicating where to fetch the dataset
+
     Returns
     -------
     pd.Series
@@ -96,11 +106,11 @@ def fetch_any(filename, data_home=None):
     filepath = os.path.join(data_home, filename)
     name, _ = os.path.splitext(filename)
     if filename in os.listdir(data_home):  # already fetched
-        it = _read_dat(filepath)
+        it = _read_dat(filepath, zip=True) if base_url == BASE_URL_CGI else _read_dat(filepath)
     else:  # not fetched yet
-        url = BASE_URL + filename
+        url = base_url + filename
         wget.download(url, filepath)
-        it = _read_dat(filepath)
+        it = _read_dat(filepath, zip=True) if base_url == BASE_URL_CGI else _read_dat(filepath)
 
     s = pd.Series(it, name=name)
     return s
@@ -119,8 +129,8 @@ def fetch_chess(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -128,7 +138,7 @@ def fetch_chess(data_home=None):
         Transactions from the chess dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("chess.dat", data_home=data_home)
+    return fetch_any("chess.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
 def fetch_connect(data_home=None):
@@ -144,8 +154,8 @@ def fetch_connect(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -153,10 +163,10 @@ def fetch_connect(data_home=None):
         Transactions from the connect dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("connect.dat", data_home=data_home)
+    return fetch_any("connect.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
-def fetch_mushroom(data_home=None, return_mush_y=False):
+def fetch_mushroom(data_home=None, return_y=False):
     """Fetch and return the mushroom dataset (Frequent Itemset Mining)
 
     The Mushroom data set includes descriptions of hypothetical samples corresponding
@@ -178,10 +188,10 @@ def fetch_mushroom(data_home=None, return_mush_y=False):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
-    return_mush_y: bool, default=False.
+    return_y: bool, default=False.
         If True, returns a tuple for both the data and the associated labels
         (0 for edible, 1 for poisonous)
 
@@ -192,27 +202,27 @@ def fetch_mushroom(data_home=None, return_mush_y=False):
         Each unique transaction is represented as a Python list.
 
     (mush, y) : tuple
-        if ``return_D_y`` is True
+        if ``return_y`` is True
 
     Examples
     --------
     >>> from skmine.datasets.fimi import fetch_mushroom
     >>> from skmine.datasets.utils import describe
-    >>> mush, y = fetch_mushroom(return_mush_y=True)
-    >>> describe(mush)['n_items']
-    119
+    >>> X, y = fetch_mushroom(return_y=True)
+    >>> describe(X)['n_items']
+    117
     >>> y.value_counts()
     0    4208
     1    3916
     Name: mushroom, dtype: int64
     """
-    mush = fetch_any("mushroom.dat", data_home=data_home)
-    if return_mush_y:
-        y = mush.str[0]
-        y = y.replace(2, 0)  # 2 is edible, 1 is poisonous
-        return mush, y
-
-    return mush
+    mush = fetch_any("mushroom.dat", base_url=BASE_URL_FIMI, data_home=data_home)
+    if return_y:
+        y = mush.str[0].replace(2, 0)  # 2 is edible, 1 is poisonous
+        X = mush.str[1:]
+        return X, y
+    else:
+        return mush
 
 
 def fetch_pumsb(data_home=None):
@@ -230,8 +240,8 @@ def fetch_pumsb(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -239,7 +249,7 @@ def fetch_pumsb(data_home=None):
         Transactions from the pumsb dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("pumsb.dat", data_home=data_home)
+    return fetch_any("pumsb.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
 def fetch_pumsb_star(data_home=None):
@@ -255,8 +265,8 @@ def fetch_pumsb_star(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -264,7 +274,7 @@ def fetch_pumsb_star(data_home=None):
         Transactions from the pumsb_star dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("pumsb_star.dat", data_home=data_home)
+    return fetch_any("pumsb_star.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
 def fetch_kosarak(data_home=None):
@@ -282,8 +292,8 @@ def fetch_kosarak(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -291,7 +301,7 @@ def fetch_kosarak(data_home=None):
         Transactions from the kosarak dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("kosarak.dat", data_home=data_home)
+    return fetch_any("kosarak.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
 def fetch_retail(data_home=None):
@@ -318,8 +328,8 @@ def fetch_retail(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default,
-        all scikit-mine data is stored in `scikit-mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `scikit-mine_data`.
 
     Returns
     -------
@@ -327,7 +337,7 @@ def fetch_retail(data_home=None):
         Transactions from the retail dataset, as an in-memory pandas Series.
         Each unique transaction is represented as a Python list.
     """
-    return fetch_any("retail.dat", data_home=data_home)
+    return fetch_any("retail.dat", base_url=BASE_URL_FIMI, data_home=data_home)
 
 
 def fetch_accidents(data_home=None):
@@ -347,8 +357,8 @@ def fetch_accidents(data_home=None):
     Parameters
     ----------
     data_home : optional, default: None
-        Specify another download and cache folder for the datasets. By default
-        all scikit-mine data is stored in `~/scikit_mine_data`.
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `~/scikit_mine_data`.
 
     Returns
     -------
@@ -357,4 +367,125 @@ def fetch_accidents(data_home=None):
         Each unique transaction is represented as a Python list.
 
     """
-    return fetch_any("accidents.dat", data_home=data_home)
+    return fetch_any("accidents.dat", base_url=BASE_URL_FIMI, data_home=data_home)
+
+
+def fetch_iris(data_home=None, return_y=False):
+    """Fetch and return the discretized iris dataset (Frequent Itemset Mining)
+
+    This dataset corresponds to the iris dataset which has been discretized into 19 items.
+    The last column (items: 17, 18, 19) corresponds to the targets and can be useful for classification.
+
+    see: https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/exmpleDNnotes.html#iris
+
+    ====================   ==============
+    Nb of items                        19
+    Nb of transactions                150
+    Avg transaction size                5
+    Density                         26.32
+    ====================   ==============
+
+    Parameters
+    ----------
+    data_home : optional, default: None
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `~/scikit_mine_data`.
+
+    return_y : bool, default: False
+        If True, returns a tuple for both the data and the associated labels.
+
+    Returns
+    -------
+    pd.Series
+        Transactions from the iris dataset, as an in-memory pandas Series.
+        Each unique transaction is represented as a Python list.
+
+    """
+    iris = fetch_any("iris.D19.N150.C3.num.gz", base_url=BASE_URL_CGI, data_home=data_home)
+    if return_y:
+        y = iris.str[-1]
+        X = iris.str[:-1]
+        return X, y
+    else:
+        return iris
+
+
+def fetch_breast(data_home=None, return_y=False):
+    """Fetch and return the discretized breast dataset (Frequent Itemset Mining)
+
+    This dataset corresponds to the breast dataset which has been discretized into 20 items.
+    The last column (items: 19, 20) corresponds to the targets and can be useful for classification.
+
+    see: https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/exmpleDNnotes.html#breast
+
+    ====================   ==============
+    Nb of items                        20
+    Nb of transactions                699
+    Avg transaction size             9.98
+    Density                            50
+    ====================   ==============
+
+    Parameters
+    ----------
+    data_home : optional, default: None
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `~/scikit_mine_data`.
+
+    return_y : bool, default: False
+        If True, returns a tuple for both the data and the associated labels.
+
+    Returns
+    -------
+    pd.Series
+        Transactions from the breast dataset, as an in-memory pandas Series.
+        Each unique transaction is represented as a Python list.
+
+    """
+    breast = fetch_any("breast.D20.N699.C2.num", base_url=BASE_URL_CGI, data_home=data_home)
+    if return_y:
+        y = breast.str[-1]
+        X = breast.str[:-1]
+        return X, y
+    else:
+        return breast
+
+
+def fetch_tictactoe(data_home=None, return_y=False):
+    """Fetch and return the discretized tictactoe dataset (Frequent Itemset Mining)
+
+    This dataset corresponds to the tictactoe dataset which has been discretized into 29 items.
+    The last column (items: 28, 29) corresponds to the targets and can be useful for classification.
+
+    see: https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/exmpleDNnotes.html#tictactoe
+
+    ====================   ==============
+    Nb of items                        29
+    Nb of transactions                958
+    Nb of transactions                699
+    Avg transaction size               10
+    Density                         34.48
+    ====================   ==============
+
+    Parameters
+    ----------
+    data_home : optional, default: None
+        Specify another download and cache folder for the datasets.
+        By default, all scikit-mine data is stored in `~/scikit_mine_data`.
+
+    return_y : bool, default: False
+        If True, returns a tuple for both the data and the associated labels.
+
+    Returns
+    -------
+    pd.Series
+        Transactions from the breast dataset, as an in-memory pandas Series.
+        Each unique transaction is represented as a Python list.
+
+    """
+    tictactoe = fetch_any("ticTacToe.D29.N958.C2.num", base_url=BASE_URL_CGI, data_home=data_home)
+    if return_y:
+        y = tictactoe.str[-1]
+        X = tictactoe.str[:-1]
+        return X, y
+    else:
+        return tictactoe
diff --git a/skmine/feature_extraction/slim_vectorizer.py b/skmine/feature_extraction/slim_vectorizer.py
index b3eab35f..52fe393a 100644
--- a/skmine/feature_extraction/slim_vectorizer.py
+++ b/skmine/feature_extraction/slim_vectorizer.py
@@ -5,7 +5,7 @@
 import numpy as np
 import pandas as pd
 
-from ..base import TransformerMixin, _get_tags
+from ..base import TransformerMixin
 from ..itemsets import SLIM
 from ..itemsets.slim import _to_vertical, cover
 
@@ -70,9 +70,7 @@ class SLIMVectorizer(SLIM, TransformerMixin):
     patterns should output matrices with very few zeros.
     """
 
-    def __init__(
-        self, strategy="codes", *, k=5, pruning=False, stop_items=None, **kwargs
-    ):
+    def __init__(self, strategy="codes", *, k=5, pruning=False, stop_items=None, **kwargs):
         super().__init__(**kwargs)
         self.k = k
         self.pruning = pruning
@@ -106,9 +104,8 @@ def transform(self, D, y=None):
         stop_items = self.stop_items or set()
         D_sct, _len = _to_vertical(D, stop_items=stop_items, return_len=True)
 
-        code_lengths = self.discover(
-            usage_tids=False, singletons=True, drop_null_usage=False
-        )
+        code_lengths = self.discover(return_tids=False, singletons=True, drop_null_usage=False)
+        code_lengths = pd.Series(code_lengths["usage"].values, index=code_lengths["itemset"].apply(tuple))
         code_lengths = code_lengths[code_lengths.index.map(set(D_sct).issuperset)]
 
         isets = code_lengths.nlargest(self.k)  # real usages sorted in decreasing order
@@ -124,6 +121,3 @@ def transform(self, D, y=None):
             mat = (mat * ct_codes).astype(np.float32)
 
         return mat
-
-    def _get_tags(self):
-        return {**_get_tags(self), **{"stateless": True}}  # modfies output shape
diff --git a/skmine/graph/graphmdl/code_table.py b/skmine/graph/graphmdl/code_table.py
index c9ce5993..11c4207c 100644
--- a/skmine/graph/graphmdl/code_table.py
+++ b/skmine/graph/graphmdl/code_table.py
@@ -16,7 +16,8 @@ class CodeTable:
         It's composed by the non singleton pattern and their information (usage, ports) who represented by a row
         And the singleton pattern stored in a dictionary if there is one.
 
-        The separation between singleton and non-singleton pattern make easily their treatments and reduces the execution time.
+        The separation between singleton and non-singleton pattern make easily their treatments and reduces the
+        execution time.
 
         Parameters
         ----------
diff --git a/skmine/graph/graphmdl/graph_mdl.py b/skmine/graph/graphmdl/graph_mdl.py
index 24331bfb..e1c43673 100644
--- a/skmine/graph/graphmdl/graph_mdl.py
+++ b/skmine/graph/graphmdl/graph_mdl.py
@@ -27,11 +27,12 @@ class GraphMDL(BaseMiner):
 
         References
         ----------
-         F. Bariatti, "Mining Tractable Sets of Graph Patterns with the Minimum Description Length Principle", PhD thesis, Université de Rennes 1, 2021. Available: https://hal.inria.fr/tel-03523742
-
-         F. Bariatti, P. Cellier, and S. Ferré. "GraphMDL+ : interleaving the generation and MDL-based selection of graph patterns", in Proceedings of the 36th Annual ACM Symposium on Applied Computing, Mar. 2021, pp. 355–363. doi: 10.1145/3412841.3441917.
-
+         F. Bariatti, "Mining Tractable Sets of Graph Patterns with the Minimum Description Length Principle",
+         PhD thesis, Université de Rennes 1, 2021. Available: https://hal.inria.fr/tel-03523742
 
+         F. Bariatti, P. Cellier, and S. Ferré. "GraphMDL+ : interleaving the generation and MDL-based selection of
+         graph patterns", in Proceedings of the 36th Annual ACM Symposium on Applied Computing, Mar. 2021, pp. 355–363.
+         doi: 10.1145/3412841.3441917.
     """
 
     def __init__(self):
diff --git a/skmine/graph/graphmdl/label_codes.py b/skmine/graph/graphmdl/label_codes.py
index 0b3f562e..2ce1fb2b 100644
--- a/skmine/graph/graphmdl/label_codes.py
+++ b/skmine/graph/graphmdl/label_codes.py
@@ -105,4 +105,5 @@ def encode_singleton_edge(self, edge_singleton_label):
         return utils.encode_singleton(self, 2, edge_singleton_label)
 
     def __str__(self) -> str:
-        return "Edge label\n-----------------\n" + self.display_edge_lc() + "\nVertex label\n----------------------\n" + self.display_vertex_lc()
+        return "Edge label\n-----------------\n" + self.display_edge_lc() + "\nVertex label\n----------------------\n" \
+               + self.display_vertex_lc()
diff --git a/skmine/graph/graphmdl/utils.py b/skmine/graph/graphmdl/utils.py
index 3aa8ae45..2f5b8fc9 100644
--- a/skmine/graph/graphmdl/utils.py
+++ b/skmine/graph/graphmdl/utils.py
@@ -585,7 +585,7 @@ def draw_graph(g: Graph):
     pos = nx.spring_layout(g, seed=7)
     edge_labels = dict([((u, v,), d['label']) for u, v, d in g.edges(data=True)])
     node_labels = dict([(u, d['label']) for u, d in g.nodes(data=True) if 'label' in d])
-    nx.draw(g, pos, with_labels=True)
+    nx.draw_networkx(g, pos, with_labels=True)
     nx.draw_networkx_edge_labels(g, pos, edge_labels=edge_labels, font_color="red", font_weight="bold", font_size=14)
     nx.draw_networkx_labels(g, pos, node_labels, font_color="red", font_weight="bold", font_size=14)
 
diff --git a/skmine/itemsets/lcm.py b/skmine/itemsets/lcm.py
index 81472794..11ba8993 100644
--- a/skmine/itemsets/lcm.py
+++ b/skmine/itemsets/lcm.py
@@ -6,7 +6,7 @@
 # Authors: Rémi Adon <remi.adon@gmail.com>
 #          Luis Galárraga <galarraga@luisgalarraga.de>
 #          Hermann Courteille <hermann.courteille@irisa.fr>
-#          Cyril Regan <cyril.regan@irisa.fr>
+#          Cyril Regan <cyril.regan@loria.fr>
 #          Thomas Betton <thomas.betton@irisa.fr>
 #
 # License: BSD 3 clause
@@ -66,12 +66,12 @@ class LCM(BaseMiner, DiscovererMixin):
     >>> lcm = LCM(min_supp=2000)
     >>> patterns = lcm.fit_discover(chess)
     >>> patterns.head()
-        itemset support
-    0      [58]    3195
-    1      [52]    3185
-    2  [58, 52]    3184
-    3      [29]    3181
-    4  [58, 29]    3180
+        itemset  support
+    0      [58]     3195
+    1      [52]     3185
+    2  [52, 58]     3184
+    3      [29]     3181
+    4  [29, 58]     3180
     >>> patterns[patterns.itemset.map(len) > 3]  # doctest: +SKIP
     """
 
@@ -99,6 +99,9 @@ def fit(self, D, y=None):
             a transactional database. All entries in this D should be lists.
             If D is a pandas.Series, then `(D.map(type) == list).all()` should return `True`
 
+        y: Ignored
+            Not used, present here for API consistency by convention.
+
         Raises
         ------
         TypeError
@@ -132,7 +135,7 @@ def fit(self, D, y=None):
 
         return self  # for call .fit().discover() in DiscovererMixin()
 
-    def discover(self, *, return_tids=False, lexicographic_order=False, max_length=-1, out=None):
+    def discover(self, *, return_tids=False, lexicographic_order=True, max_length=-1, out=None):
         """Return the set of closed itemsets, with respect to the minimum support
 
         Parameters
@@ -146,7 +149,7 @@ def discover(self, *, return_tids=False, lexicographic_order=False, max_length=-
             Either to return transaction ids along with itemset.
             Default to False, will return supports instead
 
-        lexicographic_order: bool, default=False
+        lexicographic_order: bool, default=True
             Either the order of the items in each itemset is not ordered or the items are ordered lexicographically
 
         max_length: int, default=-1 Maximum length of an itemset. By default, -1 means that LCM returns itemsets of
@@ -179,18 +182,17 @@ def discover(self, *, return_tids=False, lexicographic_order=False, max_length=-
         >>> from skmine.itemsets import LCM
         >>> D = [[1, 2, 3, 4, 5, 6], [2, 3, 5], [2, 5]]
         >>> LCM(min_supp=2).fit_discover(D, lexicographic_order=True)
-             itemset support
-        0     [2, 5]       3
-        1  [2, 3, 5]       2
+             itemset  support
+        0     [2, 5]        3
+        1  [2, 3, 5]        2
         >>> LCM(min_supp=2).fit_discover(D, return_tids=True)
-             itemset support       tids
-        0     [2, 5]       3  (0, 1, 2)
-        1  [2, 5, 3]       2     (0, 1)
+             itemset  support       tids
+        0     [2, 5]        3  (0, 1, 2)
+        1  [2, 3, 5]        2     (0, 1)
         """
         self.lexicographic_order = lexicographic_order
         self.return_tids = return_tids
         self.max_length = max_length
-
         if out is None:  # store results in memory
             dfs = Parallel(n_jobs=self.n_jobs, prefer="processes")(
                 delayed(self._explore_root)(item, tids, root_file=None) for item, tids in
@@ -198,8 +200,8 @@ def discover(self, *, return_tids=False, lexicographic_order=False, max_length=-
             )  # dfs is a list of dataframe
             # make sure we have something to concat
             columns = ["itemset", "support"] if not self.return_tids else ["itemset", "support", "tids"]
-            dfs.append(pd.DataFrame(columns=columns))
-            df = pd.concat(dfs, axis=0, ignore_index=True)
+            df = pd.concat([pd.DataFrame(columns=columns)] + dfs, axis=0, ignore_index=True)
+            df["support"] = pd.to_numeric(df["support"])
 
             return df
 
diff --git a/skmine/itemsets/slim.py b/skmine/itemsets/slim.py
index 4e689792..131fbe12 100644
--- a/skmine/itemsets/slim.py
+++ b/skmine/itemsets/slim.py
@@ -1,6 +1,10 @@
-"""SLIM pattern discovery"""
+"""SLIM pattern discovery
+based on `https://eda.mmci.uni-saarland.de/pubs/2012/slim_directly_mining_descriptive_patterns-smets,vreeken.pdf
+and https://eda.rg.cispa.io/pres/ida14-slimmer-poster.pdf
+"""
 
 # Authors: Rémi Adon <remi.adon@gmail.com>
+#          Thomas Betton <thomas.betton@irisa.fr>
 # License: BSD 3 clause
 
 from collections import Counter, defaultdict
@@ -9,27 +13,46 @@
 
 import numpy as np
 import pandas as pd
+import time
 from sortedcontainers import SortedDict
 from pyroaring import BitMap as Bitmap
 
-from ..base import BaseMiner, InteractiveMiner, MDLOptimizer
+
+from ..base import BaseMiner, DiscovererMixin, InteractiveMiner, MDLOptimizer
 from ..utils import _check_D, supervised_to_unsupervised
+from sklearn.utils.validation import check_is_fitted
 
 
-def _to_vertical(D, stop_items=set(), return_len=False):
+def _to_vertical(D, stop_items=None, return_len=False):
+    if stop_items is None:
+        stop_items = set()
     res = defaultdict(Bitmap)
     idx = 0
     for idx, transaction in enumerate(D):
         for e in transaction:
-            if e in stop_items:
-                continue
-            res[e].add(idx)
-    if return_len:
+            if e not in stop_items:
+                res[e].add(idx)
+    if return_len:  # correspond to the number of transactions
         return dict(res), idx + 1
     return dict(res)
 
 
 def _log2(values):
+    """
+    This function calculates the log2 of a set of values.
+    Be careful, if one of the values is 0, the function will return 0.
+
+    Parameters
+    ----------
+    values: pd.Series
+        A set of values with a possible index (you can also pass as parameter an np.array without index)
+
+    Returns
+    -------
+    pd.Series
+        The set of values present in "values" after applying the log2 function with the correct index if there was one
+        in a pd.Series.
+    """
     res_index = values.index if isinstance(values, pd.Series) else None
     res = np.zeros(len(values), dtype=np.float32)
     res[values != 0] = np.log2(values[values != 0]).astype(np.float32)
@@ -61,61 +84,7 @@ def cover(sct: dict, itemsets: list):
     return covers
 
 
-def generate_candidates_big(codetable, stack=set(), depth=None):
-    """
-    Generate candidates, but does not sort output by estimated gain
-
-    The result is a python generator, not an in-memory list
-
-    This results in slightly less accurate candidate generation,
-    but avoids computing candidates that will never be evaluated,
-    if coupled with an early stopping strategy.
-
-    Parameters
-    ----------
-    codetable: SortedDict[frozenset, Bitmap]
-        A codetable, sorted in Standard Candidate Order
-
-    stack: set[frozenset], defaut=set()
-        A stack of already seen itemsets, which will not be considered in output
-        Note that this function updates the stack, passed as a reference
-
-    See Also
-    --------
-    generate_candidates
-    """
-    assert isinstance(codetable, SortedDict)
-    depth = depth or int(np.log2(len(codetable)) * 1e2)
-    for idx, (X, X_usage) in enumerate(codetable.items()):
-        Y = codetable.items()[idx + 1: idx + 1 + depth]
-        _best_usage = 0
-        best_XY = None
-        for y, y_usage in Y:
-            XY = X.union(y)
-            if XY in stack:
-                continue
-            stack.add(XY)
-            inter_len = y_usage.intersection_cardinality(X_usage)
-            if inter_len > _best_usage:
-                _best_usage = inter_len
-                best_XY = XY
-
-        if best_XY is not None:
-            yield best_XY, _best_usage
-
-
-def generate_candidates(codetable, stack=set()):
-    """
-    assumes codetable is sorted in Standard Candidate Order
-    """
-    return sorted(
-        generate_candidates_big(codetable, stack=stack),
-        key=lambda e: e[1],
-        reverse=True,
-    )
-
-
-class SLIM(BaseMiner, MDLOptimizer, InteractiveMiner):
+class SLIM(BaseMiner, DiscovererMixin, MDLOptimizer, InteractiveMiner):
     """SLIM: Directly Mining Descriptive Patterns
 
     SLIM looks for a compressed representation of transactional data.
@@ -125,39 +94,31 @@ class SLIM(BaseMiner, MDLOptimizer, InteractiveMiner):
     - provide a natively interpretable modeling of this data
     - make predictions on new data, using this condensed representation as an encoding scheme
 
+    Note: The reconstruction of the initial dataset from the codetable itemsets is lossless.
 
     Parameters
     ----------
-    k: int, default=50
-        Number of non-singleton itemsets to mine.
-        A singleton is an itemset containing a single item.
     pruning: bool, default=True
         Either to activate pruning or not. Pruned itemsets may be useful at
         prediction time, so it is usually recommended to set it to `False`
         to build a classifier. The model will be less concise, but will lead
         to more accurate predictions on average.
-    n_items: int, default=200
-        Number of most frequent items to consider for mining.
-        As SLIM is highly dependant from the set of symbols from which
-        it refines its codetable,
-        lowering this argument will significantly improve runtime.
 
-        Note: The reconstruction is lossless from this set of items. If the input data
-        has more than `n_items` items, then the reconstruction will be lossy w.r.t this
-        input data.
-    tol: float, default=0.5
-        Minimum compression gain (in bits) for a candidate to be accepted
+    max_time : int, default=-1
+        Specify a maximum calculation time before SLIM returns the itemsets. This parameter is in seconds and is useful
+        for large datasets when SLIM may take a long time to return a table code. In addition, after a while, the
+        compression progress of the database gets weaker and weaker, so it may be useful to use this parameter.
 
 
     Examples
     --------
     >>> from skmine.itemsets import SLIM
     >>> D = [['bananas', 'milk'], ['milk', 'bananas', 'cookies'], ['cookies', 'butter', 'tea']]
-    >>> SLIM().fit(D).discover(singletons=True, usage_tids=True)
-    (bananas, milk)    (0, 1)
-    (butter, tea)         (2)
-    (cookies,)         (1, 2)
-    dtype: object
+    >>> SLIM().fit(D).discover(singletons=True, return_tids=True)
+               itemset    tids
+    0  [bananas, milk]  (0, 1)
+    1    [butter, tea]     (2)
+    2        [cookies]  (1, 2)
 
     References
     ----------
@@ -169,51 +130,55 @@ class SLIM(BaseMiner, MDLOptimizer, InteractiveMiner):
         "Slimmer, outsmarting Slim", 2014
     """
 
-    def __init__(
-            self, *, k=50, pruning=True, n_items=200, tol=0.5,
-    ):
-        self.n_items = n_items
-        self.tol = tol
-        self.standard_codetable_ = None
-        self.codetable_ = SortedDict()
-        self.model_size_ = None  # L(CT|D)
-        self.data_size_ = None  # L(D|CT)
+    def __init__(self, *, pruning=True, max_time=-1, items=None):
         self.pruning = pruning
-        self.k = k
+        self.max_time = max_time
+        self.items = items
 
-    def fit(self, D, y=None):  # pylint:disable = too-many-locals
+    def fit(self, X, y=None):  # pylint:disable = too-many-locals
         """fit SLIM on a transactional dataset
 
         This generates new candidate patterns and add those which improve compression,
         iteratibely refining ``self.codetable_``
 
+
         Parameters
         ----------
-        D: iterable of iterables or array-like
+        X: iterable of iterables or array-like
             Transactional dataset, either as an iterable of iterables
             or encoded as tabular binary data
+
+        y: Ignored
+            Not used, present here for API consistency by convention.
         """
-        self.prefit(D, y=y)
-        seen_cands = set()
-        k = 0
+        self.starting_codes_ = None
+        self.standard_codetable_ = None
+        self.codetable_ = SortedDict()
+        self.model_size_ = None  # L(CT|D)
+        self.data_size_ = None  # L(D|CT)
+        self.is_fitted_ = True
 
-        while k < self.k:
+        start = time.time()
+        self.prefit(X, y=y)
+        while True:
+            seen_cands = set(self.codetable_.keys())
             candidates = self.generate_candidates(stack=seen_cands)
+
+            if not candidates:  # if empty candidate generation
+                break
+
             for cand, _ in candidates:
+
                 data_size, model_size, usages = self.evaluate(cand)
                 diff = (self.model_size_ + self.data_size_) - (data_size + model_size)
-
-                if diff >= self.tol:
-                    self.update(
-                        usages=usages, data_size=data_size, model_size=model_size
-                    )
-
-                    k = sum(map(lambda iset: len(iset) > 1, self.codetable_))
-                if k >= self.k:
+                if diff > 0:
+                    self.update(usages=usages, data_size=data_size, model_size=model_size)
                     break
 
-            if not candidates:  # if empty candidate generation
-                Warning(f"could not find `{self.k}` itemsets, try with a lower `tol`")
+            if diff <= 0:  # if no more candidates are found that improve the model, we stop
+                break
+
+            if self.max_time != -1 and time.time() - start > self.max_time:
                 break
 
         return self
@@ -240,7 +205,7 @@ def decision_function(self, D):
         >>> new_D = to_tabular([['cookies', 'butter']])
         >>> slim = SLIM().fit(to_tabular(D))
         >>> slim.decision_function(new_D)
-        0   -1.321928
+        0   -5.584963
         dtype: float32
 
         See Also
@@ -249,31 +214,113 @@ def decision_function(self, D):
         discover
         """
         mat = self.cover(D)
-        code_lengths = self.discover(singletons=True, usage_tids=False)
-        ct_codes = code_lengths / code_lengths.sum()
-        codes = (mat * ct_codes).sum(axis=1).astype(np.float32)
-        # positive sign on log2 to return negative distance : sklearn]
-        r = _log2(codes)
-        r[r == 0] = -np.inf  # zeros would fool a `shortest code wins` strategy
-        return r
-
-    def generate_candidates(self, stack=set()):
+        code_lengths = self.discover(singletons=True, return_tids=False, drop_null_usage=False)
+        # the codetable is Laplace corrected: the usage of each itemset is increased by 1 in order that all seen
+        # items have a code
+        code_lengths["usage"] += 1
+        code_lengths["code"] = _log2(code_lengths["usage"] / code_lengths["usage"].sum())
+        mapping = {tuple(row['itemset']): row['code'] for _, row in code_lengths.iterrows()}
+        codes = mat.replace(True, mapping).sum(axis=1).astype(np.float32)
+        codes[codes == 0] = -np.inf  # zeros would fool a `shortest code wins` strategy
+        return codes
+
+    def generate_candidates(self, stack=None):
         """
-        Generate candidates from the current codetable (SLIM is any-time)
+        Generate candidates  from a copy of the codetable and return the candidates sorted in descending order of
+        estimated gain.
+        For each element of the codetable, the union with each following element is performed and an estimated gain is
+        calculated. If this gain is positive, the union is returned.
 
-        Note that `stack` is updated during the execution of this method.
+        The result is a in-memory list
 
         Parameters
         ----------
-        stack: set[frozenset], default=None
-            a stack of already-seen candidates to be excluded
-
-        Returns
-        -------
-        iterator[tuple(frozenset, Bitmap)]
+        stack: set[frozenset], defaut=set()
+            A stack of already seen itemsets, which will not be considered in output
+            Note that this function updates the stack, passed as a reference
         """
-        ct = SortedDict(self._standard_candidate_order, self.codetable_.items())
-        return generate_candidates(ct, stack=stack)
+        codetable = SortedDict(self.codetable_.items())
+        candidates = []
+
+        if stack is None:
+            stack = set()
+        assert isinstance(codetable, SortedDict)
+
+        for idx, (x, x_usage) in enumerate(codetable.items()):
+            Y = codetable.items()[idx + 1:]
+
+            old_usage_X = len(codetable[x])
+            if old_usage_X == 0:
+                continue
+
+            for y, y_usage in Y:
+                XY = x.union(y)
+                if XY in stack:
+                    continue
+
+                # Gain estimate
+                old_usage_Y = len(codetable[y])
+                if old_usage_Y == 0:
+                    continue
+                new_usage_XY = y_usage.intersection_cardinality(x_usage)
+                if new_usage_XY == 0:
+                    continue
+                new_usage_X = old_usage_X - new_usage_XY
+                new_usage_Y = old_usage_Y - new_usage_XY
+                old_countsum = sum(len(usage) for usage in codetable.values())
+                new_countsum = old_countsum - new_usage_XY
+                old_num_codes_with_non_zero_usage = sum(1 if len(usage) > 0 else 0 for usage in codetable.values())
+                new_num_codes_with_non_zero_usage = old_num_codes_with_non_zero_usage + 1 \
+                                                    - (1 if new_usage_X == 0 else 0) - (1 if new_usage_Y == 0 else 0)
+                log_values = _log2(
+                    np.array([old_usage_X, old_usage_Y, new_usage_XY, new_usage_X, new_usage_Y, old_countsum,
+                              new_countsum]))
+
+                # Estimation of the size of the database gain
+                gain_db_XY = -1 * (
+                        -new_usage_XY * log_values[2] - new_usage_X * log_values[3] + old_usage_X * log_values[0]
+                        - new_usage_Y * log_values[4] + old_usage_Y * log_values[1] + new_countsum *
+                        log_values[6] - old_countsum * log_values[5])
+
+                # Estimation of the size of the codetable gain
+                gain_ct_XY = -log_values[2]
+                old_Y_size_code = sum(self._starting_codes[item] for item in y if item in self._starting_codes)
+                old_X_size_code = sum(self._starting_codes[item] for item in x if item in self._starting_codes)
+                if new_usage_X != old_usage_X:
+                    if new_usage_X != 0 and old_usage_X != 0:
+                        gain_ct_XY -= log_values[3]
+                        gain_ct_XY += log_values[0]
+                    elif old_usage_X == 0:
+                        gain_ct_XY += old_X_size_code
+                        gain_ct_XY -= log_values[3]
+                    elif new_usage_X == 0:
+                        gain_ct_XY -= old_X_size_code
+                        gain_ct_XY += log_values[0]
+
+                if new_usage_Y != old_usage_Y:
+                    if new_usage_Y != 0 and old_usage_Y != 0:
+                        gain_ct_XY -= log_values[4]
+                        gain_ct_XY += log_values[1]
+                    elif old_usage_Y == 0:
+                        gain_ct_XY += old_Y_size_code
+                        gain_ct_XY -= log_values[4]
+                    elif new_usage_Y == 0:
+                        gain_ct_XY += old_Y_size_code
+                        gain_ct_XY -= log_values[1]
+
+                gain_ct_XY += new_num_codes_with_non_zero_usage * log_values[6]
+                gain_ct_XY -= old_num_codes_with_non_zero_usage * log_values[5]
+
+                # Total estimated gain
+                gain_XY = gain_db_XY - gain_ct_XY - min(old_X_size_code, old_Y_size_code)
+
+                stack.add(XY)
+
+                if gain_XY > 0:
+                    candidates.append((XY, gain_XY))
+
+        # sort the itemsets by decreasing order gain
+        return sorted(candidates, key=lambda e: e[1], reverse=True)
 
     def evaluate(self, candidate):
         """
@@ -289,23 +336,20 @@ def evaluate(self, candidate):
         (float, float, dict)
             updated (data size, model size, codetable)
         """
+        # Get the id (``idx``) of the insertion of ``candidate`` in codetable w.r.t the standard cover order
         idx = self.codetable_.bisect(candidate)
         ct = list(self.codetable_)
+        # Insert the candidate to the CT w.r.t the usage order
         ct.insert(idx, candidate)
         D = {k: v.copy() for k, v in self.standard_codetable_.items()}
+        # Get the cover a standard codetable D with CT itemsets
+        # CTc is sorted in Standard Cover Order like D
         CTc = cover(D, ct)
 
-        decreased = set()
-        for iset, usage in self.codetable_.items():  # TODO useless is size is too big
-            if len(CTc[iset]) < len(usage):
-                decreased.add(iset)
-
         data_size, model_size = self._compute_sizes(CTc)
 
         if self.pruning:
-            CTc, data_size, model_size = self._prune(
-                CTc, decreased, model_size, data_size
-            )
+            CTc, data_size, model_size = self._prune(CTc, model_size, data_size)
 
         return data_size, model_size, CTc
 
@@ -341,6 +385,7 @@ def update(self, candidate=None, model_size=None, data_size=None, usages=None):
         if usages is None:
             data_size, model_size, usages = self.evaluate(candidate)
         to_drop = {c for c in self.codetable_.keys() - usages.keys() if len(c) > 1}
+        # deletes itemsets in the codetable before upgrade that do not appear in the new usages and longer than 1
         self.codetable_.update(usages)
         for iset in to_drop:
             del self.codetable_[iset]
@@ -361,9 +406,9 @@ def cover(self, D):
         >>> D = ["ABC", "AB", "BCD"]
         >>> s = SLIM().fit(D)
         >>> s.cover(["BC", "AB"])
-           (A, B)   (B,)   (C,)
-        0   False   True   True
-        1    True  False  False
+           (A, B)   (B,)   (A,)   (C,)
+        0   False   True  False   True
+        1    True  False  False  False
 
         Returns
         -------
@@ -371,68 +416,116 @@ def cover(self, D):
         """
         if hasattr(D, "shape") and len(D.shape) == 2:  # tabular
             D = _check_D(D)
-            D_sct = {
-                k: Bitmap(np.where(D[k])[0])
-                for k in D.columns
-                if k in self.standard_codetable_
-            }
+            D_sct = {k: Bitmap(np.where(D[k])[0]) for k in D.columns if k in self.standard_codetable_}
         else:  # transactional
             D_sct = _to_vertical(D)
 
-        isets = self.discover(singletons=True, usage_tids=False)
-        isets = isets[isets.index.map(set(D_sct).issuperset)]
-        covers = cover(D_sct, isets.index)
+        isets = self.discover(singletons=True, return_tids=False, drop_null_usage=False)
+        isets = [tuple(itemset) for itemset in isets[isets["itemset"].map(set(D_sct).issuperset)]["itemset"].to_list()]
+        covers = cover(D_sct, isets)
 
         mat = np.zeros(shape=(len(D), len(covers)), dtype=bool)
         for idx, tids in enumerate(covers.values()):
             mat[tids, idx] = True
         return pd.DataFrame(mat, columns=list(covers.keys()))
 
-    def discover(self, singletons=False, usage_tids=False, drop_null_usage=True):
+    def discover(self, singletons=True, return_tids=False, lexicographic_order=True, drop_null_usage=True,
+                 return_dl=False, out=None):
         """Get a user-friendly copy of the codetable
 
         Parameters
         ----------
-        singletons: bool, default=False
+        singletons: bool, default=True
             Either to include itemsets of length 1 in the result
-        usage_tids: bool, default=False
-            Either returns the transaction ids for each itemset in tuple format or its codelength
+
+        return_tids: bool, default=False
+            Either returns the tids of each itemset associated with the coverage or simply the usage, i.e. the number of
+            times the itemset is used, if set to False.
+
+        lexicographic_order: bool, default=True
+            Either the order of the items in each itemset is not ordered or the items are ordered lexicographically
+
         drop_null_usage: bool, default=True
             Either to include itemset with no usage in the training data
             (i.e itemsets under cover of other itemsets)
 
+        return_dl: bool, default=False
+            Display the total size of the model L(CT, D) according to MDL (Minimum Description Length) which is equal to
+            the sum of the encoded database size L(D | CT) and the encoded table code size L(CT | D).
+
+        out : str, default=None
+            File where results are written. Discover return None. The file contains in parentheses the usage of the
+            itemset located after the closing parenthesis. If the 'return_tids' option is enabled then the line under
+            each itemset is a line of transaction ids containing the previous itemset.
+
         Example
         -------
         >>> from skmine.itemsets import SLIM
         >>> D = ["ABC", "AB", "BCD"]
-        >>> SLIM().fit(D).discover(singletons=True, usage_tids=True, drop_null_usage=False)
-        (A, B)    (0, 1)
-        (B,)         (2)
-        (A,)          ()
-        (C,)      (0, 2)
-        (D,)         (2)
-        dtype: object
+        >>> SLIM().fit(D).discover(singletons=True, return_tids=True, lexicographic_order=True, drop_null_usage=False)
+          itemset    tids
+        0  [A, B]  (0, 1)
+        1  [B, D]     (2)
+        2     [B]      ()
+        3     [A]      ()
+        4     [C]  (0, 2)
+        5     [D]      ()
 
         Returns
         -------
         pd.Series
             codetable containing patterns and ids of transactions in which they are used
         """
-        s = {
-            tuple(sorted(iset)): tids.copy()
-            for iset, tids in self.codetable_.items()
-            if len(tids) >= drop_null_usage and len(iset) > (not singletons)
-        }
-        s = pd.Series(list(s.values()), index=list(s.keys()))
-        if not usage_tids:
-            s = s.map(len).astype(np.uint32)
-        return s
+        check_is_fitted(self, "is_fitted_")
+
+        itemsets = []
+        itids = []
+        iusages = []
+        for iset, tids in self.codetable_.items():
+            if len(tids) >= drop_null_usage and len(iset) > (not singletons):
+                itemsets.append(sorted(iset)) if lexicographic_order else itemsets.append(list(iset))
+                itids.append(tids) if return_tids else []
+                iusages.append(len(tids))
+
+        if out is not None:
+            with open(out, 'w') as f:
+                for i, (itemset, usage) in enumerate(zip(itemsets, iusages)):
+                    line = "(" + str(usage) + ") " + " ".join(itemset) + "\n"
+                    if return_tids:
+                        line += " ".join(map(str, itids[i])) + "\n"
+                    f.write(line)
+            return None
+        else:
+            df = pd.DataFrame(data={'itemset': itemsets, ('tids' if return_tids else 'usage'): (itids if return_tids
+                                                                                                else iusages)})
+            if return_dl:
+                print("data_size :", self.data_size_)
+                print("model_size :", self.model_size_)
+                print("total_size :", self.data_size_ + self.model_size_)
+            return df
 
     def reconstruct(self):
-        """reconstruct the original data from the current `self.codetable_`"""
-        n_transactions = (
-                max(map(Bitmap.max, filter(lambda e: e, self.codetable_.values()))) + 1
-        )
+        """reconstruct the original data from the current `self.codetable_`. This is possible because SLIM is a
+        lossless algorithm .
+
+        Example
+        -------
+        >>> from skmine.itemsets import SLIM
+        >>> D = ["ABC", "AB", "BCD"]
+        >>> slim = SLIM()
+        >>> slim.fit(D).discover()  # doctest: +SKIP
+        >>> slim.reconstruct()  # doctest: +SKIP
+        0    [A, B, C]
+        1       [A, B]
+        2    [B, C, D]
+        dtype: object
+
+        Returns
+        -------
+        pd.Series
+            original database containing a list of transactions
+        """
+        n_transactions = (max(map(Bitmap.max, filter(lambda e: e, self.codetable_.values()))) + 1)
 
         D = pd.Series([set()] * n_transactions)
         for itemset, tids in self.codetable_.items():
@@ -459,13 +552,11 @@ def get_support(self, *items):
     def _standard_cover_order(self, itemset):
         """
         Returns a tuple associated with an itemset,
-        so that many itemsets can be sorted in Standard Cover Order
+        so that many itemsets can be sorted in Standard Cover Order :
+        |X|↓ supp_D(X) ↓ lexicographically ↑
         """
         return -len(itemset), -len(self.get_support(*itemset)), tuple(itemset)
 
-    def _standard_candidate_order(self, itemset):
-        return -len(self.get_support(*itemset)), -len(itemset), tuple(itemset)
-
     def prefit(self, D, y=None):
         """
         Parameters
@@ -488,22 +579,70 @@ def prefit(self, D, y=None):
                 D = supervised_to_unsupervised(D, y)  # SKLEARN_COMPAT
             item_to_tids = {k: Bitmap(np.where(D[k])[0]) for k in D.columns}
         else:
+            # compute tids for each item in Bitmap
             item_to_tids = _to_vertical(D)
-        sct = pd.Series(item_to_tids)
+        sct = pd.Series(item_to_tids)  # sct for "standard code table"
+        # The usage of an itemset X ∈ CT (Code Table) is the number of transactions t ∈ D which have X in their cover.
+        # A cover(t) is the set of itemsets X ∈ CT used to encode a transaction t
         usage = sct.map(len).astype(np.uint32)
-        usage = usage.nlargest(self.n_items)
+        usage = usage.nlargest(len(sct))
+        # Descending usage sorting
         sct = sct[usage.index]
+
+        # Build Standard Codetable <class 'pandas.core.series.Series'> in usage descending order :
         self.standard_codetable_ = sct
 
-        ct_it = ((frozenset([e]), tids) for e, tids in sct.items())
+        if self.items is not None:
+            # Adds in the standard codetable, the items that do not appear in the transactions. Useful for
+            # classifiers mainly.
+            not_in_sct = [item for item in self.items if item not in self.standard_codetable_]
+            series_to_add = pd.Series([Bitmap() for item in not_in_sct], index=not_in_sct, dtype=object)
+            self.standard_codetable_ = pd.concat([self.standard_codetable_, series_to_add])
+
+        # Convert Standard Codetable pandas.Series in list of (frozenset({.}), Bitmap({...}),...)
+        ct_it = ((frozenset([e]), tids) for e, tids in self.standard_codetable_.items())
+
+        # Sort Standard Codetable in standard_cover_order
         self.codetable_ = SortedDict(self._standard_cover_order, ct_it)
 
+        # Compute the length of the optimal prefix code of itemset X :
+        #     codes(X) =  L(X|CT)  = -log2(usage(X) / ∑_CT usage)
         codes = -_log2(usage / usage.sum())
         self._starting_codes = codes
 
-        # L(code_ST(X)) = L(code_CT(X)), because CT=ST
+        # The encoded size of the code table is then given by
+        # L(CT | D) = ∑_{X∈CT & usage(X)!=0) L(X|ST) + L(X|CT)
+        #
+        # because CT=ST :
+        # L(CT | D) = 2 * ∑_{X∈CT & usage(X)!=0) L(X|ST)
+        #           = 2 * ∑_{X} L(X|ST)
+        #                (as X ∈ ST : usage(X)!=0 because it exists at least one transaction where {X} is in)
+        #           = 2 * codes.sum()
         self.model_size_ = 2 * codes.sum()
 
+        # Compute the length of the encoding of the database D : L(D | CT)
+        #
+        # L(D | CT) is the sum of the sizes of the encoded transactions L(t|CT) for t ∈ D.
+        #
+        #   The length of the encoding of the transaction L(t|CT) is simply the
+        #   sum of the code lengths of the itemsets in its cover :
+        #             L(t|CT) =  ∑_{X∈cover(t)} L(X | CT )
+        #
+        #   As CT=ST  :  X ∈ cover(t) = {X} in t =>
+        #                            L(t|CT)  =  ∑_{ {X} in t } L(X|CT)
+        #                            L(t|CT)  =  ∑_{ {X} in t } codes(X)
+        #
+        #   L(D | CT)   = sum( L(t|CT) for  t∈D  )
+        #               = ∑_{ t ∈ D }  ∑_{  {X} ∈ t   } codes(X)
+        #               = ∑_{{X}∈ I }  ∑_{t ∈ tids(X) } codes(X)   (if we change order of the sum)
+        #               = ∑_{{X}∈ I} usage(X) * codes(X)
+        #
+        # Example : for D =  ['ABC', 'AB', 'BCD']
+        # L(D | CT) =   codes('A') + codes('B') + codes('C')
+        #             + codes('A') + codes('B')
+        #             +              codes('B') + codes('C')  + codes('D')
+        #           = 2codes('A') + 3codes('B') +2codes('C') + 1codes('D')
+        #           = usage('A')*codes('A') + usage('B')*codes('B') + ...
         self.data_size_ = (codes * usage).sum()
 
         return self
@@ -532,22 +671,19 @@ def _compute_sizes(self, codetable):
         codes = -_log2(usages / usages.sum())
 
         counts = Counter(chain(*isets))
-        stand_codes_sum = sum(
-            self._starting_codes[item] * ctr for item, ctr in counts.items()
-        )
+        stand_codes_sum = sum(self._starting_codes[item] * ctr for item, ctr in counts.items())
 
         model_size = stand_codes_sum + codes.sum()  # L(CTc|D) = L(X|ST) + L(X|CTc)
         data_size = (codes * usages).sum()
+
         return data_size, model_size
 
-    def _prune(self, codetable, prune_set, model_size, data_size):
+    def _prune(self, CTc, model_size, data_size):
         """post prune a codetable considering itemsets for which usage has decreased
 
         Parameters
         ----------
-        codetable: SortedDict
-        prune_set: set
-            itemsets in ``codetable`` for which usage has decreased
+        CTc: SortedDict
         model_size: float
             current model_size for ``codetable``
         data_size: float
@@ -556,31 +692,36 @@ def _prune(self, codetable, prune_set, model_size, data_size):
         Returns
         -------
         new_codetable, new_data_size, new_model_size: SortedDict, float, float
-            a tuple containing the pruned codetable, and new model size and data size
-            w.r.t this new codetable
         """
-        prune_set = {k for k in prune_set if len(k) > 1}  # remove singletons
+        prune_set = set()
+        for iset, usage in self.codetable_.items():
+            if len(iset) > 1:
+                # Force the pruning of itemsets longer than 1 that do not appear in the cover. This may prevent
+                # to obtain the optimal code table, but it reduces the complexity of the algorithm
+                if len(CTc[iset]) == 0:
+                    del CTc[iset]
+                # Potentially prune the elements whose use has decreased
+                elif len(CTc[iset]) < len(usage):
+                    prune_set.add(iset)
+
         while prune_set:
-            cand = min(prune_set, key=lambda e: len(codetable[e]))
-            prune_set.discard(cand)
+            cand = min(prune_set, key=lambda e: len(CTc[e]))  # select the element of decreased with the
+            # lowest usage in CTc
+            prune_set.discard(cand)  # remove cand from prune_set
 
-            ct = list(codetable)
+            ct = list(CTc)
             ct.remove(cand)
 
-            D = {
-                k: v.copy() for k, v in self.standard_codetable_.items()
-            }  # TODO avoid data copies
+            D = {k: v.copy() for k, v in self.standard_codetable_.items()}  # TODO avoid data copies
             CTp = cover(D, ct)
-            decreased = {
-                k for k, v in CTp.items() if len(k) > 1 and len(v) < len(codetable[k])
-            }
 
             d_size, m_size = self._compute_sizes(CTp)
 
             if d_size + m_size < model_size + data_size:
-                codetable.update(CTp)
-                del codetable[cand]
+                decreased = {k for k, v in CTp.items() if len(k) > 1 and len(v) < len(CTc[k])}
+                CTc.update(CTp)
+                del CTc[cand]
                 prune_set.update(decreased)
                 data_size, model_size = d_size, m_size
 
-        return codetable, data_size, model_size
+        return CTc, data_size, model_size
diff --git a/skmine/itemsets/slim_classifier.py b/skmine/itemsets/slim_classifier.py
new file mode 100644
index 00000000..9d4fd7b2
--- /dev/null
+++ b/skmine/itemsets/slim_classifier.py
@@ -0,0 +1,101 @@
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.utils.validation import check_is_fitted
+from .slim import SLIM
+
+import numpy as np
+from functools import reduce
+
+
+class SlimClassifier(BaseEstimator, ClassifierMixin):
+    """
+    Classifier using the SLIM compression algorithm. Works for binary and multi-class problems.
+
+    This classifier uses one SLIM instance per class in the database, resulting in a code table per class.
+    To classify a transaction, we simply assign the class belonging to the code table that provides the minimal encoded
+    length for the transaction.
+
+    Parameters
+    ----------
+    items: set, default=None
+        The list of items in the complete dataset not only the training set. This improves the accuracy of the model.
+        Without this set of items, the classifier works but is less good in particular with small datasets.
+
+    pruning: bool, default=False
+        Indicates whether each SLIM classifier enables pruning
+
+    Attributes
+    ----------
+    classes_ : array-like
+        All the unique classes
+
+    models_ : list
+        A list of SLIM instances corresponding to *classes_*
+
+    classes_X_ : list
+        A list where each element is a subset of X and each element contains the transactions of X associated
+        with the class from *classes_*  of the same index
+    """
+
+    def __init__(self, items=None, pruning=False):
+        self.items = items
+        self.pruning = pruning
+
+    def fit(self, X, y):
+        """Fit the model according to the given training data.
+
+        Parameters
+        ----------
+        X: iterable, {array_like}
+            containing n_transactions containing themselves n_items
+
+        y: array-like of shape (n_samples,)
+            Target vector relative to X.
+
+        Returns
+        -------
+        self : object
+            An instance of the estimator
+        """
+        self.classes_ = np.unique(y)
+        self.classes_X_ = []
+        self.models_ = []
+
+        for c in self.classes_:
+            transactions_classes = [transaction for transaction, target in zip(X, y) if target == c]
+            self.classes_X_.append(transactions_classes)
+            self.models_.append(SLIM(items=self.items))
+
+        for model, data in zip(self.models_, self.classes_X_):
+            model.fit(data)
+
+        return self
+
+    def predict(self, X):
+        """Perform classification on samples in X
+
+        Parameters
+        ----------
+        X : iterable containing n_transactions containing themselves n_items
+
+        Returns
+        -------
+        y_pred : np.array of shape (n_samples,)
+            Class labels for samples in X
+        """
+        check_is_fitted(self, "classes_")
+
+        if self.classes_ is None:
+            raise ValueError("fit must be called first.")
+
+        models_scores = {i: model.decision_function(X).values for i, model in enumerate(self.models_)}
+        predictions = []
+
+        for i in range(len(X)):
+            scores = [model[i] for model in models_scores.values()]
+            best_index = scores.index(reduce(lambda x, y: x if abs(y) > abs(x) else y, scores))
+            predictions.append(self.classes_[0] if best_index is None else self.classes_[best_index])
+
+        return np.array(predictions)
+
+    def __copy__(self):
+        return SlimClassifier(items=self.items, pruning=self.pruning)
\ No newline at end of file
diff --git a/skmine/periodic/tree.py b/skmine/periodic/tree.py
index 8a6ff503..2477d49c 100644
--- a/skmine/periodic/tree.py
+++ b/skmine/periodic/tree.py
@@ -16,7 +16,7 @@
 from sortedcontainers import SortedKeyList
 from pyroaring import BitMap as Bitmap
 
-from ..base import BaseMiner, DiscovererMixin, InteractiveMiner
+from ..base import BaseMiner, InteractiveMiner
 from ..utils import bron_kerbosch
 from .cycles import PeriodicCycleMiner, extract_triples, merge_triples
 
@@ -519,7 +519,7 @@ def greedy_cover(candidates: List[Tree], D, dS, k=10, **event_frequencies):
     return big_P
 
 
-class PeriodicPatternMiner(BaseMiner, InteractiveMiner, DiscovererMixin):
+class PeriodicPatternMiner(BaseMiner, InteractiveMiner):
     """
     Mining Periodic Pattern with a MDL criterion
 
diff --git a/skmine/preprocessing/mdlp_discretizer.py b/skmine/preprocessing/mdlp_discretizer.py
index c0d0ba81..468e419a 100644
--- a/skmine/preprocessing/mdlp_discretizer.py
+++ b/skmine/preprocessing/mdlp_discretizer.py
@@ -63,8 +63,8 @@ class MDLPVectDiscretizer(MDLOptimizer):
     Basic block for the implementation of
     "Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning".
 
-    This class operates at a column level, i.e it finds the best cut points for a given feature
-    to fit a the corresponding labels
+    This class operates at a column level, i.e. it finds the best cut points for a given feature
+    to fit a corresponding labels
     """
 
     def __init__(self, min_depth=0):
@@ -79,6 +79,7 @@ def evaluate(self, y, start, end, cut_point):
         Evaluate vector y of size ``end`` - ``start``,
         given a ``cutpoint``
         """
+
         entropy1, k1 = get_entropy_nb_ones(y[start:cut_point])
         entropy2, k2 = get_entropy_nb_ones(y[cut_point:end])
         whole_entropy, k0 = get_entropy_nb_ones(y[start:end])
@@ -86,9 +87,7 @@ def evaluate(self, y, start, end, cut_point):
         N = end - start
 
         part1 = 1 / N * ((cut_point - start) * entropy1 + (end - cut_point) * entropy2)
-        delta = np.log2(pow(3, k0) - 2) - (
-            k0 * whole_entropy - k1 * entropy1 - k2 * entropy2
-        )
+        delta = np.log2(pow(3, k0) - 2) - (k0 * whole_entropy - k1 * entropy1 - k2 * entropy2)
 
         gain = whole_entropy - part1
 
@@ -134,7 +133,7 @@ def fit(self, X, y):
                 search_intervals.append((start, k, depth + 1))
                 search_intervals.append((k, end, depth + 1))
 
-        self.cut_points_ = np.array(list(cut_points))
+        self.cut_points_ = np.array(sorted(list(cut_points)))
         return self
 
 
@@ -181,10 +180,8 @@ class MDLPDiscretizer(BaseMiner):
     """
 
     def __init__(self, random_state=None, n_jobs=1):
-        self.cut_points_ = dict()
         self.random_state = random_state
         self.n_jobs = n_jobs
-        self.discretizers_ = []
 
     def fit(self, X, y):
         """fit the MLDP discretizer on an input matrix ``X``, given a label vector ``y``.
@@ -198,7 +195,11 @@ def fit(self, X, y):
         y : np.ndarray of pd.Series of shape(n_samples,)
             The label vector used to discretize ``X``
         """
+        self.cut_points_ = dict()
+        self.discretizers_ = []
+
         assert y is not None and np.issubdtype(y.dtype, np.integer)
+
         random_state = _check_random_state(self.random_state)
         permutation = random_state.permutation(len(X))
         _X = X.values if isinstance(X, pd.DataFrame) else X
@@ -220,9 +221,13 @@ def fit(self, X, y):
         else:
             self.cut_points_ = dict(enumerate(cut_points))
 
+        # self.is_fitted_ = True
+
         return self
 
     def discover(self):
+        # check_is_fitted(self, "is_fitted_")
+
         """user-friendly view on cut points"""
         return pd.Series(self.cut_points_, dtype=object)
 
@@ -231,6 +236,8 @@ def transform(self, X, y=None):  # pylint: disable=unused-argument
 
         This applies the cutpoints their respective columns
         """
+        # check_is_fitted(self, "is_fitted_")
+
         if isinstance(X, pd.DataFrame) and not set(self.cut_points_) == set(X.columns):
             raise ValueError(f"X columns should be {self.cut_points_.keys()}")
         _X = X.values if isinstance(X, pd.DataFrame) else X
diff --git a/skmine/utils.py b/skmine/utils.py
index 8fccb511..455080b6 100644
--- a/skmine/utils.py
+++ b/skmine/utils.py
@@ -21,17 +21,13 @@ def _check_random_state(seed):
         return np.random.RandomState(seed)
     if isinstance(seed, np.random.RandomState):
         return seed
-    raise ValueError(
-        f"{seed} cannot be used to seed a numpy.random.RandomState instance"
-    )
+    raise ValueError(f"{seed} cannot be used to seed a numpy.random.RandomState instance")
 
 
 def _check_min_supp(min_supp, accept_absolute=True):
     if isinstance(min_supp, int):
         if not accept_absolute:
-            raise ValueError(
-                "Absolute support is prohibited, please provide a float value between 0 and 1"
-            )
+            raise ValueError("Absolute support is prohibited, please provide a float value between 0 and 1")
         if min_supp < 1:
             raise ValueError("Minimum support must be strictly positive")
     elif isinstance(min_supp, float):
@@ -187,15 +183,15 @@ def intersect2d(ar1, ar2, return_indices=True):
     x, y = ar1[x_ind], ar2[y_ind]
     xy_where = np.argwhere((x == y).all(axis=1)).reshape(-1)
     x_ind = x_ind[xy_where]
+
     if return_indices:
         y_ind = y_ind[xy_where]
         return ar1[x_ind], x_ind, y_ind
-    return ar1[x_ind]
+    else:
+        return ar1[x_ind]
 
 
-def _sliding_window_view_dispatcher(
-    x, window_shape, axis=None, *, subok=None, writeable=None
-):
+def _sliding_window_view_dispatcher(x, window_shape, axis=None, *, subok=None, writeable=None):
     return (x,)
 
 
@@ -291,20 +287,13 @@ def sliding_window_view(x, window_shape, axis=None, *, subok=False, writeable=Fa
     if axis is None:
         axis = tuple(range(x.ndim))
         if len(window_shape) != len(axis):
-            raise ValueError(
-                f"Since axis is `None`, must provide "
-                f"window_shape for all dimensions of `x`; "
-                f"got {len(window_shape)} window_shape elements "
-                f"and `x.ndim` is {x.ndim}."
-            )
+            raise ValueError(f"Since axis is `None`, must provide window_shape for all dimensions of `x`; "
+                             f"got {len(window_shape)} window_shape elements and `x.ndim` is {x.ndim}.")
     else:
         axis = normalize_axis_tuple(axis, x.ndim, allow_duplicate=True)
         if len(window_shape) != len(axis):
-            raise ValueError(
-                f"Must provide matching length window_shape and "
-                f"axis; got {len(window_shape)} window_shape "
-                f"elements and {len(axis)} axes elements."
-            )
+            raise ValueError(f"Must provide matching length window_shape and "
+                             f"axis; got {len(window_shape)} window_shape elements and {len(axis)} axes elements.")
 
     out_strides = x.strides + tuple(x.strides[ax] for ax in axis)
 
@@ -315,9 +304,7 @@ def sliding_window_view(x, window_shape, axis=None, *, subok=False, writeable=Fa
             raise ValueError("window shape cannot be larger than input array shape")
         x_shape_trimmed[ax] -= dim - 1
     out_shape = tuple(x_shape_trimmed) + window_shape
-    return as_strided(
-        x, strides=out_strides, shape=out_shape, subok=subok, writeable=writeable
-    )
+    return as_strided(x, strides=out_strides, shape=out_shape, subok=subok, writeable=writeable)
 
 
 def bron_kerbosch(candidates: dict, clique=None, excluded=None, depth=0):
@@ -331,7 +318,7 @@ def bron_kerbosch(candidates: dict, clique=None, excluded=None, depth=0):
     """
     if not candidates and not excluded and clique is not None and len(clique) > 2:
         yield [_ for _ in clique]
-        return
+        return None
 
     # pass None as default arg instead of dict()
     # fix collisions in pytest, really obscure
@@ -339,7 +326,7 @@ def bron_kerbosch(candidates: dict, clique=None, excluded=None, depth=0):
     excluded = excluded or dict()
 
     if depth > 20:
-        return
+        return None
 
     for node, neighbours in list(candidates.items()):
         new_clique = {**{node: neighbours}, **clique}
@@ -350,4 +337,3 @@ def bron_kerbosch(candidates: dict, clique=None, excluded=None, depth=0):
 
         del candidates[node]
         excluded[node] = neighbours
-


Test patch:
diff --git a/skmine/datasets/tests/test_fimi.py b/skmine/datasets/tests/test_fimi.py
index 16402791..4d8d9bec 100644
--- a/skmine/datasets/tests/test_fimi.py
+++ b/skmine/datasets/tests/test_fimi.py
@@ -4,9 +4,18 @@
 import pandas as pd
 
 import pytest
+from urllib.request import urlopen
 
 from skmine.datasets import fimi
-from skmine.datasets import get_data_home
+
+def test_url_fimi():
+    url_fimi = "http://fimi.uantwerpen.be/data/"
+    assert urlopen(url_fimi).getcode() == 200
+
+
+def test_url_cgi():
+    url_cgi = "https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/"
+    assert urlopen(url_cgi).getcode() == 200
 
 
 def test_read_dat_fimi():
@@ -34,7 +43,7 @@ def test_read_dat_text_separator_comma():
 
 
 def test_fetch_any_not_fetched():
-    transactions = fimi.fetch_any('chess.dat', './skmine/datasets/tests/')
+    transactions = fimi.fetch_any('chess.dat', data_home='./skmine/datasets/tests/')
     assert os.path.isfile('./skmine/datasets/tests/chess.dat')
     os.remove('./skmine/datasets/tests/chess.dat')
     assert transactions.name == 'chess'
@@ -43,7 +52,16 @@ def test_fetch_any_not_fetched():
 
 
 def test_fetch_any_already_fetched():
-    transactions = fimi.fetch_any('test_fimi_file_int.dat', './skmine/datasets/tests/')
+    transactions = fimi.fetch_any('test_fimi_file_int.dat', data_home='./skmine/datasets/tests/')
     assert len(transactions) == 4
     assert all(type(item) == int for transaction in transactions for item in transaction)
     pd.testing.assert_series_equal(pd.Series([[1, 2, 3], [4, 5], [2], [8, 9]], name='test_fimi_file_int'), transactions)
+
+
+def test_fetch_any_not_fetched_gz():
+    transactions = fimi.fetch_any("iris.D19.N150.C3.num.gz", base_url="https://cgi.csc.liv.ac.uk/~frans/KDD/Software/LUCS-KDD-DN/DataSets/", data_home="./skmine/datasets/tests/")
+    assert os.path.isfile('./skmine/datasets/tests/iris.D19.N150.C3.num.gz')
+    os.remove('./skmine/datasets/tests/iris.D19.N150.C3.num.gz')
+    assert transactions.name == 'iris.D19.N150.C3.num'
+    assert len(transactions) == 150
+    assert all(type(item) == int for transaction in transactions for item in transaction)
diff --git a/skmine/itemsets/tests/test_slim.py b/skmine/itemsets/tests/test_slim.py
index cfbe5945..95ba7d82 100644
--- a/skmine/itemsets/tests/test_slim.py
+++ b/skmine/itemsets/tests/test_slim.py
@@ -1,13 +1,13 @@
 from itertools import compress
-
 import numpy as np
+import pandas
 import pandas as pd
 import pytest
 from sortedcontainers import SortedDict
 
 from pyroaring import BitMap as Bitmap
 
-from ..slim import SLIM, _to_vertical, generate_candidates
+from ..slim import SLIM, _to_vertical, _log2, cover
 
 
 @pytest.fixture
@@ -15,6 +15,17 @@ def D():
     return pd.Series(["ABC"] * 5 + ["AB", "A", "B"])
 
 
+@pytest.fixture
+def codetable():
+    return SortedDict({
+        frozenset({'bananas'}): Bitmap([0, 1]),
+        frozenset({'cookies'}): Bitmap([1, 2]),
+        frozenset({'milk'}): Bitmap([0, 1]),
+        frozenset({'butter'}): Bitmap([2]),
+        frozenset({'tea'}): Bitmap([2])
+    })
+
+
 def to_tabular_df(D):
     return D.map(list).str.join("|").str.get_dummies(sep="|")
 
@@ -31,6 +42,120 @@ def test_to_vertical(D):
     assert list(vert2.keys()) == list("BC")
 
 
+def test_cover():
+    """
+    A   B   C
+    A   B
+        B   C   D
+    """
+    # D corresponds to the items and the transactions in which they appear, it is the standard code table
+    D = {
+        "B": Bitmap([0, 1, 2]),
+        "A": Bitmap([0, 1]),
+        "C": Bitmap([0, 2]),
+        "D": Bitmap([2])
+    }
+    # ct corresponds to the itemsets on which we want to calculate the cover
+    ct = [
+        frozenset("ABC"),
+        frozenset("AB"),
+        frozenset("BC"),
+        frozenset("A"),
+        frozenset("B"),
+        frozenset("C"),
+        frozenset("D")
+    ]
+    CTc = cover(D, ct)
+
+    assert CTc[frozenset("ABC")] == Bitmap([0])
+    assert CTc[frozenset("AB")] == Bitmap([1])  # AB appears only in tid_1 for usage because ABC is placed before in ct
+    # so the AB of the first transaction has been covered by ABC
+    assert CTc[frozenset("BC")] == Bitmap([2])
+    assert CTc[frozenset("A")] == Bitmap()
+    assert CTc[frozenset("B")] == Bitmap()
+    assert CTc[frozenset("C")] == Bitmap()
+    assert CTc[frozenset("D")] == Bitmap([2])
+
+
+def test_log2():
+    d = {'a': 1, 'b': 2, 'c': 3, 'd': 0}
+    d = pd.Series(data=d, index=['a', 'b', 'c', 'd'])
+    logs = _log2(d)
+
+    assert len(logs) == 4
+    assert logs["a"] == 0
+    assert logs["b"] == 1
+    np.testing.assert_almost_equal(logs["c"], 1.58, 2)
+    assert logs['d'] == 0  # attention : for a value of 0, this function returns 0
+
+
+def test_update_no_candidate_and_usages(D):
+    slim = SLIM().prefit(D)
+    # Raises an AssertionError because the candidate and the uses cannot be None at the same time
+    with pytest.raises(AssertionError):
+        slim.update(candidate=None, model_size=10, data_size=20, usages=None) == AssertionError
+
+
+def test_update_no_candidate(D):
+    slim = SLIM().prefit(D)
+    usages = {
+        frozenset("ABC"): Bitmap([0, 1, 2, 3, 4]),
+        frozenset("A"): Bitmap([5, 6]),
+        frozenset("B"): Bitmap([5, 7])
+    }
+    slim.update(candidate=None, model_size=10, data_size=20, usages=usages)
+
+    assert slim.model_size_ == 10
+    assert slim.data_size_ == 20
+    assert len(slim.codetable_) == 4  # C is always in the code table even if it is not in usages
+    assert slim.codetable_.get(frozenset("ABC")) == Bitmap([0, 1, 2, 3, 4])
+    assert slim.codetable_.get(frozenset("A")) == Bitmap([5, 6])
+    assert slim.codetable_.get(frozenset("B")) == Bitmap([5, 7])
+    assert slim.codetable_.get(frozenset("C")) == Bitmap([0, 1, 2, 3, 4])  # C has not been updated but is present
+
+
+def test_update_no_usages(D):
+    slim = SLIM().prefit(D)
+    model_size = slim.model_size_
+    data_size = slim.data_size_
+    candidate = frozenset("ABC")
+    slim.update(candidate=candidate, model_size=None, data_size=None, usages=None)
+
+    assert slim.model_size_ != model_size
+    assert slim.data_size_ != data_size
+    assert len(slim.codetable_) == 4  # ABC has been added to the table in addition to the 3 singletons (A,B,C)
+    assert slim.codetable_.get(frozenset("ABC")) == Bitmap([0, 1, 2, 3, 4])
+    # the usages of A,B,C have been calculated
+    assert slim.codetable_.get(frozenset("A")) == Bitmap([5, 6])
+    assert slim.codetable_.get(frozenset("B")) == Bitmap([5, 7])
+    assert slim.codetable_.get(frozenset("C")) == Bitmap()  # C has not been updated but is present
+
+
+def test_update_to_drop(D):
+    slim = SLIM().prefit(D)
+    usages = {
+        frozenset("AB"): Bitmap([0, 1, 2, 3, 4, 5]),
+        frozenset("A"): Bitmap([6]),
+        frozenset("B"): Bitmap([7]),
+        frozenset("C"): Bitmap([0, 1, 2, 3, 4])
+    }
+    slim.update(candidate=None, model_size=15, data_size=20, usages=usages)
+    assert slim.codetable_.get(frozenset("AB")) == Bitmap([0, 1, 2, 3, 4, 5])
+    usages = {
+        frozenset("ABC"): Bitmap([0, 1, 2, 3, 4]),
+        frozenset("A"): Bitmap([5, 6]),
+        frozenset("B"): Bitmap([7]),
+        frozenset("C"): Bitmap()
+    }
+    slim.update(candidate=None, model_size=10, data_size=20, usages=usages)
+
+    assert slim.model_size_ == 10
+    assert slim.data_size_ == 20
+    assert len(slim.codetable_) == 4
+    assert slim.codetable_.get(frozenset("AB")) is None  # AB has been removed because it does not appear
+    # in the new usages
+
+
 def test_complex_evaluate():
     """
     A   B   C
@@ -40,7 +165,7 @@ def test_complex_evaluate():
         B   C   D   E
     A   B   C   D   E
     """
-    slim = SLIM()
+    slim = SLIM()  # by default pruning=True
     D = ["ABC", "AB", "AC", "B", "BCDE", "ABCDE"]
     slim.prefit(D)
 
@@ -65,9 +190,9 @@ def test_complex_evaluate():
 
     diff = {k: v for k, v in updated.items() if k in u and u[k] != v}
 
-    assert len(diff) == 3
+    # the BC itemset has been pruned from CTc because its use is now null, so in diff we have only "DE" and "B".
+    assert len(diff) == 2
     assert len(updated[cand]) == 1  # {4}
-    assert len(updated[frozenset("BC")]) == 0  # {4} -> {}
     assert len(updated[frozenset("B")]) == 2  # {3} -> {3, 4}
     assert len(updated[frozenset("DE")]) == 1  # {4, 5} -> {5}
 
@@ -114,41 +239,33 @@ def test_complex_evaluate_2():
     assert len(updated[frozenset("C")]) == 1  # {0, 2} -> {2}
 
 
-def test_generate_candidate_1():
-    codetable = SortedDict(
-        {
-            frozenset("A"): Bitmap(range(0, 7)),
-            frozenset("B"): Bitmap([0, 1, 2, 3, 4, 5, 7]),
-            frozenset("C"): Bitmap(range(0, 5)),
-        }
-    )
-
-    new_candidates = generate_candidates(codetable)
-    assert new_candidates == [
-        (frozenset("AB"), 6),
-        (frozenset("BC"), 5),
-    ]
-
-
-def test_generate_candidate_2():
-    usage = [Bitmap(_) for _ in (range(6), [6], [7], range(5))]
-
-    index = list(map(frozenset, ["AB", "A", "B", "C"]))
-    codetable = SortedDict(zip(index, usage))
-
-    new_candidates = generate_candidates(codetable)
-    assert new_candidates == [(frozenset("ABC"), 5)]
-
+def test_standard_cover_order():
+    D = ["ABC", "ABC", "ABCD", "C"]
+    slim = SLIM().prefit(D)
+    itemsets = slim.codetable_.keys()
+    # support(A) = 3
+    # support(B) = 3
+    # support(C) = 4
+    # support(D) = 1
+    assert itemsets[0] == frozenset("C")  # C has the largest support
+    assert itemsets[1] == frozenset("A")  # A has the same support as B but is before by lexicographic order
+    assert itemsets[2] == frozenset("B")
+    assert itemsets[3] == frozenset("D")  # D has the smallest support
 
-def test_generate_candidate_stack():
-    usage = [Bitmap(_) for _ in (range(6), [6, 7], [6, 8], [])]
+    slim.codetable_.update({frozenset("AB"): Bitmap([0])})
+    assert slim.codetable_.keys()[0] == frozenset("AB")  # AB is the longest itemset
 
-    index = list(map(frozenset, ["ABC", "A", "B", "C"]))
 
-    codetable = SortedDict(zip(index, usage))
+def test_generate_candidate_1():
+    D = ['ABC', 'AB', 'BCD']
+    slim = SLIM().prefit(D)
+    seen_cands = set(slim.codetable_.keys())
+    candidates = slim.generate_candidates(stack=seen_cands)
 
-    new_candidates = generate_candidates(codetable, stack={frozenset("AB")})
-    assert new_candidates == []
+    assert len(candidates) == 2  # only two candidates are returned out of the 6 potentials because only two have an
+    # estimated gain > 0
+    np.testing.assert_almost_equal(candidates[0][1], 2.39, 2)
+    np.testing.assert_almost_equal(candidates[1][1], 2.39, 2)
 
 
 @pytest.mark.parametrize("preproc", [to_tabular_df, _id])
@@ -214,17 +331,24 @@ def test_fit_no_pruning(D, preproc, pass_y):
     y = None if not pass_y else np.array([1] * len(D))
     D = preproc(D)
     self = slim.fit(D, y=y)
-    assert list(self.codetable_) == list(map(frozenset, ["ABC", "AB", "A", "B", "C"]))
+    assert list(self.codetable_) == list(map(frozenset, ["ABC", "AC", "A", "B", "C"]))
 
 
-def test_prune(D):
+def test_prune_usage_null(D):
     slim = SLIM(pruning=False).fit(D)
-    prune_set = [frozenset("AB")]
+    # Codetable :
+    # ABC : 0, 1, 2, 3, 4
+    # AC : x
+    # A : 5, 6
+    # B : 5, 7
+    # C : x
 
     new_codetable, new_data_size, new_model_size = slim._prune(
-        slim.codetable_, prune_set, slim.model_size_, slim.data_size_
+        slim.codetable_, slim.model_size_, slim.data_size_
     )
 
+    # C is present because we do not prune itemsets of length 1 and AC is still removed because his usage is 0 and
+    # because its length is 2
     assert list(new_codetable) == list(map(frozenset, ["ABC", "A", "B", "C"]))
     np.testing.assert_almost_equal(new_data_size, 12.92, 2)
 
@@ -232,17 +356,33 @@ def test_prune(D):
     np.testing.assert_almost_equal(total_enc_size, 26, 0)
 
 
-def test_prune_empty(D):
-    slim = SLIM(pruning=False).fit(D)
-    prune_set = [frozenset("ABC")]
+def test_force_prune_with_evaluate(D):
+    slim = SLIM(pruning=True).prefit(D)
+    _, _, usages = slim.evaluate(frozenset("AC"))
+    slim.codetable_.update(usages)
+    assert frozenset("AC") in usages
+    _, _, usages = slim.evaluate(frozenset("ABC"))
+    assert frozenset("ABC") in usages
+    # AC has been removed because after the addition of ABC, its usage became null.
+    assert frozenset("AC") not in usages
+
 
-    # nothing to prune so we should get the exact same codetable
+def test_prune(D):
+    slim = SLIM(pruning=False).prefit(D)
+    # Add AB in the codetable -> usage(AB) = 6
+    _, _, usages = slim.evaluate(frozenset("AB"))
+    slim.codetable_.update(usages)
+
+    # Add ABC in the codetable -> usage(AB) = 1
+    data_size, model_size, usages = slim.evaluate(frozenset("ABC"))
 
+    # AB no longer improves compression, pruning must remove it
     new_codetable, new_data_size, new_model_size = slim._prune(
-        slim.codetable_, prune_set, slim.model_size_, slim.data_size_
+        usages, slim.model_size_, slim.data_size_
     )
 
-    assert list(new_codetable) == list(map(frozenset, ["ABC", "AB", "A", "B", "C"]))
+    assert data_size + model_size > new_data_size + new_model_size
+    assert list(new_codetable) == list(map(frozenset, ["ABC", "A", "B", "C"]))
 
 
 def test_decision_function(D):
@@ -255,40 +395,12 @@ def test_decision_function(D):
     assert dists.dtype == np.float32
     assert len(dists) == len(new_D)
     np.testing.assert_array_almost_equal(
-        dists.values, np.array([-1.17, -1.17, -1.17, -2.17, -2.17]), decimal=2
+        dists.values, np.array([-4.23, -4.23, -4.23, -5.81, -2.11]), decimal=2
     )
 
 
-def test_cover_discover_compat(D):
-    s = SLIM()
-    s.fit(D)
-    mat = s.discover(usage_tids=False, singletons=True) * s.cover(D)
-    assert mat.notna().sum().all()
-
-
 def test_reconstruct(D):
     slim = SLIM().fit(D)
     s = slim.reconstruct().map("".join)  # originally a string so we have to join
     true_s = pd.Series(["ABC"] * 5 + ["AB", "A", "B"])
     pd.testing.assert_series_equal(s, true_s)
-
-
-@pytest.mark.parametrize("k", [1, 2])
-def test_k(D, k):
-    slim = SLIM(pruning=False, k=k).fit(D)
-    assert len(slim.discover()) == k
-
-
-def test_interactive(D):
-    answers = [True, False]
-    est_usages = [6, 5]
-    slim = SLIM(pruning=False)
-    slim.prefit(D)
-    candidates = slim.generate_candidates()
-    for true_est_usage, (cand, est_usage) in compress(
-        zip(est_usages, candidates), answers
-    ):
-        assert est_usage == true_est_usage
-        slim.update(cand)
-
-    assert len(slim.discover(singletons=False)) == sum(answers)
diff --git a/skmine/itemsets/tests/test_slim_classifier.py b/skmine/itemsets/tests/test_slim_classifier.py
new file mode 100644
index 00000000..262cf673
--- /dev/null
+++ b/skmine/itemsets/tests/test_slim_classifier.py
@@ -0,0 +1,67 @@
+import pytest
+from ..slim_classifier import SlimClassifier
+from ...datasets.fimi import fetch_iris
+
+import pandas as pd
+import numpy as np
+
+
+@pytest.fixture
+def data():
+    y = pd.Series([0, 0, 1, 2, 3, 2])
+    X = pd.Series([[5, 8, 9], [5, 8, 7], [4, 7, 10], [4, 8, 10], [4, 7, 9], [4, 7, 10]])
+    return X, y
+
+
+def test_template_classifier(data):
+    y = data[1]
+    X = data[0]
+    items = set(i for t in X for i in t)
+    clf = SlimClassifier(items=items)
+
+    assert clf.items == {4, 5, 7, 8, 9, 10}
+    assert clf.pruning is False
+
+    clf.fit(X, y)
+    assert hasattr(clf, 'classes_')
+    assert hasattr(clf, 'classes_X_')
+    assert hasattr(clf, 'models_')
+
+    y_pred = clf.predict(X)
+    print(X.shape)
+    assert y_pred.shape == (X.shape[0],)
+
+
+def test_models_(data):
+    y = data[1]
+    X = data[0]
+    items = set(i for t in X for i in t)
+    clf = SlimClassifier(items=items)
+    clf.fit(X, y)
+
+    assert len(clf.models_) == 4
+
+
+def test_classes_(data):
+    y = data[1]
+    X = data[0]
+    items = set(i for t in X for i in t)
+    clf = SlimClassifier(items=items)
+    clf.fit(X, y)
+
+    assert len(clf.classes_) == 4
+    assert [0, 1, 2, 3] in clf.classes_
+
+
+def test_classes_X_(data):
+    y = data[1]
+    X = data[0]
+    items = set(i for t in X for i in t)
+    clf = SlimClassifier(items=items)
+    clf.fit(X, y)
+
+    assert len(clf.classes_X_) == 4
+    assert clf.classes_X_[0] == [X[0], X[1]]
+    assert clf.classes_X_[1] == [X[2]]
+    assert clf.classes_X_[2] == [X[3], X[5]]
+    assert clf.classes_X_[3] == [X[4]]
diff --git a/skmine/tests/test_base.py b/skmine/tests/test_base.py
index 2e9b9f5c..afb22748 100644
--- a/skmine/tests/test_base.py
+++ b/skmine/tests/test_base.py
@@ -13,11 +13,11 @@ def __init__(self, eps=3):
         def fit(self, D):
             self._a = 12
 
-        discover = lambda self: pd.Series(self.__dict__)
+        discover = lambda self: pd.DataFrame()
 
     kwargs = dict(eps=4)
     miner = MyMiner(**kwargs)
-    assert miner.get_params() == kwargs
+    assert miner.get_params() == kwargs  # get_params returns only unprotected attributes so only eps
 
     kwargs.update(eps=10)
     miner.set_params(**kwargs)
@@ -34,10 +34,10 @@ class MyMiner(BaseMiner):
         def fit(self, D, y=None):
             return self
 
-        discover = lambda self: pd.Series(self.__dict__)
+        discover = lambda self: pd.DataFrame()
 
     miner = MyMiner()
-    assert miner.get_params() == dict()
+    assert miner.get_params() == dict()  # compared to the previous test, eps is not an attribute of the class
 
 
 def test_mdl_repr():