diff --git a/lab/lab_04-05.ipynb b/lab/lab_04-05.ipynb
index 43f770e..890b554 100644
--- a/lab/lab_04-05.ipynb
+++ b/lab/lab_04-05.ipynb
@@ -68,9 +68,30 @@
    "id": "environmental-thread",
    "metadata": {},
    "source": [
-    "### Ćwiczenie 2: Uruchom ekstraktor terminologii (wykrywacz rzeczowników) z poprzednich zajęć na każdym dokumencie z osobna. Jako wynik ekstraktora w każdym przypadku wypisz 5 najczęściej występujących rzeczowników. Wyniki działania komendy umieść w notatniku."
+    "import nltk\n",
+    "nltk.download('punkt')  # Pobierz tokenizator zdania, jeśli jeszcze go nie masz\n",
+    "\n",
+    "def podziel_na_zdania(nazwa_pliku):\n",
+    "    with open(nazwa_pliku, 'r') as plik:\n",
+    "        tekst = plik.read()\n",
+    "        zdania = nltk.sent_tokenize(tekst)\n",
+    "        return zdania\n",
+    "\n",
+    "nazwa_pliku = 'tekst.txt'  # Zmień na nazwę swojego pliku\n",
+    "zdania = podziel_na_zdania(nazwa_pliku)\n",
+    "\n",
+    "for zdanie in zdania:\n",
+    "    print(zdanie)### Ćwiczenie 2: Uruchom ekstraktor terminologii (wykrywacz rzeczowników) z poprzednich zajęć na każdym dokumencie z osobna. Jako wynik ekstraktora w każdym przypadku wypisz 5 najczęściej występujących rzeczowników. Wyniki działania komendy umieść w notatniku."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79fd91c4-c22e-43a0-9842-83a33bd65fa9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": 17,
@@ -560,7 +581,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.9.2"
   },
   "subtitle": "4,5. Klasyfikacja tematyczna (terminologii ciąg dalszy)",
   "title": "Komputerowe wspomaganie tłumaczenia",
diff --git a/lab/lab_06-07.ipynb b/lab/lab_06-07.ipynb
index f667139..c5e8ac5 100644
--- a/lab/lab_06-07.ipynb
+++ b/lab/lab_06-07.ipynb
@@ -87,7 +87,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 19,
    "id": "documented-hacker",
    "metadata": {},
    "outputs": [],
@@ -95,7 +95,7 @@
     "import re\n",
     "def find_tags(text):\n",
     "    pos = []\n",
-    "    regexp = r'(<([a-zA-Z])>)|(</([a-zA-Z])>)'\n",
+    "    regexp = r'(<([_a-zA-Z]]*[^<]*)>)|(</([_a-zA-Z][^<?!]*)>)'\n",
     "    pattern = re.compile(regexp)\n",
     "    tags = pattern.finditer(text)\n",
     "    for tag in tags:\n",
@@ -105,23 +105,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 25,
    "id": "52a23469-3283-48df-ba49-4d23ba0d6088",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[(5, 8), (29, 33)]"
+       "[(71, 83), (83, 91), (96, 105), (105, 115), (127, 138), (138, 151)]"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "string = \"aaafo<r>m1aaaahform2uadaiudfo</r>m3oihdhdform2oahdoihwfform2oiadoafform11\"\n",
+    "string = \"<2024.21.04| Documentation on how to connect to the database with XML: <Connection><server>Games</server><database>Call of Duty</database></Connection>\"\n",
+    "#<Connection>\n",
+    "#    <server>Games</server>\n",
+    "#    <database>Call of Duty</database>\n",
+    "#</Connection>\n",
+    "\n",
     "find_tags(string)"
    ]
   },
@@ -135,15 +140,169 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 362,
    "id": "unauthorized-study",
    "metadata": {},
    "outputs": [],
    "source": [
     "def is_translatable(text):\n",
-    "    # 4.2.1\n",
-    "    # \n",
-    "    return True"
+    "    # v 4.2.1 / version: 4.2.1\n",
+    "    # a) B) / aa) BB) / a. BB. / aa. BB. / 1. 2. / 2) 3)\n",
+    "    # przykłady kodu python\n",
+    "    # nr_indeksu (6 cyfr | z/lub bez poprzedzającego znaku 's')\n",
+    "    \n",
+    "    version = r'(^v [0-9].[0-9].?[0-9]?[0-9]?$)|(^ver(:*|.*) [0-9].[0-9].?[0-9]?[0-9]?$)'\n",
+    "    ol = r'(^[a-zA-z][a-zA-z]?(\\)|.)$)|(^[0-9][0-9]?(\\)|.)$)'\n",
+    "    index = r'(^s?\\d{6}$)'\n",
+    "    pyt = r\"\"\"^```python\n",
+    ".*?\n",
+    "```$\"\"\"\n",
+    "    \n",
+    "    regexp = fr'{version}|{ol}|{index}'\n",
+    "    \n",
+    "    if re.fullmatch(regexp,text):\n",
+    "        return False\n",
+    "    elif re.fullmatch(pyt,text,re.DOTALL):\n",
+    "        return False\n",
+    "    else:\n",
+    "        return True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 189,
+   "id": "30abd5b8-f6e3-4a59-8f53-5ff3b4899e7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 189,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "is_translatable(\"Wiedza z tego przedmiotu może się dobrze przydać przy tworzeniu systemu dialogowego\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 190,
+   "id": "e3a39c8a-976b-4d66-834e-6d69c3833fe5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 190,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "is_translatable(\"Kliknij enter aby rozpocząć\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 185,
+   "id": "c879c8dd-9a1d-490b-a44f-4a06134f8521",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ver: 4.3.34 False\n",
+      "v 4.3.34 False\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = is_translatable(\"ver: 4.3.34\")\n",
+    "y = is_translatable(\"v 4.3.34\")\n",
+    "\n",
+    "print(f\"ver: 4.3.34 {x}\\nv 4.3.34 {y}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 184,
+   "id": "dcb91bed-63c3-4044-bb19-a2abe6a36c88",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "s444820 False\n",
+      "444820 False\n"
+     ]
+    }
+   ],
+   "source": [
+    "x = is_translatable(\"s444820\")\n",
+    "y = is_translatable(\"444820\")\n",
+    "print(f\"s444820 {x}\\n444820 {y}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 187,
+   "id": "59575516-df17-4e35-9b42-9ee69f9d8b0e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a) False\n",
+      "II. False\n",
+      "1. False\n",
+      "2. False\n"
+     ]
+    }
+   ],
+   "source": [
+    "a = is_translatable(\"a)\")\n",
+    "b = is_translatable(\"II.\")\n",
+    "c = is_translatable(\"1.\")\n",
+    "d = is_translatable(r\"2.\")\n",
+    "print(f\"a) {a}\\nII. {b}\\n1. {c}\\n2. {d}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 188,
+   "id": "40d913e6-48aa-4ece-81b4-bbe74efb5533",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 188,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ex = r\"\"\"```python\n",
+    "def func():\n",
+    "    print(HelloEarth)\n",
+    "func()\n",
+    "```\"\"\"\n",
+    "\n",
+    "is_translatable(ex)"
    ]
   },
   {
@@ -156,18 +315,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "beautiful-mathematics",
+   "execution_count": 435,
+   "id": "bbb6d96e-231d-48fb-a6a5-f05cb8c84b87",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[(0, 10), '21', '04', '2024'],\n",
+       " [(23, 33), '20', '22', '2021'],\n",
+       " [(54, 64), '01', '01', '1999']]"
+      ]
+     },
+     "execution_count": 435,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "import re\n",
+    "\n",
     "def find_dates(text):\n",
-    "    #YYYY-MM-DD\n",
-    "    #DD-MM-YYYY\n",
-    "    #\n",
-    "    #\n",
-    "    #\n",
-    "    return []"
+    "    formats = [\n",
+    "        r'(\\d{4}-\\d{2}-\\d{2})',   # YYYY-MM-DD\n",
+    "        r'(\\d{2}-\\d{2}-\\d{4})',   # DD-MM-YYYY\n",
+    "        \n",
+    "        r'(\\d{4}/\\d{2}/\\d{2})',   # YYYY/MM/DD\n",
+    "        r'(\\d{2}/\\d{2}/\\d{4})',   # DD/MM/YYYY\n",
+    "        \n",
+    "        r'(\\d{4}\\.\\d{2}\\.\\d{2})'  # YYYY.MM.DD\n",
+    "        r'(\\d{2}\\.\\d{2}\\.\\d{4})', # DD.MM.YYYY\n",
+    "    ]\n",
+    "\n",
+    "    regexp = ''\n",
+    "    for form in formats:\n",
+    "        if regexp:\n",
+    "            regexp += \"|\"+form\n",
+    "        else:\n",
+    "            regexp += form\n",
+    "\n",
+    "    answer = []       \n",
+    "    pattern = re.compile(regexp)\n",
+    "    dates = pattern.finditer(text)        \n",
+    "            \n",
+    "    for date in dates:\n",
+    "        parts = re.split(r'[-./]', date.group())\n",
+    "        \n",
+    "        if len(parts[0]) == 4:\n",
+    "            y = parts[0]\n",
+    "            d = parts[2]\n",
+    "        else:\n",
+    "            d = parts[0]\n",
+    "            y = parts[2]\n",
+    "        m = parts[1]\n",
+    "            \n",
+    "        answer.append([date.span(),d, m, y])\n",
+    "\n",
+    "    return answer\n",
+    "\n",
+    "\n",
+    "find_dates(\"2024-04-21 awdad qwrwe 20/22/2021 negweg qwqwd %reset 1999/01/01\")"
    ]
   },
   {
@@ -193,13 +400,174 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 369,
+   "id": "da509df1-75e4-4ae8-9b0d-5055d551b9dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Collecting isoweek\n",
+      "  Downloading isoweek-1.3.3-py2.py3-none-any.whl.metadata (4.4 kB)\n",
+      "Downloading isoweek-1.3.3-py2.py3-none-any.whl (7.1 kB)\n",
+      "Installing collected packages: isoweek\n",
+      "Successfully installed isoweek-1.3.3\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install isoweek"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 426,
    "id": "finished-essex",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from isoweek import Week\n",
+    "from datetime import datetime\n",
+    "\n",
+    "def isoWeekNumber(date_string):\n",
+    "    date_object = datetime.strptime(date_string, \"%Y-%m-%d\")\n",
+    "    \n",
+    "    return str(date_object.isocalendar()[1])\n",
+    "\n",
+    "def change_substring(text, new, start, end):\n",
+    "    return text[:start] + new + text[end:]\n",
+    "\n",
+    "def EuropeDate(target_segmnet,dates): #YYYY-MM-DD\n",
+    "    for date in dates:\n",
+    "        target_segmnet = change_substring(target_segmnet,date[3]+\"-\"+date[2]+\"-\"+date[1],date[0][0],date[0][1])\n",
+    "    return target_segmnet   \n",
+    "\n",
+    "def USDate(target_segmnet,dates): #MM-DD-YYYY\n",
+    "    for date in dates:\n",
+    "        target_segmnet = change_substring(target_segmnet,date[2]+\"-\"+date[1]+\"-\"+date[3],date[0][0],date[0][1])\n",
+    "    return target_segmnet\n",
+    "\n",
+    "def tyreDOTDate(target_segmnet,dates): #WWYY (weekYear) \n",
+    "    index = 0\n",
+    "    for date in dates:\n",
+    "        d = date[3]+\"-\"+date[2]+\"-\"+date[1]\n",
+    "        target_segmnet = change_substring(target_segmnet,isoWeekNumber(d)+date[3][2:],date[0][0]-index*6,date[0][1]-index*6)\n",
+    "        index += 1\n",
+    "    return target_segmnet\n",
+    "\n",
+    "\n",
     "def correct_dates(source_segment, target_segment, date_format):\n",
-    "    return ''"
+    "    ss = find_dates(source_segment)\n",
+    "    ts = find_dates(target_segment)\n",
+    "    if len(ss) != len(ts):\n",
+    "        return 'Błąd! Niezgodna liczba dat!'\n",
+    "    \n",
+    "    for index in range(len(ss)):\n",
+    "        if ss[index][1] != ts[index][1]:\n",
+    "            print(\"Rozbieżny dzień w dacie!\")\n",
+    "            print(f\"source_segment: {ss[index]}\")\n",
+    "            print(f\"target_segment: {ts[index]}\")\n",
+    "            return\n",
+    "        \n",
+    "    if date_format == \"Europe\":\n",
+    "        return EuropeDate(target_segment,ts)\n",
+    "    elif date_format == \"US\":\n",
+    "        return USDate(target_segment,ts)\n",
+    "    elif date_format == \"tyre-dot\":\n",
+    "        return tyreDOTDate(target_segment,ts)\n",
+    "    else:\n",
+    "        return \"nierozpoznawalny format rządanej daty\"\n",
+    "\n",
+    "source=\"Moje urodziny: 06/07/1999\\n moje najbliższe imieniny: 2024/12/04\"\n",
+    "target=\"My birthday: 06/07/1999\\nmy forthcoming name day: 2024/12/04.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 431,
+   "id": "05c351cb-c414-426a-9499-37886d943834",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Europe-format\n",
+      "---\n",
+      "My birthday: 1999-07-06\n",
+      "my forthcoming name day: 2024-12-04.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Europe-format\\n---\")\n",
+    "print(correct_dates(source,target,\"Europe\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 432,
+   "id": "b0c34609-cbd1-44ec-9c3a-191f0400d1fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "US-format\n",
+      "---\n",
+      "My birthday: 07-06-1999\n",
+      "my forthcoming name day: 12-04-2024.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"US-format\\n---\")\n",
+    "print(correct_dates(source,target,\"US\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 434,
+   "id": "c0808108-65f9-4025-b6e7-ad06fc06a4df",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tire-Dot-Format\n",
+      "---\n",
+      "My birthday: 2799\n",
+      "my forthcoming name day: 4924.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Tire-Dot-Format\\n---\")\n",
+    "print(correct_dates(source,target,\"tyre-dot\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 433,
+   "id": "9be67593-0ada-423b-97a9-9b4dcb3e9fa1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Błąd! Niezgodna liczba dat!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Niezgodna liczba dat\n",
+    "print(correct_dates(target,\"My birthday: \\nmy forthcoming name day: 2024/12/04\",\"Europe\")) "
    ]
   },
   {
@@ -244,13 +612,135 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 673,
    "id": "romance-judge",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "difference: 1.125\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Hi, I'm <b>Krystian Osiński </b>and I'm 24 <i>years </i>old.\""
+      ]
+     },
+     "execution_count": 673,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "import math\n",
+    "\n",
     "def transfer_tags(source_segment, target_segment):\n",
-    "    return ''"
+    "    regexp = r'(\\s|<[^>]+>)'\n",
+    "    tags = []\n",
+    "    result = \"\"\n",
+    "    index = 0\n",
+    "\n",
+    "    tokens = [token for token in re.split(regexp, source_segment) if token.strip() != \"\"]\n",
+    "    \n",
+    "    for token in tokens:\n",
+    "        if re.search(r'(<[^>]+>)', token):\n",
+    "            tags.append([index,token])\n",
+    "        if token.strip() != \"\":\n",
+    "            index += 1\n",
+    "            \n",
+    "    plain_s = re.sub(r'(<[^>]+>)', '', source_segment).split(\" \")\n",
+    "    \n",
+    "    t_tokens = target_segment.split(\" \")\n",
+    "   \n",
+    "    if len(plain_s) == len(t_tokens):\n",
+    "        for tag in tags:\n",
+    "            t_tokens.insert(tag[0],tag[1])\n",
+    "    else:\n",
+    "        difference = len(t_tokens)/len(plain_s)\n",
+    "        for tag in tags:\n",
+    "            t_tokens.insert(math.floor(tag[0]*difference),tag[1])\n",
+    "        print(f\"difference: {difference}\")\n",
+    "        \n",
+    "    \n",
+    "    for token in t_tokens:\n",
+    "        if len(token) > 1:\n",
+    "            if token[0] == \"<\" and token[-1] == \">\" and token[1] != \"/\":\n",
+    "                result += token\n",
+    "            elif token[1] == \"/\":\n",
+    "                result += token\n",
+    "            else:\n",
+    "                result += token  + \" \"\n",
+    "        else:\n",
+    "             result += token  + \" \"\n",
+    "    \n",
+    "    return result.strip()\n",
+    "\n",
+    "PLXML = \"Cześć, jestem <b>Krystian Osiński</b> i mam <i>24</i> lata.\"\n",
+    "EN = \"Hi, I'm Krystian Osiński and I'm 24 years old.\"\n",
+    "transfer_tags(PLXML,EN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 674,
+   "id": "25c52d74-d893-4c64-a637-baede2f85059",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "difference: 1.1111111111111112\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Hi, I'm <b>Krystian <i>Osiński </i></b>and I'm almost <i>24 years </i>old.\""
+      ]
+     },
+     "execution_count": 674,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PLXML = \"Cześć, jestem <b>Krystian <i>Osiński</i></b> i mam <i>prawie 24</i> lata.\"\n",
+    "EN = \"Hi, I'm Krystian Osiński and I'm almost 24 years old.\"\n",
+    "transfer_tags(PLXML,EN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 675,
+   "id": "3ffb97dd-e806-4b28-8b49-25c7e044758f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "difference: 1.125\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'I like <b>eating </b>donuts and drinking very hot <i>coffee </i>'"
+      ]
+     },
+     "execution_count": 675,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "PLXML = \"Lubię jeść <b>pączki</b> i pić bardzo gorącą <i>kawę</i>\"\n",
+    "EN = \"I like eating donuts and drinking very hot coffee\"\n",
+    "transfer_tags(PLXML,EN)"
    ]
   }
  ],
diff --git a/lab/lab_08.ipynb b/lab/lab_08.ipynb
index 274baf6..a98e197 100644
--- a/lab/lab_08.ipynb
+++ b/lab/lab_08.ipynb
@@ -57,13 +57,121 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
-   "id": "moving-clothing",
+   "execution_count": 16,
+   "id": "10ba41d5-aec6-4a8c-96ad-8167af126735",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Defaulting to user installation because normal site-packages is not writeable\n",
+      "Collecting nltk\n",
+      "  Downloading nltk-3.8.1-py3-none-any.whl.metadata (2.8 kB)\n",
+      "Requirement already satisfied: click in /usr/local/lib/python3.9/dist-packages (from nltk) (8.1.3)\n",
+      "Requirement already satisfied: joblib in /usr/lib/python3/dist-packages (from nltk) (0.17.0)\n",
+      "Requirement already satisfied: regex>=2021.8.3 in /usr/local/lib/python3.9/dist-packages (from nltk) (2023.5.5)\n",
+      "Requirement already satisfied: tqdm in /usr/local/lib/python3.9/dist-packages (from nltk) (4.64.1)\n",
+      "Downloading nltk-3.8.1-py3-none-any.whl (1.5 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m17.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m0:01\u001b[0m\n",
+      "\u001b[?25hInstalling collected packages: nltk\n",
+      "\u001b[33m  WARNING: The script nltk is installed in '/home/students/s444820/.local/bin' which is not on PATH.\n",
+      "  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.\u001b[0m\u001b[33m\n",
+      "\u001b[0mSuccessfully installed nltk-3.8.1\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "pip install nltk"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1e80adcf-ac34-4c38-a2c2-5735985c963e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1001\n",
+      "1001\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "0.7476897494228967"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import nltk\n",
+    "import zipfile\n",
+    "import string\n",
+    "from nltk.translate.bleu_score import corpus_bleu\n",
+    "def deletePunctuation(text):\n",
+    "    translator = str.maketrans('', '', string.punctuation)\n",
+    "    return text.translate(translator)\n",
+    "\n",
+    "def tokenization(i):\n",
+    "    zip_path = './data/corpus_corrected.zip'\n",
+    "    files = ['corpus_de_human.txt', 'corpus_de_nmt.txt', 'corpus_en.txt']\n",
+    "   \n",
+    "    result = []\n",
+    "    with zipfile.ZipFile(zip_path, 'r') as zf:\n",
+    "        with zf.open(files[i]) as f:\n",
+    "            text = f.read().decode('utf-8')\n",
+    "            text = text.split(\"\\n\")   \n",
+    "            for sentence in text:\n",
+    "                if i == 0: \n",
+    "                    result.append([deletePunctuation(sentence).split()])\n",
+    "                else:\n",
+    "                    result.append(deletePunctuation(sentence).split())\n",
+    "                    \n",
+    "            return result\n",
+    "\n",
+    "\n",
+    "HUMAN = tokenization(0)\n",
+    "MACHINE = tokenization(1)\n",
+    "STANDARD = tokenization(2)\n",
+    "print(len(HUMAN))\n",
+    "print(len(MACHINE))\n",
+    "corpus_bleu(HUMAN,MACHINE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "e0df3d36-9e5f-4111-a67b-3f5cc04d2cfe",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.7476897494228967"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "def calculate_bleu():\n",
-    "    return 0"
+    "    HUMAN = tokenization(0)\n",
+    "    MACHINE = tokenization(1)\n",
+    "    return corpus_bleu(HUMAN,MACHINE)\n",
+    "\n",
+    "calculate_bleu()"
    ]
   },
   {
@@ -76,13 +184,62 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 48,
    "id": "lasting-rolling",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "['[800-900)', 52]"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "def analyze_bleu():\n",
-    "    return []"
+    "from nltk.translate.bleu_score import sentence_bleu\n",
+    "import matplotlib.pyplot as plt\n",
+    "def analyze_bleu(interval):\n",
+    "    bleuResults = []\n",
+    "    errorNumber = 0\n",
+    "    er = []\n",
+    "    index = 0\n",
+    "    x = range(len(HUMAN)-1)\n",
+    "    for y in x:\n",
+    "        bleu = sentence_bleu(HUMAN[y], MACHINE[y])\n",
+    "        if bleu <= 0.7476897494228967:\n",
+    "            errorNumber += 1\n",
+    "        \n",
+    "        bleuResults.append(bleu)\n",
+    "        if index % interval == 0 and index != 0:\n",
+    "            er.append([f\"[{index-interval}-{index})\",errorNumber])\n",
+    "            errorNumber = 0\n",
+    "        index += 1\n",
+    "\n",
+    "    plt.plot(x, bleuResults, 'o',markersize=1.7)\n",
+    "    plt.xlabel('Nr zdania')\n",
+    "    plt.ylabel('Bleu')\n",
+    "    plt.title('Wynik BLEU w zależności od wartości zdań')\n",
+    "    plt.grid(True)\n",
+    "    plt.show()\n",
+    "    \n",
+    "    maxEr = max(er, key=lambda x: x[1])\n",
+    "    return maxEr\n",
+    "\n",
+    "analyze_bleu(100)"
    ]
   },
   {
@@ -120,13 +277,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 43,
    "id": "occupied-swing",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.17738143121880412"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "from jiwer import wer\n",
+    "\n",
     "def calculate_wer():\n",
-    "    return 0"
+    "    x = range(len(HUMAN)-1)\n",
+    "    w = 0\n",
+    "    for y in x:\n",
+    "        w += wer(\" \".join(HUMAN[y][0]),\" \".join(MACHINE[y]))\n",
+    "        \n",
+    "    \n",
+    "    return w/(len(HUMAN)-1)\n",
+    "calculate_wer()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "id": "c822988d-fcbf-4a6c-977d-3eda1fab0d3f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(wer(\" \".join(HUMAN[0][0]),\" \".join(MACHINE[0])))"
    ]
   },
   {
@@ -147,13 +342,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 50,
    "id": "immediate-element",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8802718348367172"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
+    "from Levenshtein import distance as levenshtein_distance\n",
+    "\n",
+    "def levenshtein_similarity(x,y):\n",
+    "    return 1 - levenshtein_distance(x,y) / max(len(x), len(y))\n",
+    "\n",
     "def calculate_levenshtein():\n",
-    "    return 0"
+    "    x = range(len(HUMAN)-1)\n",
+    "    l = 0\n",
+    "    for y in x:\n",
+    "        l += levenshtein_similarity(\" \".join(HUMAN[y][0]),\" \".join(MACHINE[y]))\n",
+    "        \n",
+    "    return l/(len(HUMAN)-1)\n",
+    "\n",
+    "calculate_levenshtein()"
    ]
   },
   {
@@ -177,13 +395,50 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
+   "id": "49c68adb-f242-434a-94e0-8236bb944e1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Invalid Word\n",
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "import PyDictionary \n",
+    "dictde = PyDictionary.PyDictionary() \n",
+    "  \n",
+    "translation = dictde.translate(\"happy\",'de') \n",
+    "print(translation)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
    "id": "descending-easter",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from PyDictionary import PyDictionary\n",
+    "\n",
+    "def translate(word):\n",
+    "    dictionary = PyDictionary()\n",
+    "    translation = dictionary.translate(word, 'de')\n",
+    "    return translation\n",
+    "\n",
     "def analyze_translations():\n",
-    "    return []"
+    "    dictionary = PyDictionary()\n",
+    "    result = []\n",
+    "    for sentence in STANDARD:\n",
+    "        words = []\n",
+    "        for word in sentence:\n",
+    "            words.append(dictionary.translate(word,'de'))\n",
+    "    result.append(words)\n",
+    "\n"
    ]
   }
  ],