{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ordered-wrestling",
   "metadata": {},
   "source": [
    "![Logo 1](https://git.wmi.amu.edu.pl/AITech/Szablon/raw/branch/master/Logotyp_AITech1.jpg)\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "<h1> Komputerowe wspomaganie tłumaczenia </h1>\n",
    "<h2> 13,14. <i>Korekta pisowni</i> [laboratoria]</h2> \n",
    "<h3>Rafał Jaworski (2021)</h3>\n",
    "</div>\n",
    "\n",
    "![Logo 2](https://git.wmi.amu.edu.pl/AITech/Szablon/raw/branch/master/Logotyp_AITech2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "featured-afghanistan",
   "metadata": {},
   "source": [
    "Współczesne programy typu CAT nie mogą obyć się bez korektora pisowni. Na bieżąco kontrolują one pisownię wyrazów po stronie docelowej, czyli tam, gdzie tłumacz wpisuje tłumaczenie. Jest to niezwykle istotne w sytuacji, gdy język docelowy nie jest dla tłumacza językiem ojczystym. Co więcej, badania wykazują, iż korekta pisowni wydatnie zmniejsza liczbę błędów w każdych scenariuszach."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seventh-genre",
   "metadata": {},
   "source": [
    "Co poprawia korekta pisowni? Słowa. Tylko lub aż słowa. Program dokonujący korekty pisowni przegląda tekst słowo po słowie i sprawdza, czy należy ono do słownika. Jeśli nie, sygnalizowany jest błąd oraz, jeśli to możliwe, podawane sugestie poprawy. Co istotne, korektor pisowni nie zajmuje się szeregiem błędów, które mieszczą się w dziedzinie korekty gramatycznej, w tym:\n",
    "* interpunkcją\n",
    "* powtórzeniami wyrazów\n",
    "* stylistyką."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sticky-society",
   "metadata": {},
   "source": [
    "Aby zaimplementować korektor pisowni bez wątpienia potrzebny jest słownik. Skorzystajmy ze słownika, który znajdziemy w folderze data, pochodzącego z narzędzia Hunspell. Jest on spakowany - użyjmy techniki czytania z archiwum zip bez rozpakowywania. Poniższy kod wypisze fragment ze środka słownika."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "familiar-terrace",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kalecząc\n",
      "kaledonidy\n",
      "kaledoński\n",
      "kalefaktor\n",
      "kalejdofon\n",
      "kalejdoskop\n",
      "kalejdoskopowość\n",
      "kalejdoskopowy\n",
      "kaleka\n",
      "kaleki\n",
      "kalema\n",
      "kalendarium\n",
      "kalendarz\n",
      "kalendarzowy\n",
      "kalendarzyk\n",
      "kalendy\n",
      "kalenica\n",
      "kalenicowy\n",
      "kalepin\n",
      "kalesonki\n",
      "kalesony\n"
     ]
    }
   ],
   "source": [
    "from zipfile import ZipFile\n",
    "\n",
    "with ZipFile('data/hunspell_pl.zip') as zipped_dictionary:\n",
    "    with zipped_dictionary.open('hunspell_pl.txt') as dictionary_file:\n",
    "        count = 0\n",
    "        for line_bytes in dictionary_file:\n",
    "            count += 1\n",
    "            if count >= 100000 and count <= 100020:\n",
    "                line = line_bytes.decode('utf-8')\n",
    "                print(line.rstrip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dominant-insurance",
   "metadata": {},
   "source": [
    "Miejmy na uwadze, że powyższy słownik zawiera tylko formy podstawowe słowa, np. zawiera słowo \"kalendarz\", ale nie zawiera \"kalendarze\", \"kalendarza\", \"kalendarzy\" itp. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "single-brighton",
   "metadata": {},
   "source": [
    "Algorytm korekty pisowni na podstawie słownika powinien działać według następujących kroków:\n",
    "1. Wczytanie słownika do zbioru (set)\n",
    "2. Podział tekstu do korekty na słowa (podział po spacji)\n",
    "3. Dla każdego słowa wypisać, czy jest ono poprawne (znajduje się w słowniku) czy nie."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "needed-watson",
   "metadata": {},
   "source": [
    "### Ćwiczenie 1: Zaimplementuj podstawowy algorytm korekty pisowni według powyższych wytycznych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "economic-southeast",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data(zip_file_path):\n",
    "    with ZipFile(zip_file_path) as zip_f:\n",
    "        with zip_f.open('hunspell_pl.txt') as f:\n",
    "            return set([line.strip().lower() for line in f.read().decode('utf-8').splitlines()])\n",
    "\n",
    "def correct_words(sentence, dictionary):\n",
    "    \"\"\"\n",
    "    0 - incorrect\n",
    "    1 - correct\n",
    "    \"\"\"\n",
    "    return [(word, 1) if word in dictionary\n",
    "            else (word, 0)\n",
    "            for word in sentence.lower().split()]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "bba15ae8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('hakunamatata', 0)]\n",
      "[('czy', 1), ('dobrze', 1), ('pisze', 0)]\n",
      "[('ala', 1), ('ma', 1), ('kota', 1)]\n"
     ]
    }
   ],
   "source": [
    "data = load_data('data/hunspell_pl.zip')\n",
    "print(correct_words('Hakunamatata', data))\n",
    "print(correct_words('Czy dobrze pisze', data))\n",
    "print(correct_words('Ala ma kota', data))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "endless-slide",
   "metadata": {},
   "source": [
    "To jednak oczywiście nie wszystko. Do tej pory mamy funkcjonalność sygnalizowania słów błędnych, ale każdy dobry korektor pisowni potrafi podać sugestie poprawek. W tym celu musimy stawić czoła następującemu problemowi - wygenerowanie listy słów podobnych do danego słowa błędnego, które znajdują się w słowniku."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adult-freight",
   "metadata": {},
   "source": [
    "W pierwszej kolejności musimy zdefiniować podobieństwo między wyrazami. Posłuży do tego dobrze nam znana odległość Levenshteina - wyrazy podobne to takie, dla których dystans Levenshteina jest niewielki (np. równy 1 lub 2). Teraz brakuje tylko algorytmu wyszukiwania wyrazów w danym słowniku, które znajdują się niedaleko (w sensie Levenshteina) danego błędnego słowa."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "everyday-things",
   "metadata": {},
   "source": [
    "Rozważmy następujący algorytm: dla danego słownika $D$ i błędnego słowa $w \\notin D$:\n",
    "1. Wygeneruj zbiór $L_1(w)$ wszystkich słów, których odległość Levenshteina od $w$ wynosi 1.\n",
    "2. Wyznacz zbiór $S_1(w)=L_1(w) \\cap D$\n",
    "3. Wyznacz zbiór $L_2(w)=\\bigcup_{v \\in L_1(w)} L_1(v)$\n",
    "4. Wyznacz zbiór $S_2(w)=L_2(w) \\cap D$\n",
    "5. Zwróć jako listę sugestii: $S_1 \\cup S_2$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "industrial-convert",
   "metadata": {},
   "source": [
    "### Ćwiczenie 2: Napisz funkcję do generowania zbioru $L_1(w)$ - wszystkich słów znajdujących się w odległości Levenshteina 1 od danego słowa w."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "built-sally",
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = 'aąbcćdeęfghijklłmnńoóprsśtuwyzźż'\n",
    "\n",
    "def L1(w):\n",
    "    edits = set()\n",
    "    for i in range(len(w) + 1):\n",
    "        for c in alphabet:\n",
    "            if i < len(w):\n",
    "                edits.add(w[:i] + c + w[i+1:])\n",
    "            edits.add(w[:i] + c + w[i:])\n",
    "        if i < len(w):\n",
    "            edits.add(w[:i] + w[i+1:])\n",
    "    return edits\n",
    "\n",
    "def L2(l1):\n",
    "    edits = set()\n",
    "    for word in l1:\n",
    "        edits.update(L1(word))\n",
    "    return edits\n",
    "\n",
    "def S(edits, dictionary):\n",
    "    return set(dictionary).intersection(set(edits))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wireless-uncle",
   "metadata": {},
   "source": [
    "### Ćwiczenie 3: Napisz funkcję do generowania sugestii poprawek dla danego słowa według opisanego wcześniej algorytmu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "coordinated-cooperation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['cześć'], ['mam'], ['na'], {'gajek', 'tajner', 'jasne', 'janne', 'jajem', 'janet', 'jacek', 'janez', 'banek', 'jarek', 'panek', 'ranek', 'majtek', 'danek', 'jadnak', 'jenek', 'najdek', 'jaje', 'jane', 'kajtek', 'jonek', 'jamnik', 'janik', 'pajek', 'janem', 'gajnik', 'jajnik', 'jasiek', 'garnek', 'majek', 'bajek', 'jasek', 'jasnej', 'janek', 'tajnik', 'ganek'}]\n"
     ]
    }
   ],
   "source": [
    "def apply_edits(sentence, dictionary):\n",
    "    suggestions = []\n",
    "    for word, is_misspelled in sentence:\n",
    "        if is_misspelled == 0:\n",
    "            words = generate_suggestions(word, dictionary)\n",
    "            suggestions.append(words)\n",
    "        else:\n",
    "            suggestions.append([word])\n",
    "    return suggestions\n",
    "\n",
    "def generate_suggestions(w, dictionary):\n",
    "    l1 = L1(w)\n",
    "    l2 = L2(l1)\n",
    "    s1 = S(l1, dictionary)\n",
    "    s2 = S(l2, dictionary)\n",
    "    return s1.union(s2)\n",
    "\n",
    "print(apply_edits(correct_words('Cześć mam na jajnek', data), data))"
   ]
  }
 ],
 "metadata": {
  "author": "Rafał Jaworski",
  "email": "rjawor@amu.edu.pl",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "lang": "pl",
  "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.11.0"
  },
  "subtitle": "13,14. Korekta pisowni",
  "title": "Komputerowe wspomaganie tłumaczenia",
  "year": "2021"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}