weka2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analýza sentimentu\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nastartujeme virtuální stroj Javy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DEBUG:weka.core.jvm:Adding bundled jars\n",
      "DEBUG:weka.core.jvm:Classpath=['C:\\\\Users\\\\karel\\\\anaconda3\\\\Lib\\\\site-packages\\\\javabridge\\\\jars\\\\rhino-1.7R4.jar', 'C:\\\\Users\\\\karel\\\\anaconda3\\\\Lib\\\\site-packages\\\\javabridge\\\\jars\\\\runnablequeue.jar', 'C:\\\\Users\\\\karel\\\\anaconda3\\\\Lib\\\\site-packages\\\\javabridge\\\\jars\\\\cpython.jar', 'C:\\\\Users\\\\karel\\\\anaconda3\\\\lib\\\\site-packages\\\\weka\\\\lib\\\\python-weka-wrapper.jar', 'C:\\\\Users\\\\karel\\\\anaconda3\\\\lib\\\\site-packages\\\\weka\\\\lib\\\\weka.jar']\n",
      "DEBUG:weka.core.jvm:MaxHeapSize=default\n",
      "DEBUG:weka.core.jvm:Package support disabled\n"
     ]
    }
   ],
   "source": [
    "import weka.core.jvm as jvm\n",
    "jvm.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Část Weka\n",
    "\n",
    "Načtení originálních dat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from weka.core.converters import Loader\n",
    "\n",
    "loader = Loader(\"weka.core.converters.ArffLoader\")\n",
    "data = loader.load_file(\"./tweets.arff\")\n",
    "\n",
    "# nastaveni class atributu na první atribut - sentiment\n",
    "data.class_index = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Část bez úpravy předzpracování dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from weka.filters import Filter\n",
    "\n",
    "# aplikace filtru String To Word Vector - bez parametru\n",
    "f = Filter(classname=\"weka.filters.unsupervised.attribute.StringToWordVector\")\n",
    "f.inputformat(data)\n",
    "# vytvoreni filtrovaneho datasetu\n",
    "expanded = f.filter(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Celkový počet vytvořených atributů z vektorizace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1752\n"
     ]
    }
   ],
   "source": [
    "print(len(expanded.attribute_names()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(expanded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = Filter(classname=\"weka.filters.supervised.attribute.AttributeSelection\")\n",
    "f.inputformat(expanded)\n",
    "\n",
    "final = f.filter(expanded)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Po provedení filtrace se vytvoří následující počet atributů:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "83\n"
     ]
    }
   ],
   "source": [
    "print(len(final.attribute_names()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(final)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 90.0397088021178 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 93.61350099272005 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 92.81932495036399 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 94.07677035076108 % instances\n"
     ]
    }
   ],
   "source": [
    "from weka.classifiers import Classifier\n",
    "from weka.classifiers import Evaluation\n",
    "from weka.core.classes import from_commandline\n",
    "\n",
    "classifiers = [\n",
    "    'weka.classifiers.rules.ZeroR',\n",
    "    'weka.classifiers.rules.OneR -B 6',\n",
    "    'weka.classifiers.bayes.NaiveBayes',\n",
    "    'weka.classifiers.trees.J48 -C 0.25 -M 2',\n",
    "    'weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"'\n",
    "]\n",
    "\n",
    "for classifier in classifiers:\n",
    "    cls = from_commandline(classifier, classname=\"weka.classifiers.Classifier\")\n",
    "    cls.build_classifier(final)\n",
    "    ev = Evaluation(final)\n",
    "    ev.evaluate_train_test_split(cls, final, 66, rnd = None)\n",
    "    \n",
    "    print(\"Classifier \" + classifier + \" has correctly classfied \" + str(ev.percent_correct) + \" % instances\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Využitím jiných algoritmů se samo o sobě přesnost zlepšila vcelku výrazně, nejlépe si zde vede K-nn algoritmus, následovaný NaiveBayes a neprořezaným rozhodovacím stromem. V další části provedu úpravy v předzpracování dat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Změna předzpracování dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Postupně vyzkoušíme změnu předzpracování dat. V prvním kroku se vyzkouší odstranění stop slov, následně se vypíše počet atributů, vyfiltrují se atributy, natrénuje se klasifikátor a vypíše se výsledek.\n",
    "\n",
    "Většina změn přístupu vede k velmi malým změnám, ale dohromady se jedná o zlepšení o cca. 5 procentních bodů oproti ZeroR. Ve srovnání s předchozím krokem ale není "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---1---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.NullStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 3336\n",
      "Filtered attributes: 92\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.23825281270682 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.27134348113832 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.4295168762409 % instances\n",
      "--------\n",
      "---2---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.LovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2873\n",
      "Filtered attributes: 71\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.70152217074785 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.86697551290536 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.4295168762409 % instances\n",
      "--------\n",
      "---3---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.LovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2873\n",
      "Filtered attributes: 71\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.70152217074785 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.86697551290536 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.4295168762409 % instances\n",
      "--------\n",
      "---4---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-I', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.LovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2873\n",
      "Filtered attributes: 71\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.70152217074785 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.86697551290536 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.4295168762409 % instances\n",
      "--------\n",
      "---5---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-I', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.LovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2873\n",
      "Filtered attributes: 71\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.70152217074785 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.86697551290536 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.4295168762409 % instances\n",
      "--------\n",
      "---6---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '1', '-I', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.LovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2873\n",
      "Filtered attributes: 69\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 73.52746525479814 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.10589013898081 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 88.6168100595632 % instances\n",
      "--------\n",
      "---7---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-I', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.IteratedLovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2724\n",
      "Filtered attributes: 68\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.73461283917935 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.80079417604236 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.5287888815354 % instances\n",
      "--------\n",
      "---8---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-I', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.Rainbow', '-stemmer', 'weka.core.stemmers.IteratedLovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 2724\n",
      "Filtered attributes: 68\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 89.57643944407677 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 90.73461283917935 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 90.80079417604236 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 91.5287888815354 % instances\n",
      "--------\n",
      "---9---\n",
      "['-R', 'first-last', '-W', '1000', '-prune-rate', '-1.0', '-N', '0', '-I', '-T', '-L', '-stopwords-handler', 'weka.core.stopwords.WordsFromFile -stopwords C:\\\\Users\\\\karel\\\\Documents\\\\py\\\\weka\\\\stopwords.txt', '-stemmer', 'weka.core.stemmers.IteratedLovinsStemmer', '-M', '1', '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\"()?!\"']\n",
      "SWV created attributes: 1420\n",
      "Filtered attributes: 62\n",
      "Classifier weka.classifiers.rules.ZeroR has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.rules.OneR -B 6 has correctly classfied 91.72733289212442 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 93.34877564526803 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 92.98477829252151 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 94.67240238252813 % instances\n",
      "--------\n"
     ]
    }
   ],
   "source": [
    "from weka.filters import Filter\n",
    "from weka.filters import StringToWordVector\n",
    "\n",
    "opt = [\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.NullStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # vychozi nastaveni + rainbow stopword handler\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.LovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # LovinsStemmer\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.LovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # vse nahore + TF\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.LovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # vse nahore + IDF,\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.LovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # vse nahore + TF-IDF\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"1\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.LovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # s normalizaci\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # tf-idf odlisny stemmer\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ], # tokenizer vyuzivajici n-gramy\n",
    "    [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.WordsFromFile -stopwords C:\\\\Users\\\\karel\\\\Documents\\\\py\\\\weka\\\\stopwords.txt\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "    ] # stop words from file\n",
    "]\n",
    "\n",
    "attr = [\n",
    "    [\n",
    "        \"-E\", \"weka.attributeSelection.CfsSubsetEval -M -Z -P 1 -E 1\", \"-S\", \"weka.attributeSelection.BestFirst -D 2 -N 5\"\n",
    "    ]\n",
    "   \n",
    "]\n",
    "\n",
    "m = 0\n",
    "\n",
    "i = 1\n",
    "\n",
    "for option in opt:\n",
    "    print(\"---\" + str(i) + \"---\")\n",
    "    print(option)\n",
    "    \n",
    "    i = i + 1\n",
    "    \n",
    "    f = StringToWordVector(options = option)\n",
    "    f.inputformat(data)\n",
    "\n",
    "    vectorized = f.filter(data)\n",
    "\n",
    "    print(\"SWV created attributes: \" + str(len(vectorized.attribute_names())))\n",
    "\n",
    "    f = Filter(classname=\"weka.filters.supervised.attribute.AttributeSelection\", options=attr[0])\n",
    "    f.inputformat(vectorized)\n",
    "    toclassify = f.filter(vectorized)\n",
    "\n",
    "    print(\"Filtered attributes: \" + str(len(toclassify.attribute_names())))\n",
    "    \n",
    "\n",
    "    for classifier in classifiers:\n",
    "        cls = from_commandline(classifier, classname=\"weka.classifiers.Classifier\")\n",
    "        cls.build_classifier(toclassify)\n",
    "        ev = Evaluation(toclassify)\n",
    "        ev.evaluate_train_test_split(cls, toclassify, 66, rnd = None)\n",
    "        \n",
    "        m = max(m, ev.percent_correct)\n",
    "\n",
    "        print(\"Classifier \" + classifier + \" has correctly classfied \" + str(ev.percent_correct) + \" % instances\")\n",
    "        \n",
    "    print(\"--------\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94.67240238252813\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Za nejlepší přístup se tedy nabízí kombinace stop words from file, ngram tokenizer, iterated Lovins stemmer, převod všeho na malá písmena. Z tohoto přístupu se zdá, že převod na tf-idf nemá žádný vliv na výsledek u těchto vybraných algoritmů. Může to být z toho důvodu, že méně častá slova budou odstraněna ve fázi redukce dimenzionality.\n",
    "\n",
    "Nejlepší výsledek měl algoritmus NaiveBayes s úspěšností 94.3745863666446 %."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NaiveBayes\n",
    "\n",
    "V této části bude podstoupeno ladění metaparametrů NaiveBayes. NaiveBayes měl nejlepší výsledky u posledního pokusu z předchozí části, tak prvním krokem pro tento pokus bude využití předchozího předzpracování dat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SWV created attributes: 1420\n",
      "Filtered attributes: 62\n",
      "Classifier weka.classifiers.bayes.NaiveBayes has correctly classfied 93.34877564526803 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes -K has correctly classfied 94.87094639311714 % instances\n",
      "Classifier weka.classifiers.bayes.NaiveBayes -D has correctly classfied 94.50694904037061 % instances\n",
      "--------\n"
     ]
    }
   ],
   "source": [
    "option = [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\",  \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.WordsFromFile -stopwords C:\\\\Users\\\\karel\\\\Documents\\\\py\\\\weka\\\\stopwords.txt\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.WordTokenizer -delimiters \" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\"'\n",
    "]\n",
    "    \n",
    "f = StringToWordVector(options = option)\n",
    "f.inputformat(data)\n",
    "\n",
    "vectorized = f.filter(data)\n",
    "\n",
    "print(\"SWV created attributes: \" + str(len(vectorized.attribute_names())))\n",
    "\n",
    "f = Filter(classname=\"weka.filters.supervised.attribute.AttributeSelection\", options=attr[0])\n",
    "f.inputformat(vectorized)\n",
    "toclassify = f.filter(vectorized)\n",
    "\n",
    "print(\"Filtered attributes: \" + str(len(toclassify.attribute_names())))\n",
    "\n",
    "classifiers_bayes = [\n",
    "    \"weka.classifiers.bayes.NaiveBayes\",\n",
    "    \"weka.classifiers.bayes.NaiveBayes -K\",\n",
    "    \"weka.classifiers.bayes.NaiveBayes -D\"\n",
    "]\n",
    "\n",
    "for classifier in classifiers_bayes:\n",
    "    cls = from_commandline(classifier, classname=\"weka.classifiers.Classifier\")\n",
    "    cls.build_classifier(toclassify)\n",
    "    ev = Evaluation(toclassify)\n",
    "    ev.evaluate_train_test_split(cls, toclassify, 66, rnd = None)\n",
    "\n",
    "    m = max(m, ev.percent_correct)\n",
    "\n",
    "    print(\"Classifier \" + classifier + \" has correctly classfied \" + str(ev.percent_correct) + \" % instances\")\n",
    "\n",
    "print(\"--------\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nejlepší výsledek NaiveBayes dosáhl s použitím parametru -D, tedy funkce využívající místo normálního rozdělení pravděpodobnosti KDE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IB-k\n",
    "\n",
    "Clusterovací algoritmus dosáhl nejlepšího výsledku na předposledním výsledku předchozí části."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SWV created attributes: 1734\n",
      "Filtered attributes: 65\n",
      "Classifier weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.77895433487757 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.74586366644606 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.51422898742554 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 4 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.51422898742554 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 4 -W 100 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 88.91462607544672 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -I -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.71277299801456 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -F -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\" has correctly classfied 93.74586366644606 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -W 0 -A \"weka.core.neighboursearch.KDTree\" has correctly classfied 93.74586366644606 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -W 100 -A \"weka.core.neighboursearch.BallTree\" has correctly classfied 88.74917273328921 % instances\n",
      "Classifier weka.classifiers.lazy.IBk -K 2 -W 100 -A \"weka.core.neighboursearch.CoverTree\" has correctly classfied 88.6829913964262 % instances\n",
      "--------\n"
     ]
    }
   ],
   "source": [
    "option = [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.Rainbow\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.NGramTokenizer -max 3 -min 1 -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "]\n",
    "    \n",
    "f = StringToWordVector(options = option)\n",
    "f.inputformat(data)\n",
    "\n",
    "vectorized = f.filter(data)\n",
    "\n",
    "print(\"SWV created attributes: \" + str(len(vectorized.attribute_names())))\n",
    "\n",
    "f = Filter(classname=\"weka.filters.supervised.attribute.AttributeSelection\", options=attr[0])\n",
    "f.inputformat(vectorized)\n",
    "toclassify = f.filter(vectorized)\n",
    "\n",
    "print(\"Filtered attributes: \" + str(len(toclassify.attribute_names())))\n",
    "\n",
    "classifiers_ibk = [\n",
    "    'weka.classifiers.lazy.IBk -K 1 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 3 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 4 -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 4 -W 100 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -I -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -F -W 0 -A \"weka.core.neighboursearch.LinearNNSearch\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -W 0 -A \"weka.core.neighboursearch.KDTree\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -W 100 -A \"weka.core.neighboursearch.BallTree\"',\n",
    "    'weka.classifiers.lazy.IBk -K 2 -W 100 -A \"weka.core.neighboursearch.CoverTree\"',\n",
    "]\n",
    "\n",
    "for classifier in classifiers_ibk:\n",
    "    cls = from_commandline(classifier, classname=\"weka.classifiers.Classifier\")\n",
    "    cls.build_classifier(toclassify)\n",
    "    ev = Evaluation(toclassify)\n",
    "    ev.evaluate_train_test_split(cls, toclassify, 66, rnd = None)\n",
    "\n",
    "    m = max(m, ev.percent_correct)\n",
    "\n",
    "    print(\"Classifier \" + classifier + \" has correctly classfied \" + str(ev.percent_correct) + \" % instances\")\n",
    "\n",
    "print(\"--------\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Veškeré provedené změny na tomto algoritmu vedly pouze ke zhoršení výsledků. Změna výpočtu vzdálenosti mezi instancemi bohužel nebyla vyzkoušena kvůli chybové hlášce ze strany knihovny při překopírování celého příkazu z prostředí Weka."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## J48\n",
    "\n",
    "U tohoto algoritmu byl opět nejúspěšnější poslední výše uvedený případ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SWV created attributes: 1548\n",
      "Filtered attributes: 59\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 2 has correctly classfied 93.44804765056254 % instances\n",
      "Classifier weka.classifiers.trees.J48 -C 0.25 -M 5 has correctly classfied 93.15023163467902 % instances\n",
      "Classifier weka.classifiers.trees.J48 -R -N 3 -Q 1 -M 2 has correctly classfied 93.31568497683654 % instances\n",
      "Classifier weka.classifiers.trees.J48 -O -U -M 1 has correctly classfied 93.05095962938451 % instances\n",
      "--------\n"
     ]
    }
   ],
   "source": [
    "option = [\n",
    "        \"-R\", \"first-last\", \"-W\", \"1000\", \"-prune-rate\", \"-1.0\", \"-N\", \"0\", \"-I\", \"-T\", \"-L\",\n",
    "        \"-stopwords-handler\", \"weka.core.stopwords.WordsFromFile -stopwords E:\\Weka\\Weka-3-8-4\", \"-stemmer\", \"weka.core.stemmers.IteratedLovinsStemmer\",\n",
    "        \"-M\", \"1\", '-tokenizer', 'weka.core.tokenizers.NGramTokenizer -max 3 -min 1 -delimiters \\\" \\\\r\\\\n\\\\t.,;:\\\\\\'\\\\\\\"()?!\\\"'\n",
    "]\n",
    "    \n",
    "f = StringToWordVector(options = option)\n",
    "f.inputformat(data)\n",
    "\n",
    "vectorized = f.filter(data)\n",
    "\n",
    "print(\"SWV created attributes: \" + str(len(vectorized.attribute_names())))\n",
    "\n",
    "f = Filter(classname=\"weka.filters.supervised.attribute.AttributeSelection\", options=attr[0])\n",
    "f.inputformat(vectorized)\n",
    "toclassify = f.filter(vectorized)\n",
    "\n",
    "print(\"Filtered attributes: \" + str(len(toclassify.attribute_names())))\n",
    "\n",
    "classifiers_tree = [\n",
    "    \"weka.classifiers.trees.J48 -C 0.25 -M 2\",\n",
    "    \"weka.classifiers.trees.J48 -C 0.25 -M 5\",\n",
    "    \"weka.classifiers.trees.J48 -R -N 3 -Q 1 -M 2\",\n",
    "    \"weka.classifiers.trees.J48 -O -U -M 1\"\n",
    "]\n",
    "\n",
    "for classifier in classifiers_tree:\n",
    "    cls = from_commandline(classifier, classname=\"weka.classifiers.Classifier\")\n",
    "    cls.build_classifier(toclassify)\n",
    "    ev = Evaluation(toclassify)\n",
    "    ev.evaluate_train_test_split(cls, toclassify, 66, rnd = None)\n",
    "\n",
    "    m = max(m, ev.percent_correct)\n",
    "\n",
    "    print(\"Classifier \" + classifier + \" has correctly classfied \" + str(ev.percent_correct) + \" % instances\")\n",
    "\n",
    "print(\"--------\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Výsledné stromy byly opět intervencí pouze zhoršeny. Lepší výsledek neměl ani neprořezaný strom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}