diff --git a/notebooks/horus_v1/02-horus-training-news-classifiers-wiki.ipynb b/notebooks/horus_v1/02-horus-training-news-classifiers-wiki.ipynb
index 2f2003d..dcc2dbe 100644
--- a/notebooks/horus_v1/02-horus-training-news-classifiers-wiki.ipynb
+++ b/notebooks/horus_v1/02-horus-training-news-classifiers-wiki.ipynb
@@ -20,7 +20,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -62,7 +62,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -78,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
@@ -232,7 +232,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [
     {
@@ -241,7 +241,7 @@
        "\"\\ndf_other2 = pd.read_csv('./data/raw/dump_dbpedia_other_02.csv', sep='\\t', index_col=0)\\ndf_other3 = pd.read_csv('./data/raw/dump_dbpedia_other_03.csv', sep='\\t', index_col=0)\\ndf_other4 = pd.read_csv('./data/raw/dump_dbpedia_other_04.csv', sep='\\t', index_col=0)\\ndf_other5 = pd.read_csv('./data/raw/dump_dbpedia_other_05.csv', sep='\\t', index_col=0)\\ndf_other6 = pd.read_csv('./data/raw/dump_dbpedia_other_06.csv', sep='\\t', index_col=0)\\ndf_other7 = pd.read_csv('./data/raw/dump_dbpedia_other_07.csv', sep='\\t', index_col=0)\\ndf_other8 = pd.read_csv('./data/raw/dump_dbpedia_other_08.csv', sep='\\t', index_col=0)\\ndf_other9 = pd.read_csv('./data/raw/dump_dbpedia_other_09.csv', sep='\\t', index_col=0)\\ndf_other10 = pd.read_csv('./data/raw/dump_dbpedia_other_10.csv', sep='\\t', index_col=0)\\n\""
       ]
      },
-     "execution_count": 6,
+     "execution_count": 67,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -305,7 +305,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
     {
@@ -398,7 +398,7 @@
        "4  Nikos Ventouras (August 31, 1899 – April 1, 19...  "
       ]
      },
-     "execution_count": 7,
+     "execution_count": 68,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -416,7 +416,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 69,
    "metadata": {},
    "outputs": [
     {
@@ -429,7 +429,7 @@
       "(12292, 4)\n",
       "LOCATION (20000, 4)\n",
       "(20000, 4)\n",
-      "OTHER (20000, 4)\n",
+      "MISC (20000, 4)\n",
       "(19970, 4)\n"
      ]
     }
@@ -462,7 +462,7 @@
     "#aux = [df_other0, df_other1, df_other2, df_other3, df_other4, df_other5, df_other6, df_other7, df_other8, df_other9, df_other10]\n",
     "aux = [df_other0, df_other1]\n",
     "df_other = pd.concat(aux)\n",
-    "print('OTHER', df_other.shape)\n",
+    "print('MISC', df_other.shape)\n",
     "df_other.drop_duplicates(subset =\"label\", keep = False, inplace = True) \n",
     "print(df_other.shape)\n",
     "df_other.to_csv('./data/processed/dump_dbpedia_other.csv', sep='\\t')"
@@ -470,7 +470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -478,26 +478,26 @@
     "df_per['category'] = 'PER'\n",
     "df_org['category'] = 'ORG'\n",
     "df_loc['category'] = 'LOC'\n",
-    "df_other['category'] = 'OTHER'"
+    "df_other['category'] = 'MISC'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "category\n",
-       "LOC      20000\n",
-       "ORG      12292\n",
-       "OTHER    19970\n",
-       "PER      20000\n",
+       "LOC     20000\n",
+       "MISC    19970\n",
+       "ORG     12292\n",
+       "PER     20000\n",
        "Name: s, dtype: int64"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 71,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -511,7 +511,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 72,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -524,16 +524,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Index(['PER', 'ORG', 'LOC', 'OTHER'], dtype='object')"
+       "Index(['PER', 'ORG', 'LOC', 'MISC'], dtype='object')"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 73,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -544,7 +544,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0, 0, 0, ..., 3, 3, 3]),\n",
+       " Index(['PER', 'ORG', 'LOC', 'MISC'], dtype='object'))"
+      ]
+     },
+     "execution_count": 74,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_train['category'].factorize()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -553,7 +574,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [
     {
@@ -599,7 +620,7 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>52292</th>\n",
-       "      <td>OTHER</td>\n",
+       "      <td>MISC</td>\n",
        "      <td>3</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -611,10 +632,10 @@
        "0          PER            0\n",
        "20000      ORG            1\n",
        "32292      LOC            2\n",
-       "52292    OTHER            3"
+       "52292     MISC            3"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 76,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -625,7 +646,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "enc = category_id_df.values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'PER': 0, 'ORG': 1, 'LOC': 2, 'MISC': 3}"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dict(enc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
    "metadata": {},
    "outputs": [
     {
@@ -634,7 +684,7 @@
        "['encoder_4MUC_cat2id_id2cat.joblib']"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 79,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -647,16 +697,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 80,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'PER': 0, 'ORG': 1, 'LOC': 2, 'OTHER': 3}"
+       "{'PER': 0, 'ORG': 1, 'LOC': 2, 'MISC': 3}"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 80,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -667,16 +717,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{0: 'PER', 1: 'ORG', 2: 'LOC', 3: 'OTHER'}"
+       "{0: 'PER', 1: 'ORG', 2: 'LOC', 3: 'MISC'}"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 81,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -687,7 +737,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [
     {
@@ -696,7 +746,7 @@
        "'PER'"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 82,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -707,21 +757,128 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 83,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>s</th>\n",
+       "      <th>label</th>\n",
+       "      <th>type</th>\n",
+       "      <th>abstract</th>\n",
+       "      <th>category</th>\n",
+       "      <th>category_id</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>http://dbpedia.org/resource/Andreas_Ekberg</td>\n",
+       "      <td>Andreas Ekberg</td>\n",
+       "      <td>http://dbpedia.org/ontology/Person</td>\n",
+       "      <td>Andreas Ekberg (born 2 January 1985) is a Swed...</td>\n",
+       "      <td>PER</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>http://dbpedia.org/resource/Danilo_Tognon</td>\n",
+       "      <td>Danilo Tognon</td>\n",
+       "      <td>http://dbpedia.org/ontology/Person</td>\n",
+       "      <td>The Canoeist Danilo Tognon (born October 9, 19...</td>\n",
+       "      <td>PER</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>http://dbpedia.org/resource/Lorine_Livington_P...</td>\n",
+       "      <td>Lorine Livington Pruette</td>\n",
+       "      <td>http://dbpedia.org/ontology/Person</td>\n",
+       "      <td>Lorine Livington Pruette (1896–1977) was an Am...</td>\n",
+       "      <td>PER</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>http://dbpedia.org/resource/Megan_Lawrence</td>\n",
+       "      <td>Megan Lawrence</td>\n",
+       "      <td>http://dbpedia.org/ontology/Person</td>\n",
+       "      <td>Megan Lawrence (born 1972) is an American actr...</td>\n",
+       "      <td>PER</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>http://dbpedia.org/resource/Nikolaos_Ventouras</td>\n",
+       "      <td>Nikolaos Ventouras</td>\n",
+       "      <td>http://dbpedia.org/ontology/Person</td>\n",
+       "      <td>Nikos Ventouras (August 31, 1899 – April 1, 19...</td>\n",
+       "      <td>PER</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                   s  \\\n",
+       "0         http://dbpedia.org/resource/Andreas_Ekberg   \n",
+       "1          http://dbpedia.org/resource/Danilo_Tognon   \n",
+       "2  http://dbpedia.org/resource/Lorine_Livington_P...   \n",
+       "3         http://dbpedia.org/resource/Megan_Lawrence   \n",
+       "4     http://dbpedia.org/resource/Nikolaos_Ventouras   \n",
+       "\n",
+       "                      label                                type  \\\n",
+       "0            Andreas Ekberg  http://dbpedia.org/ontology/Person   \n",
+       "1             Danilo Tognon  http://dbpedia.org/ontology/Person   \n",
+       "2  Lorine Livington Pruette  http://dbpedia.org/ontology/Person   \n",
+       "3            Megan Lawrence  http://dbpedia.org/ontology/Person   \n",
+       "4        Nikolaos Ventouras  http://dbpedia.org/ontology/Person   \n",
+       "\n",
+       "                                            abstract category  category_id  \n",
+       "0  Andreas Ekberg (born 2 January 1985) is a Swed...      PER            0  \n",
+       "1  The Canoeist Danilo Tognon (born October 9, 19...      PER            0  \n",
+       "2  Lorine Livington Pruette (1896–1977) was an Am...      PER            0  \n",
+       "3  Megan Lawrence (born 1972) is an American actr...      PER            0  \n",
+       "4  Nikos Ventouras (August 31, 1899 – April 1, 19...      PER            0  "
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "df_train.head()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 84,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x432 with 1 Axes>"
       ]
@@ -747,7 +904,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 258,
+   "execution_count": 85,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -765,7 +922,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 259,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -775,7 +932,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 260,
+   "execution_count": 87,
    "metadata": {},
    "outputs": [
     {
@@ -788,7 +945,7 @@
        "Name: category_id, dtype: int64"
       ]
      },
-     "execution_count": 260,
+     "execution_count": 87,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -799,7 +956,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 261,
+   "execution_count": 88,
    "metadata": {},
    "outputs": [
     {
@@ -812,7 +969,7 @@
        "Name: category_id, dtype: int64"
       ]
      },
-     "execution_count": 261,
+     "execution_count": 88,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -823,7 +980,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 262,
+   "execution_count": 89,
    "metadata": {},
    "outputs": [
     {
@@ -832,7 +989,7 @@
        "['feature_extract_tfidf_ngram2_5000.joblib']"
       ]
      },
-     "execution_count": 262,
+     "execution_count": 89,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -856,18 +1013,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 263,
+   "execution_count": 90,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "(72262, 5000)"
-      ]
-     },
-     "execution_count": 263,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'features' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-90-ce5d0f26b013>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfeatures\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'features' is not defined"
+     ]
     }
    ],
    "source": [
@@ -876,9 +1034,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 264,
+   "execution_count": 91,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'category_to_id' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-91-d06d8efaf2e6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mN\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mcategory\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcategory_id\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcategory_to_id\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mfeatures_chi2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mchi2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mcategory_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mindices\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfeatures_chi2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'category_to_id' is not defined"
+     ]
+    }
+   ],
    "source": [
     "N = 2\n",
     "for category, category_id in sorted(category_to_id.items()):\n",
@@ -902,7 +1072,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 265,
+   "execution_count": 92,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -911,7 +1081,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 266,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [
     {
@@ -920,7 +1090,7 @@
        "pandas.core.series.Series"
       ]
      },
-     "execution_count": 266,
+     "execution_count": 93,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -931,7 +1101,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 267,
+   "execution_count": 94,
    "metadata": {},
    "outputs": [
     {
@@ -948,18 +1118,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 268,
+   "execution_count": 95,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "72262"
-      ]
-     },
-     "execution_count": 268,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'labels' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-95-ae43f30abac1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'labels' is not defined"
+     ]
     }
    ],
    "source": [
@@ -975,7 +1146,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 269,
+   "execution_count": 96,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1024,7 +1195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 270,
+   "execution_count": 97,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1033,7 +1204,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1053,7 +1224,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 271,
+   "execution_count": 98,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1070,7 +1241,7 @@
        "Name: accuracy, dtype: float64"
       ]
      },
-     "execution_count": 271,
+     "execution_count": 98,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1095,25 +1266,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 281,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['PER', 'ORG', 'LOC', 'OTHER']"
-      ]
-     },
-     "execution_count": 281,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": []
   },
   {
    "cell_type": "code",
-   "execution_count": 282,
+   "execution_count": 99,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1139,7 +1299,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 284,
+   "execution_count": 100,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1167,7 +1327,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 291,
+   "execution_count": 101,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1186,7 +1346,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 504x504 with 2 Axes>"
       ]
@@ -1206,7 +1366,7 @@
       "         PER       0.96      0.95      0.96      6549\n",
       "         ORG       0.92      0.93      0.92      4017\n",
       "         LOC       0.99      0.99      0.99      6676\n",
-      "       OTHER       0.96      0.96      0.96      6605\n",
+      "        MISC       0.96      0.96      0.96      6605\n",
       "\n",
       "    accuracy                           0.96     23847\n",
       "   macro avg       0.96      0.96      0.96     23847\n",
@@ -1235,7 +1395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 286,
+   "execution_count": 102,
    "metadata": {},
    "outputs": [
     {
@@ -1250,7 +1410,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 504x504 with 2 Axes>"
       ]
@@ -1270,7 +1430,7 @@
       "         PER       0.96      0.95      0.95      6549\n",
       "         ORG       0.92      0.92      0.92      4017\n",
       "         LOC       0.99      0.99      0.99      6676\n",
-      "       OTHER       0.95      0.96      0.96      6605\n",
+      "        MISC       0.95      0.96      0.96      6605\n",
       "\n",
       "    accuracy                           0.96     23847\n",
       "   macro avg       0.96      0.96      0.96     23847\n",
@@ -1299,7 +1459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 287,
+   "execution_count": 103,
    "metadata": {},
    "outputs": [
     {
@@ -1314,7 +1474,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 504x504 with 2 Axes>"
       ]
@@ -1334,7 +1494,7 @@
       "         PER       0.95      0.93      0.94      6549\n",
       "         ORG       0.91      0.91      0.91      4017\n",
       "         LOC       0.99      0.99      0.99      6676\n",
-      "       OTHER       0.94      0.95      0.94      6605\n",
+      "        MISC       0.94      0.95      0.94      6605\n",
       "\n",
       "    accuracy                           0.95     23847\n",
       "   macro avg       0.95      0.95      0.95     23847\n",
@@ -1366,7 +1526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 288,
+   "execution_count": 104,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1385,13 +1545,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 289,
+   "execution_count": 105,
    "metadata": {
     "pycharm": {
      "is_executing": true
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'category_to_id' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-105-d625b6cb5b5a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#model.fit(features, labels)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mN\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mcategory\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcategory_id\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msorted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcategory_to_id\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mindices\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margsort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcoef_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcategory_id\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'category_to_id' is not defined"
+     ]
+    }
+   ],
    "source": [
     "#model.fit(features, labels)\n",
     "N = 2\n",
@@ -1408,18 +1580,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 290,
+   "execution_count": 106,
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "20000"
-      ]
-     },
-     "execution_count": 290,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "NameError",
+     "evalue": "name 'subset' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-106-6cb9fbbf29ca>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabstract\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m: name 'subset' is not defined"
+     ]
     }
    ],
    "source": [
@@ -1428,7 +1601,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 107,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1441,7 +1614,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 108,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1474,7 +1647,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": 109,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1487,7 +1660,7 @@
        "False"
       ]
      },
-     "execution_count": 101,
+     "execution_count": 109,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1498,7 +1671,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 110,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1508,10 +1681,10 @@
     {
      "data": {
       "text/plain": [
-       "2697"
+       "0"
       ]
      },
-     "execution_count": 58,
+     "execution_count": 110,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1523,7 +1696,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 111,
    "metadata": {
     "pycharm": {
      "is_executing": true
@@ -1541,7 +1714,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 112,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1550,16 +1723,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 113,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'PER'"
+       "0         PER\n",
+       "1         PER\n",
+       "2         PER\n",
+       "3         PER\n",
+       "4         PER\n",
+       "5         PER\n",
+       "6         PER\n",
+       "7         PER\n",
+       "8         PER\n",
+       "9         PER\n",
+       "10        PER\n",
+       "11        PER\n",
+       "12        PER\n",
+       "13        PER\n",
+       "14        PER\n",
+       "15        PER\n",
+       "16        PER\n",
+       "17        PER\n",
+       "18        PER\n",
+       "19        PER\n",
+       "20        PER\n",
+       "21        PER\n",
+       "22        PER\n",
+       "23        PER\n",
+       "24        PER\n",
+       "25        PER\n",
+       "26        PER\n",
+       "27        PER\n",
+       "28        PER\n",
+       "29        PER\n",
+       "         ... \n",
+       "72232    MISC\n",
+       "72233    MISC\n",
+       "72234    MISC\n",
+       "72235    MISC\n",
+       "72236    MISC\n",
+       "72237    MISC\n",
+       "72238    MISC\n",
+       "72239    MISC\n",
+       "72240    MISC\n",
+       "72241    MISC\n",
+       "72242    MISC\n",
+       "72243    MISC\n",
+       "72244    MISC\n",
+       "72245    MISC\n",
+       "72246    MISC\n",
+       "72247    MISC\n",
+       "72248    MISC\n",
+       "72249    MISC\n",
+       "72250    MISC\n",
+       "72251    MISC\n",
+       "72252    MISC\n",
+       "72253    MISC\n",
+       "72254    MISC\n",
+       "72255    MISC\n",
+       "72256    MISC\n",
+       "72257    MISC\n",
+       "72258    MISC\n",
+       "72259    MISC\n",
+       "72260    MISC\n",
+       "72261    MISC\n",
+       "Name: category, Length: 72262, dtype: object"
       ]
      },
-     "execution_count": 79,
+     "execution_count": 113,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1567,6 +1801,41 @@
    "source": [
     "df_train.category"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/horus_v1/encoder_4MUC_cat2id_id2cat.joblib b/notebooks/horus_v1/encoder_4MUC_cat2id_id2cat.joblib
index 190b2f9..33d2ee6 100644
Binary files a/notebooks/horus_v1/encoder_4MUC_cat2id_id2cat.joblib and b/notebooks/horus_v1/encoder_4MUC_cat2id_id2cat.joblib differ
diff --git a/notebooks/horus_v1/feature_extract_tfidf_ngram2_5000.joblib b/notebooks/horus_v1/feature_extract_tfidf_ngram2_5000.joblib
index c3eb349..30f34ea 100644
Binary files a/notebooks/horus_v1/feature_extract_tfidf_ngram2_5000.joblib and b/notebooks/horus_v1/feature_extract_tfidf_ngram2_5000.joblib differ
diff --git a/notebooks/horus_v1/multi_cls-calib_linear.joblib b/notebooks/horus_v1/multi_cls-calib_linear.joblib
index 15e70e5..d16088c 100644
Binary files a/notebooks/horus_v1/multi_cls-calib_linear.joblib and b/notebooks/horus_v1/multi_cls-calib_linear.joblib differ
diff --git a/notebooks/horus_v1/ovr_cls-linearSVC.joblib b/notebooks/horus_v1/ovr_cls-linearSVC.joblib
index b065059..9a2f11c 100644
Binary files a/notebooks/horus_v1/ovr_cls-linearSVC.joblib and b/notebooks/horus_v1/ovr_cls-linearSVC.joblib differ
diff --git a/scripts/05_feature_extraction.py b/scripts/05_feature_extraction.py
index e364fe4..1bf7e0b 100644
--- a/scripts/05_feature_extraction.py
+++ b/scripts/05_feature_extraction.py
@@ -40,7 +40,7 @@
                 config.logger.info(f'finish ok?: {out}')
                 horus.update_status(PRE_PROCESSING_STATUS["FEATURE_LEXICAL"])
             else:
-                config.logger.info('feature extraction (lexical): either not active or already cached')
+                config.logger.info('feature extraction (lexical): either not active or already processed')
 
             if EXTRACT_IMAGE and (str(PRE_PROCESSING_STATUS["FEATURE_IMAGE"]) not in str(horus.processing_status)):
                 config.logger.info('feature extraction (image)')
@@ -48,7 +48,7 @@
                 config.logger.info(f'finish ok?: {out}')
                 horus.update_status(PRE_PROCESSING_STATUS["FEATURE_IMAGE"])
             else:
-                config.logger.info('feature extraction (image): either not active or already cached')
+                config.logger.info('feature extraction (image): either not active or already processed')
 
             if EXTRACT_TEXT and (str(PRE_PROCESSING_STATUS["FEATURE_TEXT"]) not in str(horus.processing_status)):
                 config.logger.info('feature extraction (text)')
@@ -56,7 +56,7 @@
                 config.logger.info(f'finish ok?: {out}')
                 horus.update_status(PRE_PROCESSING_STATUS["FEATURE_TEXT"])
             else:
-                config.logger.info('feature extraction (text): either not active or already cached')
+                config.logger.info('feature extraction (text): either not active or already processed')
 
             config.logger.info('done! saving files')
             horus_file_stage3_simple_json = conll_file.replace('.horusx', '.horus3.simple.json')
@@ -64,7 +64,7 @@
 
             # TODO: for now I am saving in a different json file just to compare and check things are fine.
             # later just update the status of the horus file (definitions.PRE_PROCESSING_STATUS)
-            #HorusDataLoader.save_metadata_to_file(horus=horus, file=horus_file_stage3_simple_json, simple_json=True)
+            HorusDataLoader.save_metadata_to_file(horus=horus, file=horus_file_stage3_simple_json, simple_json=True)
             HorusDataLoader.save_metadata_to_file(horus=horus, file=horus_file_stage3, simple_json=False)
 
             config.logger.info('hooray!')
diff --git a/src/definitions.py b/src/definitions.py
index 9c50b6c..39de2ec 100644
--- a/src/definitions.py
+++ b/src/definitions.py
@@ -127,13 +127,13 @@
 NER_TAGS.extend(NER_TAGS_LOC)
 NER_TAGS.extend(NER_TAGS_MISC)
 
-# PER, LOC, ORG and MISC
-PLOMNone_index2label = {1: "LOC", 2: "ORG", 3: "PER", 4: "MISC", 5: "O"} #KLASSES
-PLOMNone_label2index = {"LOC": 1, "ORG": 2, "PER": 3, "MISC": 4, "O": 5} #KLASSES2
-PLOM_index2label = PLOMNone_index2label.copy()
-del PLOM_index2label[5]
-# not testing MISC for now
-del PLOM_index2label[4]
+# PER, ORG, LOC and MISC
+encoder_4MUC_NER_idx2category = {0: "O", 1: "PER", 2: "ORG", 3: "LOC", 4: "MISC"} #KLASSES
+encoder_4MUC_NER_category2idx = {"O": 0, "PER": 1, "ORG": 2, "LOC": 3, "MISC": 4} #KLASSES2
+#PLOM_index2label = encoder_4MUC_NER_idx2category.copy()
+#del PLOM_index2label[5]
+## not testing MISC for now
+#del PLOM_index2label[4]
 
 header = 'cross-validation\tconfig\trun\tlabel\tprecision\trecall\tf1\tsupport\talgo\tdataset1\tdataset2\ttask\n'
 line = '%s\t%s\t%s\t%s\t%.5f\t%.5f\t%.5f\t%s\t%s\t%s\t%s\t%s\n'
@@ -141,13 +141,13 @@
 def tags_to_3muc_simple(tags):
     for i in range(len(tags)):
         if tags[i] in NER_TAGS_PER:
-            tags[i] = PLOMNone_label2index['PER']
+            tags[i] = encoder_4MUC_NER_category2idx['PER']
         elif tags[i] in NER_TAGS_ORG:
-            tags[i] = PLOMNone_label2index['ORG']
+            tags[i] = encoder_4MUC_NER_category2idx['ORG']
         elif tags[i] in NER_TAGS_LOC:
-            tags[i] = PLOMNone_label2index['LOC']
+            tags[i] = encoder_4MUC_NER_category2idx['LOC']
         else:
-            tags[i] = PLOMNone_label2index['O']
+            tags[i] = encoder_4MUC_NER_category2idx['O']
     return tags
 
 
diff --git a/src/features/horus_feature_extraction.py b/src/features/horus_feature_extraction.py
index 6ef301d..26ba492 100644
--- a/src/features/horus_feature_extraction.py
+++ b/src/features/horus_feature_extraction.py
@@ -98,16 +98,16 @@ def __init__(self, config: HorusConfig):
         super().__init__(config)
         self.translator = BingTranslator(self.config)
         self.text_bow = BowTfidf(self.config)
-        self.config.logger.info('Loading Word2Vec embeddings...')
+        self.config.logger.info('Loading embeddings')
         self.word2vec_google = gensim.models.KeyedVectors.load_word2vec_format(self.config.embeddings_path, binary=True)
-        self.config.logger.info('Loading Topic Modeling')
+        self.config.logger.info('Loading topic modeling')
         self.text_tm = TopicModelingShortCNN(self.config, w2v=self.word2vec_google, mode='test')
         self.extended_seeds_PER = []
         self.extended_seeds_ORG = []
         self.extended_seeds_LOC = []
         self.extended_seeds_NONE = []
         self.min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))
-        self.config.logger.info('Setting the seeds ')
+        self.config.logger.info('Setting seeds ')
         self.__set_str_extended_seeds()
 
     def __get_translated_text(self, id):
@@ -258,8 +258,17 @@ def __set_str_extended_seeds(self):
         except:
             raise
 
+    def __get_basic_stats(self, vec: np.array()) -> []:
+
+        _sum = [np.sum(vec[:, 0]), np.sum(vec[:, 1]), np.sum(vec[:, 2]), np.sum(vec[:, 3])]
+        _avg = [np.average(vec[:, 0]), np.average(vec[:, 1]), np.average(vec[:, 2]), np.average(vec[:, 3])]
+        _max = [np.max(vec[:, 0]), np.max(vec[:, 1]), np.max(vec[:, 2]), np.max(vec[:, 3])]
+        _min = [np.min(vec[:, 0]), np.min(vec[:, 1]), np.min(vec[:, 2]), np.min(vec[:, 3])]
+
+        return _sum, _avg, _max, _min
+
     def __set_token_statistics(self, token: HorusToken, y_bow: np.array, y_tm: np.array, limit_txt: int,
-                               nr_results_txt: int, tx_dict: dict, tx_dict_reversed: dict):
+                               nr_results_txt: int, tx_dict: dict, tx_dict_rev: dict):
         try:
 
             self.config.logger.info("token statistics")
@@ -268,7 +277,6 @@ def __set_token_statistics(self, token: HorusToken, y_bow: np.array, y_tm: np.ar
             tot_error_translation = 0
             klass_top = []
             tm_cnn_w = []
-            tm_cnn_w_exp = []
 
             embs, top5_sim = self.__get_number_classes_in_embeedings(token.text)
             if self.text_tm.wvmodel is not None:
@@ -293,136 +301,118 @@ def __set_token_statistics(self, token: HorusToken, y_bow: np.array, y_tm: np.ar
             # top 5 most similar predictions
             klass_top = np.array(klass_top)
 
-            gpb = [np.count_nonzero(yyb == 1),
-                   np.count_nonzero(yyb == 2),
-                   np.count_nonzero(yyb == 3),
-                   np.count_nonzero(yyb == 4)]
+            gpb = [np.count_nonzero(yyb == self.text_bow.category2idx['PER']),
+                   np.count_nonzero(yyb == self.text_bow.category2idx['ORG']),
+                   np.count_nonzero(yyb == self.text_bow.category2idx['LOC']),
+                   np.count_nonzero(yyb == self.text_bow.category2idx['MISC'])]
 
-            topic_klass_top_sums = [np.sum(klass_top[:, 0]), np.sum(klass_top[:, 1]),
-                                    np.sum(klass_top[:, 2]), np.sum(klass_top[:, 3])]
-            topic_klass_top_avg = [np.average(klass_top[:, 0]), np.average(klass_top[:, 1]),
-                                   np.average(klass_top[:, 2]), np.average(klass_top[:, 3])]
-            topic_klass_top_max = [np.max(klass_top[:, 0]), np.max(klass_top[:, 1]),
-                                   np.max(klass_top[:, 2]), np.max(klass_top[:, 3])]
-            topic_klass_top_min = [np.min(klass_top[:, 0]), np.min(klass_top[:, 1]),
-                                   np.min(klass_top[:, 2]), np.min(klass_top[:, 3])]
+            tm_k_top_sum, tm_k_top_avg, tm_k_top_max, tm_k_top_min = self.__get_basic_stats(klass_top)
 
-            topic_sums = [np.sum(y_tm[:, 0]), np.sum(y_tm[:, 1]), np.sum(y_tm[:, 2]), np.sum(y_tm[:, 3])]
-            topic_avg = [np.average(y_tm[:, 0]), np.average(y_tm[:, 1]), np.average(y_tm[:, 2]),
-                         np.average(y_tm[:, 3])]
-            topic_max = [np.max(y_tm[:, 0]), np.max(y_tm[:, 1]), np.max(y_tm[:, 2]), np.max(y_tm[:, 3])]
-            topic_min = [np.min(y_tm[:, 0]), np.min(y_tm[:, 1]), np.min(y_tm[:, 2]), np.min(y_tm[:, 3])]
+            topic_sums, topic_avg, topic_max, topic_min = self.__get_basic_stats(y_tm)
 
-            horus_tx_ner = gpb.index(max(gpb)) + 1
+            # note that encoders for text and cv might have a different klass id from the NER klass id
+            # we should always interchange per label instead of klass id in this particular case
+            horus_tx_ner_label = self.text_bow.idx2category(gpb.index(max(gpb)))
 
             avg_probs_model1 = np.average(yym1)
             avg_probs_model2 = np.average(yym2)
 
-            token.features.text.values[tx_dict_reversed.get('total.retrieved.results.search_engine')] = limit_txt
-            token.features.text.values[tx_dict_reversed.get('total.error.translation')] = tot_error_translation
+            token.features.text.values[tx_dict_rev.get('total.retrieved.results.search_engine')] = limit_txt
+            token.features.text.values[tx_dict_rev.get('total.error.translation')] = tot_error_translation
 
-            token.features.text.values[tx_dict_reversed.get('total.ovr.k.loc')] = gpb[self.text_bow.category2idx['LOC']]
-            token.features.text.values[tx_dict_reversed.get('total.ovr.k.org')] = gpb[self.text_bow.category2idx['ORG']]
-            token.features.text.values[tx_dict_reversed.get('total.ovr.k.per')] = gpb[self.text_bow.category2idx['PER']]
-            token.features.text.values[tx_dict_reversed.get('total.ovr.k.other')] = gpb[
-                self.text_bow.category2idx['OTHER']]
+            token.features.text.values[tx_dict_rev.get('total.ovr.k.loc')] = gpb[self.text_bow.category2idx['LOC']]
+            token.features.text.values[tx_dict_rev.get('total.ovr.k.org')] = gpb[self.text_bow.category2idx['ORG']]
+            token.features.text.values[tx_dict_rev.get('total.ovr.k.per')] = gpb[self.text_bow.category2idx['PER']]
+            token.features.text.values[tx_dict_rev.get('total.ovr.k.misc')] = gpb[self.text_bow.category2idx['MISC']]
 
-            token.features.text.values[tx_dict_reversed.get('avg.probs1.k.loc')] = avg_probs_model1[
+            token.features.text.values[tx_dict_rev.get('avg.probs1.k.loc')] = avg_probs_model1[
                 self.text_bow.category2idx['LOC']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs1.k.org')] = avg_probs_model1[
+            token.features.text.values[tx_dict_rev.get('avg.probs1.k.org')] = avg_probs_model1[
                 self.text_bow.category2idx['ORG']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs1.k.per')] = avg_probs_model1[
+            token.features.text.values[tx_dict_rev.get('avg.probs1.k.per')] = avg_probs_model1[
                 self.text_bow.category2idx['PER']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs1.k.other')] = avg_probs_model1[
-                self.text_bow.category2idx['OTHER']]
+            token.features.text.values[tx_dict_rev.get('avg.probs1.k.misc')] = avg_probs_model1[
+                self.text_bow.category2idx['MISC']]
 
-            token.features.text.values[tx_dict_reversed.get('avg.probs2.k.per')] = avg_probs_model2[
+            token.features.text.values[tx_dict_rev.get('avg.probs2.k.per')] = avg_probs_model2[
                 self.text_bow.category2idx['PER']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs2.k.org')] = avg_probs_model2[
+            token.features.text.values[tx_dict_rev.get('avg.probs2.k.org')] = avg_probs_model2[
                 self.text_bow.category2idx['ORG']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs2.k.loc')] = avg_probs_model2[
+            token.features.text.values[tx_dict_rev.get('avg.probs2.k.loc')] = avg_probs_model2[
                 self.text_bow.category2idx['LOC']]
-            token.features.text.values[tx_dict_reversed.get('avg.probs2.k.other')] = avg_probs_model2[
-                self.text_bow.category2idx['OTHER']]
-
-            token.features.text.values[tx_dict_reversed.get('total.topic.k.loc')] = 0 if len(tm_cnn_w) == 0 else \
-            tm_cnn_w[0]
-            token.features.text.values[tx_dict_reversed.get('total.topic.k.org')] = 0 if len(tm_cnn_w) == 0 else \
-            tm_cnn_w[1]
-            token.features.text.values[tx_dict_reversed.get('total.topic.k.per')] = 0 if len(tm_cnn_w) == 0 else \
-            tm_cnn_w[2]
-            token.features.text.values[tx_dict_reversed.get('total.topic.k.other')] = 0 if len(tm_cnn_w) == 0 else \
-            tm_cnn_w[3]
+            token.features.text.values[tx_dict_rev.get('avg.probs2.k.misc')] = avg_probs_model2[
+                self.text_bow.category2idx['MISC']]
+
+            token.features.text.values[tx_dict_rev.get('total.topic.k.loc')] = 0 if len(tm_cnn_w) == 0 else tm_cnn_w[0]
+            token.features.text.values[tx_dict_rev.get('total.topic.k.org')] = 0 if len(tm_cnn_w) == 0 else tm_cnn_w[1]
+            token.features.text.values[tx_dict_rev.get('total.topic.k.per')] = 0 if len(tm_cnn_w) == 0 else tm_cnn_w[2]
+            token.features.text.values[tx_dict_rev.get('total.topic.k.misc')] = 0 if len(tm_cnn_w) == 0 else tm_cnn_w[3]
 
             if len(tm_cnn_w) != 0:
-                horus_tx_ner_cnn = gpb.index(max(tm_cnn_w)) + 1
+                horus_tx_ner_cnn = tm_cnn_w.index(max(tm_cnn_w)) + 1
             else:
-                horus_tx_ner_cnn = self.text_bow.category2idx['OTHER'] # forcing NONE
+                horus_tx_ner_cnn = self.text_bow.category2idx['MISC'] # forcing NONE
 
             maxs_tx = heapq.nlargest(2, gpb)
             maxs_tm = 0 if len(tm_cnn_w) == 0 else heapq.nlargest(2, tm_cnn_w)
             dist_tx_indicator = max(maxs_tx) - min(maxs_tx)
             dist_tx_indicator_tm = 0 if np.sum(y_tm[:,]) == 0 else (max(maxs_tm) - min(maxs_tm))
 
-            token.features.text.values[tx_dict_reversed.get('dist.k')] = dist_tx_indicator
-            token.features.text.values[tx_dict_reversed.get('dist.k.topic_model')] = dist_tx_indicator_tm
-            token.features.text.values[tx_dict_reversed.get('total.results.search_engine')] = nr_results_txt
-
-            token.features.text.values[tx_dict_reversed.get('total.emb.similar.loc')] = embs[0]
-            token.features.text.values[tx_dict_reversed.get('total.emb.similar.org')] = embs[1]
-            token.features.text.values[tx_dict_reversed.get('total.emb.similar.per')] = embs[2]
-            token.features.text.values[tx_dict_reversed.get('total.emb.similar.other')] = embs[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.sum.loc')] = topic_klass_top_sums[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.sum.org')] = topic_klass_top_sums[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.sum.per')] = topic_klass_top_sums[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.sum.other')] = topic_klass_top_sums[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.avg.loc')] = topic_klass_top_avg[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.avg.org')] = topic_klass_top_avg[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.avg.per')] = topic_klass_top_avg[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.avg.other')] = topic_klass_top_avg[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.max.loc')] = topic_klass_top_max[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.max.org')] = topic_klass_top_max[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.max.per')] = topic_klass_top_max[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.max.other')] = topic_klass_top_max[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.min.loc')] = topic_klass_top_min[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.min.org')] = topic_klass_top_min[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.min.per')] = topic_klass_top_min[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.top.k.min.other')] = topic_klass_top_min[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.sum.loc')] = topic_sums[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.sum.org')] = topic_sums[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.sum.per')] = topic_sums[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.sum.other')] = topic_sums[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.avg.loc')] = topic_avg[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.avg.org')] = topic_avg[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.avg.per')] = topic_avg[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.avg.other')] = topic_avg[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.max.loc')] = topic_max[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.max.org')] = topic_max[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.max.per')] = topic_max[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.max.other')] = topic_max[3]
-
-            token.features.text.values[tx_dict_reversed.get('stats.topic.min.loc')] = topic_min[0]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.min.org')] = topic_min[1]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.min.per')] = topic_min[2]
-            token.features.text.values[tx_dict_reversed.get('stats.topic.min.other')] = topic_min[3]
+            token.features.text.values[tx_dict_rev.get('dist.k')] = dist_tx_indicator
+            token.features.text.values[tx_dict_rev.get('dist.k.topic_model')] = dist_tx_indicator_tm
+            token.features.text.values[tx_dict_rev.get('total.results.search_engine')] = nr_results_txt
+
+            token.features.text.values[tx_dict_rev.get('total.emb.similar.loc')] = embs[0]
+            token.features.text.values[tx_dict_rev.get('total.emb.similar.org')] = embs[1]
+            token.features.text.values[tx_dict_rev.get('total.emb.similar.per')] = embs[2]
+            token.features.text.values[tx_dict_rev.get('total.emb.similar.misc')] = embs[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.sum.loc')] = tm_k_top_sum[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.sum.org')] = tm_k_top_sum[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.sum.per')] = tm_k_top_sum[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.sum.misc')] = tm_k_top_sum[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.avg.loc')] = tm_k_top_avg[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.avg.org')] = tm_k_top_avg[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.avg.per')] = tm_k_top_avg[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.avg.misc')] = tm_k_top_avg[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.max.loc')] = tm_k_top_max[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.max.org')] = tm_k_top_max[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.max.per')] = tm_k_top_max[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.max.misc')] = tm_k_top_max[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.min.loc')] = tm_k_top_min[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.min.org')] = tm_k_top_min[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.min.per')] = tm_k_top_min[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.top.k.min.misc')] = tm_k_top_min[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.sum.loc')] = topic_sums[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.sum.org')] = topic_sums[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.sum.per')] = topic_sums[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.sum.misc')] = topic_sums[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.avg.loc')] = topic_avg[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.avg.org')] = topic_avg[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.avg.per')] = topic_avg[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.avg.misc')] = topic_avg[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.max.loc')] = topic_max[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.max.org')] = topic_max[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.max.per')] = topic_max[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.max.misc')] = topic_max[3]
+
+            token.features.text.values[tx_dict_rev.get('stats.topic.min.loc')] = topic_min[0]
+            token.features.text.values[tx_dict_rev.get('stats.topic.min.org')] = topic_min[1]
+            token.features.text.values[tx_dict_rev.get('stats.topic.min.per')] = topic_min[2]
+            token.features.text.values[tx_dict_rev.get('stats.topic.min.misc')] = topic_min[3]
 
             if limit_txt != 0:
-                token.features.text.values[tx_dict_reversed.get('top.binary.k')] = \
-                    definitions.PLOMNone_index2label[horus_tx_ner]
-                token.features.text.values[tx_dict_reversed.get('top.topic.k')] = \
-                    definitions.PLOMNone_index2label[horus_tx_ner_cnn]
+                token.features.text.values[tx_dict_rev.get('top.binary.k')] = definitions.encoder_4MUC_NER_idx2category[horus_tx_ner_label]
+                token.features.text.values[tx_dict_rev.get('top.topic.k')] = definitions.encoder_4MUC_NER_idx2category[horus_tx_ner_cnn]
             else:
-                token.features.text.values[tx_dict_reversed.get('top.binary.k')] = \
-                    definitions.PLOMNone_index2label[4]
-                token.features.text.values[tx_dict_reversed.get('top.topic.k')] = \
-                    definitions.PLOMNone_index2label[4]
+                token.features.text.values[tx_dict_rev.get('top.binary.k')] = definitions.encoder_4MUC_NER_idx2category[4]
+                token.features.text.values[tx_dict_rev.get('top.topic.k')] = definitions.encoder_4MUC_NER_idx2category[4]
 
             return token
 
@@ -565,7 +555,7 @@ def extract_features(self, horus: Horus) -> bool:
                                                         limit_txt=limit_txt,
                                                         nr_results_txt=nr_results_txt,
                                                         tx_dict=tx_dict,
-                                                        tx_dict_reversed=tx_dict_reversed)
+                                                        tx_dict_rev=tx_dict_reversed)
 
         except Exception as e:
             raise e
diff --git a/src/horus_meta.py b/src/horus_meta.py
index 75232ac..b09a25d 100644
--- a/src/horus_meta.py
+++ b/src/horus_meta.py
@@ -34,69 +34,69 @@ def get_textual() -> dict:
             3: 'total.ovr.k.loc',
             4: 'total.ovr.k.org',
             5: 'total.ovr.k.per',
-            6: 'total.ovr.k.other',
+            6: 'total.ovr.k.misc',
             7: 'avg.probs1.k.loc',
             8: 'avg.probs1.k.org',
             9: 'avg.probs1.k.per',
-            10: 'avg.probs1.k.other',
+            10: 'avg.probs1.k.misc',
             11: 'avg.probs2.k.loc',
             12: 'avg.probs2.k.org',
             13: 'avg.probs2.k.per',
-            14: 'avg.probs2.k.other',
+            14: 'avg.probs2.k.misc',
             15: 'top.binary.k',
             16: 'dist.k',
             17: 'total.topic.k.loc',
             18: 'total.topic.k.org',
             19: 'total.topic.k.per',
             20: 'total.topic.k.misc',
-            21: 'total.topic.k.other',
+            21: 'total.topic.k.misc',
             22: 'top.topic.k',
             23: 'dist.k.topic_model',
             24: 'total.emb.similar.loc',
             25: 'total.emb.similar.org',
             26: 'total.emb.similar.per',
             27: 'total.emb.similar.misc',
-            28: 'total.emb.similar.other',
+            28: 'total.emb.similar.misc',
             29: 'stats.topic.top.k.sum.loc',
             30: 'stats.topic.top.k.sum.org',
             31: 'stats.topic.top.k.sum.per',
             32: 'stats.topic.top.k.sum.misc',
-            33: 'stats.topic.top.k.sum.other',
+            33: 'stats.topic.top.k.sum.misc',
             34: 'stats.topic.top.k.avg.loc',
             35: 'stats.topic.top.k.avg.org',
             36: 'stats.topic.top.k.avg.per',
             37: 'stats.topic.top.k.avg.misc',
-            38: 'stats.topic.top.k.avg.other',
+            38: 'stats.topic.top.k.avg.misc',
             39: 'stats.topic.top.k.max.loc',
             40: 'stats.topic.top.k.max.org',
             41: 'stats.topic.top.k.max.per',
             42: 'stats.topic.top.k.max.misc',
-            43: 'stats.topic.top.k.max.other',
+            43: 'stats.topic.top.k.max.misc',
             44: 'stats.topic.top.k.min.loc',
             45: 'stats.topic.top.k.min.org',
             46: 'stats.topic.top.k.min.per',
             47: 'stats.topic.top.k.min.misc',
-            48: 'stats.topic.top.k.min.other',
+            48: 'stats.topic.top.k.min.misc',
             49: 'stats.topic.sum.loc',
             50: 'stats.topic.sum.org',
             51: 'stats.topic.sum.per',
             52: 'stats.topic.sum.misc',
-            53: 'stats.topic.sum.other',
+            53: 'stats.topic.sum.misc',
             54: 'stats.topic.avg.loc',
             55: 'stats.topic.avg.org',
             56: 'stats.topic.avg.per',
             57: 'stats.topic.avg.misc',
-            58: 'stats.topic.avg.other',
+            58: 'stats.topic.avg.misc',
             59: 'stats.topic.max.loc',
             60: 'stats.topic.max.org',
             61: 'stats.topic.max.per',
             62: 'stats.topic.max.misc',
-            63: 'stats.topic.max.other',
+            63: 'stats.topic.max.misc',
             64: 'stats.topic.min.loc',
             65: 'stats.topic.min.org',
             66: 'stats.topic.min.per',
             67: 'stats.topic.min.misc',
-            68: 'stats.topic.min.other'
+            68: 'stats.topic.min.misc'
         }
 
         reversed_features = dict([(value, key) for key, value in features.items()])
diff --git a/src/utils/util.py b/src/utils/util.py
index 3e34803..3687d27 100644
--- a/src/utils/util.py
+++ b/src/utils/util.py
@@ -591,13 +591,13 @@ def populate_matrix_new_columns(self):
         temp.extend([0] * (int(definitions.HORUS_TOT_FEATURES)-8))
         # do NOT append the last column here (y)
 
-        temp[18] = definitions.PLOMNone_index2label[4]
-        temp[26] = definitions.PLOMNone_index2label[4]
-        temp[26] = definitions.PLOMNone_index2label[4]
-        temp[38] = definitions.PLOMNone_index2label[4]
-        temp[39] = definitions.PLOMNone_index2label[4]
-        temp[40] = definitions.PLOMNone_index2label[4]
-        temp[41] = definitions.PLOMNone_index2label[4]
+        temp[18] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[26] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[26] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[38] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[39] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[40] = definitions.encoder_4MUC_NER_idx2category[4]
+        temp[41] = definitions.encoder_4MUC_NER_idx2category[4]
 
         return temp
 
@@ -618,9 +618,9 @@ def sentence_to_horus_matrix(self, sentences):
                     word_index_ref = sent[6][self.config.models_pos_tag_lib][c][0]
                     compound = sent[6][self.config.models_pos_tag_lib][c][1]
                     compound_size = sent[6][self.config.models_pos_tag_lib][c][2]
-                    temp = [0, sent_index, word_index_ref, compound, '', '', definitions.PLOMNone_index2label[4], 1, compound_size]
+                    temp = [0, sent_index, word_index_ref, compound, '', '', definitions.encoder_4MUC_NER_idx2category[4], 1, compound_size]
                     temp.extend(self.populate_matrix_new_columns())
-                    temp[definitions.INDEX_TARGET_NER] = definitions.PLOMNone_index2label[4]
+                    temp[definitions.INDEX_TARGET_NER] = definitions.encoder_4MUC_NER_idx2category[4]
                     converted.append(temp)
                 word_index = 0
                 starty = 0
@@ -646,24 +646,24 @@ def sentence_to_horus_matrix(self, sentences):
                     if len(sent[3][0]) > 0:
                         tag_ner_y = sent[3][0][ind_ner_real]
                         if tag_ner_y in definitions.NER_TAGS_LOC:
-                            tag_ner_y = definitions.PLOMNone_index2label[1]
+                            tag_ner_y = definitions.encoder_4MUC_NER_idx2category[1]
                         elif tag_ner_y in definitions.NER_TAGS_ORG:
-                            tag_ner_y = definitions.PLOMNone_index2label[2]
+                            tag_ner_y = definitions.encoder_4MUC_NER_idx2category[2]
                         elif tag_ner_y in definitions.NER_TAGS_PER:
-                            tag_ner_y = definitions.PLOMNone_index2label[3]
+                            tag_ner_y = definitions.encoder_4MUC_NER_idx2category[3]
                         else:
-                            tag_ner_y = definitions.PLOMNone_index2label[4]
+                            tag_ner_y = definitions.encoder_4MUC_NER_idx2category[4]
                     else:
-                        tag_ner_y = definitions.PLOMNone_index2label[4]
+                        tag_ner_y = definitions.encoder_4MUC_NER_idx2category[4]
 
                     if tag_ner in definitions.NER_TAGS_LOC:
-                        tag_ner = definitions.PLOMNone_index2label[1]
+                        tag_ner = definitions.encoder_4MUC_NER_idx2category[1]
                     elif tag_ner in definitions.NER_TAGS_ORG:
-                        tag_ner = definitions.PLOMNone_index2label[2]
+                        tag_ner = definitions.encoder_4MUC_NER_idx2category[2]
                     elif tag_ner in definitions.NER_TAGS_PER:
-                        tag_ner = definitions.PLOMNone_index2label[3]
+                        tag_ner = definitions.encoder_4MUC_NER_idx2category[3]
                     else:
-                        tag_ner = definitions.PLOMNone_index2label[4]
+                        tag_ner = definitions.encoder_4MUC_NER_idx2category[4]
 
                     temp = [has_NER, sent_index, word_index, term, tag_pos_uni, tag_pos, tag_ner, 0, 0]  # 0-8
                     temp.extend(self.populate_matrix_new_columns())