Update pages/students/2024/kristian_sokolsky/README.md

AGENTS.md

@@ -0,0 +1,71 @@
+# Repository Description for Agents
+
+This repository hosts the GRAV CMS-based wiki for the Department of Electronics and Multimedia Telecommunications (KEMT) at Technical University in Košice (TUKE). It is a collaborative academic platform where students and faculty share final theses, project notes, and NLP (Natural Language Processing) research materials.
+
+## System Overview
+
+- **CMS**: [GRAV](https://getgrav.org/) — a flat-file CMS that stores content as Markdown files.
+- **Content format**: Each page is a directory containing a `README.md` file with YAML frontmatter (title, taxonomy, author, publication status).
+- **Version control**: All changes are tracked via Git on the institution's GitLab instance (`git.kemt.fei.tuke.sk`).
+
+## Directory Structure
+
+```
+pages/                    # Root of GRAV CMS content
+├── home/                 # Homepage (index page)
+├── 02.browse/            # Browse/search landing page
+├── 04.categories/        # Category listing pages
+├── 05.tags/              # Tag listing pages
+├── taxonomy/             # Taxonomy index pages
+├── authors/              # Author profile pages
+├── interns/              # Intern profiles (organized by student name)
+├── students/             # Student profiles (organized by year of enrollment)
+│   └── <start_year>/
+│       └── <student_name>/README.md
+└── topics/               # Project notes and reference materials
+```
+
+## Student Profiles (`pages/students/`)
+
+Each student has an individual profile directory named `<first_name>_<last_name>` organized under a year subdirectory (`2016`–`2024`). Profiles track academic work including:
+
+- **Study year** (`rok začiatku štúdia`)
+- **Thesis type**: bakalársky projekt (bp), magistrský projekt (mp), bakalárska práca (bp), diplomová práca (dp), veterinárna práca (vp)
+- **Thesis topic and goals** (`Téma`, `Ciele na semester`)
+- **Thesis assignment** (`Zadanie` / `Návrh na zadanie`)
+- **Meeting logs** (`Stretnutie`) — dated records with tasks assigned, progress notes, and current status (`Stav`)
+- **Tasks** (`Úlohy`) — specific deliverables and assignments
+- **Project outputs** — code repositories, models, demo applications
+- **Tags** — project domains (e.g., `nlp`, `rag`, `ner`, `chatbot`, `multimodal`, `dataset`, `evaluation`)
+
+Example path: `pages/students/2022/jakub_schwarc/README.md`
+
+## Project Notes (`pages/topics/`)
+
+Each topic is a directory (or file) under `pages/topics/` containing:
+
+- **Project descriptions** — goals, scope, applications
+- **Task lists** — planned and completed work items
+- **Research references** — papers, datasets, tools, frameworks
+- **People** — team members involved
+- **Notes** — meeting notes, experimental results, troubleshooting
+
+Topics cover NLP research areas including BERT training, chatbot development, hate speech detection, named entity recognition, machine translation, sequence-to-sequence models, legal text processing, morphological analysis, and Slovak question answering.
+
+## Grav-specific Conventions
+
+- **Numeric prefixes** (`02.`, `04.`, `05.`) control page ordering in the GRAV navigation tree.
+- **YAML frontmatter** uses `taxonomy` for categories (`[dp2027]`, `[bp2025]`, `[project]`, `[info]`) and tags (`[nlp]`, `[rag]`, `[ner]`).
+- **`published: true`** controls page visibility.
+- **`process.markdown: false`** and **`process.twig: true`** disable Markdown rendering and enable Twig templates (used for dynamic collection pages like the topics index).
+- **Relative links** to other pages use paths like `/students/2022/jakub_schwarc` or `/topics/hatespeech`.
+
+## Configuration (`config/`)
+
+- `config/plugins/` — GRAV plugin settings
+- `config/themes/` — Theme configuration
+
+## Themes (`themes/`)
+
+- `knowledge-base/` — Primary knowledge-base theme
+- `mytheme/` — Custom theme

pages/AGENTS.md

@@ -0,0 +1,186 @@
+# Wiki Content Guide
+
+## Purpose
+
+This Grav wiki manages final theses, semester projects, and internships. Treat its pages as long-lived supervision records rather than polished articles: preserve factual history, make current work easy to find, and distinguish recorded facts from proposed work.
+
+The main content areas are:
+
+- `topics/`: support materials and general project summaries.
+- `interns/`: intern profiles.
+- `students/<start-year>/`: student profiles grouped by the year in which the student started studying.
+
+## General editing rules
+
+- Preserve the language already used by a page. Student profiles are usually in Slovak; intern profiles may be in English. Use the page's language for new headings and text.
+- Preserve valid Grav YAML front matter between `---` delimiters. Do not rename existing taxonomy keys.
+- Treat `taxonomy.author` as the supervisor, `taxonomy.tag` as project keywords, and `taxonomy.category` as project-type/year categories such as `bp2027`, `dp2027`, or `vp2026`.
+- Use lowercase `first_last` profile directory names without diacritics. Keep the person's correct spelling and diacritics in the front-matter `title`.
+- Do not invent names, dates, assignments, status updates, completed work, repository URLs, results, or citations. If required information is missing, leave an explicit placeholder or ask for it.
+- Keep links descriptive. Every active student project should have a visible link to its Git repository. Do not mistake a linked dependency, article, dataset, or related project for the student's repository.
+- Prefer focused edits. Do not reformat or reorganize a legacy profile unless the task requires it.
+- Apply the canonical formats below to new profiles and substantial new project sections. When updating an existing section, follow its established style unless doing so would make the record ambiguous.
+
+## Finding and comparing projects
+
+When searching for a person or project, search across `students/`, `interns/`, and `topics/`, not only the newest cohort. Check:
+
+- profile names and project titles;
+- front-matter categories, tags, and authors;
+- assignment text, goals, meeting status, and task backlogs;
+- Git repository links and links to related wiki topics.
+
+When identifying similar projects, explain the similarity using concrete evidence such as a shared task, domain, dataset, method, model, or evaluation approach. Separate direct predecessors from projects that are only thematically related.
+
+## Creating a student profile
+
+Create a profile at `students/<start-year>/<first_last>/README.md`. Use this baseline:
+
+```markdown
+---
+title: Full Student Name
+published: true
+taxonomy:
+    category: [project_type_and_end_year]
+    tag: [keyword-one,keyword-two]
+    author: Supervisor Name
+---
+
+rok začiatku štúdia: YYYY
+
+# Project Type YYYY
+
+Názov:
+
+Project title
+
+Repozitár:
+
+- [Git repozitár](https://example.invalid/repository)
+
+Zadanie:
+
+1. First assignment point.
+2. Second assignment point.
+```
+
+Replace all placeholders before publishing. The year in the project heading and taxonomy category is the project's expected ending year, not the study start year. Add every project represented on the profile to `taxonomy.category`.
+
+Common Slovak project/category names are:
+
+- `Bakalárska práca` / `bpYYYY`
+- `Bakalársky projekt` / `bpYYYY`
+- `Diplomová práca` / `dpYYYY`
+- `Diplomový projekt` / `dpYYYY`
+- `Vedecký projekt` / `vpYYYY`
+- `Tímový projekt` / `tpYYYY`
+
+Follow an existing nearby profile when another established project type is needed.
+
+## Creating an intern profile
+
+Create a profile at `interns/<first_last>/README.md`. Intern pages normally use the language of supervision and this baseline:
+
+```markdown
+---
+title: Full Intern Name
+published: true
+taxonomy:
+    category: [internship-program]
+    tag: [keyword-one,keyword-two]
+    author: Supervisor Name
+---
+
+Internship program and period
+
+Goal:
+
+- Primary goal
+
+Repository:
+
+- [Git repository](https://example.invalid/repository)
+
+Tasks:
+
+1. First task.
+2. Second task.
+```
+
+Record the internship period instead of a student study-start year. Add results, reports, datasets, and model links when they become available.
+
+## Student project sections
+
+A student may have several semester or final projects in one profile. Each project section must make these items identifiable:
+
+- project type and ending year in the heading;
+- project title;
+- assignment or clearly marked preliminary assignment;
+- Git repository link;
+- goals or expected outputs when known;
+- dated meeting records.
+
+Place the newest/current project first. Keep older project records because they provide context and make related work discoverable.
+
+Do not silently turn preliminary ideas into an approved assignment. Label tentative content with the page's existing terms, for example `Predbežné zadanie`, `Návrh`, `Možné ciele`, or `Nápady`.
+
+## Meeting records
+
+Add new meetings under the relevant project, newest first. Use the page's language. A Slovak record should normally look like:
+
+```markdown
+Stretnutie DD.MM.YYYY
+
+Stav:
+
+- Work completed or current observed state.
+- Important problem or result.
+
+Úlohy:
+
+- Concrete next action with an observable output.
+- Another prioritized action.
+
+Zásobník úloh:
+
+- Lower-priority or possible future work.
+```
+
+An English intern record may use `Meeting`, `State`, `Tasks`, and `Future tasks`. Omit an empty optional backlog, but do not omit known status or assigned tasks. Preserve checkbox notation where a page already uses it; never mark a task complete without recorded evidence.
+
+## Writing assignments and proposing tasks
+
+Write project assignments as numbered, outcome-oriented points. A useful assignment normally progresses through:
+
+1. reviewing relevant methods and literature;
+2. selecting or preparing data, tools, or an experimental setup;
+3. implementing and evaluating the proposed solution;
+4. identifying limitations and proposing improvements.
+
+Adapt that sequence to the actual project instead of copying generic wording unchanged. Keep the title, assignment, goals, tasks, and expected artifacts consistent.
+
+When proposing new tasks from a project status:
+
+- read the latest meeting and unresolved earlier tasks first;
+- connect each proposal to a recorded problem, result, assignment point, or missing deliverable;
+- prioritize the smallest verifiable next steps;
+- include expected artifacts such as code, data, tables, experiment results, or written sections;
+- reuse relevant methods or resources found in similar projects, with links;
+- distinguish immediate tasks from optional ideas or backlog items;
+- include updating the Git repository when code or data is produced, without requesting secrets or credentials.
+
+Do not claim that a proposed experiment will improve results. State what it is intended to test and how the result should be evaluated.
+
+## Review checklist
+
+Before finishing a content change, verify that:
+
+- front matter is valid YAML and retains `title`, `published`, and taxonomy data;
+- the profile path and study-start year or internship period agree;
+- every project heading and category uses the ending year;
+- the person's name, supervisor, and keywords are present;
+- each active student project has its title, assignment, and Git repository link;
+- a new meeting has a date, status, and actionable tasks and is in newest-first order;
+- proposed facts are not presented as recorded facts;
+- internal and external links are syntactically valid;
+- unrelated historical content and formatting were left intact.

pages/interns/dries_huybens/README.md

@@ -0,0 +1,51 @@
+---
+title: Dries Huybens
+published: true
+taxonomy:
+    category: [erasmus]
+    tag: [nlp, ie, rag, medical]
+    author: Daniel Hladek
+---
+
+ERASMUS Intern Summer 2026, 20 July  - 30 August
+
+Topic:
+
+Multilingual Knowledge Graphs from medical data
+
+Goal:
+
+- Construct a knowledge graph from medical package inserts in multiple languages
+- Utilize the graph in an intelligent agent that recommends medication.
+
+Tasks:
+
+- Continue project of [Bogdan Paul Chis](/interns/bogdan_paul_chis)
+- Study repositories:
+  - https://github.com/chis-facultate/erasmus-kosice
+  - https://github.com/hladek/mul-me-kg
+  - https://github.com/hkuds/lightrag
+
+- Learn intelligent agents and generative models - OpenAI API, Agent frameworks, RAG systems.
+- Learn about knowledge graphs and GraphRAG. Read several research papers.
+- Prepare a Python based workflow, use git code repository
+- Visualize the graph
+- Prepare an agent that utilizes the unstructured data and graph-data.
+- Evaluate the agent using DeepEval or RAGAS.
+- Write a report
+- Put all code to GIT
+
+
+
+Project tasks update:
+
+- Prepare a multilingual parallel corpus from OPUS data
+- Prepare dataset for visual language model evaluation from foto
+- Prepare dataset for visual language model evaluation from wikipedia. You can use https://huggingface.co/datasets/wikimedia/wit_base .
+- Prepare corpus of text and image data from pravda.sk .  For each subdomain, create - raw HTML data with images. Then create corpus of images plus descriptions, subtitles and tags. Then create corpus of extracted text. You can use docling , trafilatura for text extration. Or design your own parser. Give source codes to a git repository with documentation. Put data files to school server. Do not download too fast, so our IP does not reveive a ban.
+
+Outupus:
+
+- multilingual corpus was analyzed with embedding models. Semantic overlap between languages is low, so multilngual parallel corpus will be small.
+- A [corpus](https://huggingface.co/datasets/driesaster/fotkyzadarmo_slovak) from FotkyZadarmo.sk
+

pages/interns/dries_huybens/opus_pipeline.py

@@ -0,0 +1,442 @@
+#!/usr/bin/env python3
+
+import argparse
+import csv
+import gzip
+import hashlib
+import re
+import shutil
+import sys
+import time
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import duckdb
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+LANGS = ["cs", "hr", "pl", "sk", "sl"]
+TEXT_EXTS = ("en", *LANGS)
+
+FILENAME_RE = re.compile(
+    r"^(?P<corpus>.+)\.(?P<langpair>[a-z]{2}-[a-z]{2})\.(?P<ext>en|cs|hr|pl|sk|sl)$"
+)
+
+# md5 of the normalised English text. Normalisation is surface-level only:
+# trim, collapse internal whitespace runs, casefold. No punctuation or
+# semantic folding -- those would merge genuinely distinct strings.
+NORMALISE = r"lower(regexp_replace(trim(en_text), '\s+', ' ', 'g'))"
+MERGE_KEY = f"md5({NORMALISE})"
+
+
+# ---------------------------------------------------------------------------
+# stage 1: extract
+# ---------------------------------------------------------------------------
+
+def read_lines(path: Path) -> list[str]:
+    with open(path, encoding="utf-8") as fh:
+        return [line.rstrip("\n") for line in fh]
+
+
+def drop_separator_pairs(en: list[str], tgt: list[str]) -> tuple[list[str], list[str]]:
+    """
+    Remove line pairs blank on BOTH sides.
+
+    Some exports insert a blank line into both files at once as a document
+    or domain separator -- CCAligned.cs-en has 255 of them, exactly matching
+    its 255 <linkGrp> elements. They are not links and must go before line N
+    can equal link N.
+
+    Only *simultaneously* blank pairs are dropped. A real link with a missing
+    translation is blank on one side only, so genuine data cannot be caught
+    by this.
+    """
+    keep_en, keep_tgt = [], []
+    for e, t in zip(en, tgt):
+        if e == "" and t == "":
+            continue
+        keep_en.append(e)
+        keep_tgt.append(t)
+    return keep_en, keep_tgt
+
+
+def _side_is_english(doc_path: str) -> bool:
+    """OPUS doc paths are language-prefixed: 'en/foo.xml.gz', 'cs/bar/baz.xml.gz'."""
+    return doc_path.split("/", 1)[0] == "en"
+
+
+def parse_ids_file(path: Path) -> list[tuple[int, int]]:
+    """
+    Tab-separated: doc_a, doc_b, ids_a, ids_b -- ids space-separated within
+    a column. Returns (n_english_ids, n_target_ids) per link.
+    """
+    out = []
+    with open(path, encoding="utf-8") as fh:
+        for line in fh:
+            parts = line.rstrip("\n").split("\t")
+            if len(parts) < 4:
+                parts = re.split(r"\s{2,}", line.rstrip("\n"))
+            if len(parts) < 4:
+                out.append((0, 0))  # unparseable -> never counts as clean
+                continue
+            doc_a, _doc_b, ids_a, ids_b = parts[0], parts[1], parts[2], parts[3]
+            n_a, n_b = len(ids_a.split()), len(ids_b.split())
+            out.append((n_a, n_b) if _side_is_english(doc_a) else (n_b, n_a))
+    return out
+
+
+def parse_xml_file(path: Path) -> list[tuple[int, int]]:
+    """
+    XCES alignment. Streamed with iterparse and cleared as we go -- some of
+    these files are 500MB+ and a full DOM is not affordable.
+
+    Multiple <linkGrp> elements are concatenated in document order, matching
+    how the flat text file numbers its lines globally.
+    """
+    out = []
+    english_left = True
+    for event, elem in ET.iterparse(str(path), events=("start", "end")):
+        if event == "start" and elem.tag == "linkGrp":
+            english_left = _side_is_english(elem.get("fromDoc", ""))
+        elif event == "end":
+            if elem.tag == "link":
+                sides = elem.get("xtargets", "").split(";")
+                if len(sides) != 2:
+                    out.append((0, 0))
+                else:
+                    a, b = len(sides[0].split()), len(sides[1].split())
+                    out.append((a, b) if english_left else (b, a))
+                elem.clear()
+            elif elem.tag == "linkGrp":
+                elem.clear()
+    return out
+
+
+def extract_one(root: Path, corpus: str, langpair: str) -> pa.Table:
+    a, b = langpair.split("-")
+    lang = b if a == "en" else a
+
+    en_path = root / f"{corpus}.{langpair}.en"
+    tgt_path = root / f"{corpus}.{langpair}.{lang}"
+    xml_path = root / f"{corpus}.{langpair}.xml"
+    ids_path = root / f"{corpus}.{langpair}.ids"
+
+    en_raw, tgt_raw = read_lines(en_path), read_lines(tgt_path)
+    if len(en_raw) != len(tgt_raw):
+        raise ValueError(
+            f"text files disagree: en={len(en_raw)} {lang}={len(tgt_raw)}"
+        )
+
+    en_lines, tgt_lines = drop_separator_pairs(en_raw, tgt_raw)
+    n = len(en_lines)
+
+    if xml_path.exists():
+        counts, align_source = parse_xml_file(xml_path), "xml"
+    elif ids_path.exists():
+        counts, align_source = parse_ids_file(ids_path), "ids"
+    else:
+        counts, align_source = [(1, 1)] * n, "none"
+
+    if len(counts) != n:
+        raise ValueError(
+            f"{align_source} has {len(counts)} links but {n} usable text lines "
+            "-- refusing to pair them positionally"
+        )
+
+    # A link whose English side is empty has no reachable key: drop it.
+    # A link with English present but the translation empty is kept -- the
+    # English key survives and that language is simply NULL.
+    keep = [i for i in range(n) if en_lines[i].strip() != ""]
+
+    return pa.table({
+        "corpus": pa.array([corpus] * len(keep)),
+        "langpair": pa.array([langpair] * len(keep)),
+        "lang": pa.array([lang] * len(keep)),
+        "line_no": pa.array([i + 1 for i in keep], type=pa.int64()),
+        "en_text": pa.array([en_lines[i] for i in keep]),
+        "lang_text": pa.array(
+            [tgt_lines[i] if tgt_lines[i].strip() != "" else None for i in keep]
+        ),
+        "en_n_ids": pa.array([counts[i][0] for i in keep], type=pa.int32()),
+        "lang_n_ids": pa.array([counts[i][1] for i in keep], type=pa.int32()),
+        "clean": pa.array([counts[i] == (1, 1) for i in keep]),
+        "align_source": pa.array([align_source] * len(keep)),
+    })
+
+
+def discover(root: Path, exclude: set[str]) -> list[tuple[str, str]]:
+    found: dict[tuple[str, str], set[str]] = {}
+    for path in root.iterdir():
+        if not path.is_file():
+            continue
+        m = FILENAME_RE.match(path.name)
+        if not m:
+            continue
+        corpus, langpair, ext = m["corpus"], m["langpair"], m["ext"]
+        if corpus in exclude:
+            continue
+        if "en" not in langpair.split("-"):
+            continue
+        found.setdefault((corpus, langpair), set()).add(ext)
+
+    combos = []
+    for (corpus, langpair), exts in found.items():
+        a, b = langpair.split("-")
+        target = b if a == "en" else a
+        if "en" in exts and target in exts:
+            combos.append((corpus, langpair))
+    return sorted(combos)
+
+
+def stage_extract(root: Path, out_dir: Path, exclude: set[str], report_path: Path) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    combos = discover(root, exclude)
+    print(f"[extract] {len(combos)} corpus x langpair combos "
+          f"({len(exclude)} corpora excluded)")
+
+    rows = []
+    for i, (corpus, langpair) in enumerate(combos, 1):
+        dest = out_dir / f"{corpus}.{langpair}.parquet"
+        if dest.exists():
+            print(f"[extract] {i}/{len(combos)} {corpus}.{langpair} -- already done")
+            continue
+        t0 = time.time()
+        tmp = dest.with_suffix(".parquet.partial")
+        try:
+            table = extract_one(root, corpus, langpair)
+            pq.write_table(table, tmp)
+            tmp.replace(dest)  # atomic: a partial file never looks complete
+            n = table.num_rows
+            n_clean = sum(table.column("clean").to_pylist())
+            src = table.column("align_source")[0].as_py() if n else ""
+            pct = round(100 * n_clean / n, 2) if n else 0.0
+            print(f"[extract] {i}/{len(combos)} {corpus}.{langpair} -- "
+                  f"{n:,} rows, {pct}% clean, {src}, {time.time()-t0:.0f}s")
+            rows.append(dict(corpus=corpus, langpair=langpair, status="ok",
+                             rows=n, clean_pct=pct, align_source=src, error=""))
+        except Exception as exc:
+            tmp.unlink(missing_ok=True)
+            print(f"[extract] {i}/{len(combos)} {corpus}.{langpair} -- FAILED: {exc}")
+            rows.append(dict(corpus=corpus, langpair=langpair, status="failed",
+                             rows=0, clean_pct=0.0, align_source="", error=str(exc)))
+
+    if rows:
+        write_header = not report_path.exists()
+        with open(report_path, "a", newline="", encoding="utf-8") as fh:
+            w = csv.DictWriter(fh, fieldnames=["corpus", "langpair", "status", "rows",
+                                               "clean_pct", "align_source", "error"])
+            if write_header:
+                w.writeheader()
+            w.writerows(rows)
+        n_fail = sum(1 for r in rows if r["status"] == "failed")
+        print(f"[extract] {len(rows)-n_fail} ok, {n_fail} failed -> {report_path}")
+
+
+# ---------------------------------------------------------------------------
+# stage 2: bucket
+# ---------------------------------------------------------------------------
+
+def stage_bucket(con, out_dir: Path, keyed_dir: Path, n_buckets: int) -> None:
+    """
+    One streaming pass. Every row gets its merge_key and a bucket number.
+    Rows sharing a merge_key always land in the same bucket, so each bucket
+    can later be merged in isolation with no cross-bucket reconciliation.
+
+    This is a projection plus a write -- no aggregation, so it does not build
+    the large hash table that made the single-query merge run out of memory.
+    """
+    print(f"[bucket] partitioning into {n_buckets} buckets -> {keyed_dir}/")
+    t0 = time.time()
+    staging = keyed_dir.with_name(keyed_dir.name + ".partial")
+    if staging.exists():
+        shutil.rmtree(staging)
+    con.execute(f"""
+        COPY (
+            SELECT
+                {MERGE_KEY} AS merge_key,
+                en_text, lang, lang_text, clean,
+                en_n_ids, lang_n_ids, corpus, langpair,
+                abs(hash({MERGE_KEY})) % {n_buckets} AS bucket
+            FROM read_parquet('{out_dir}/*.parquet')
+        ) TO '{staging}' (FORMAT PARQUET, PARTITION_BY (bucket), OVERWRITE_OR_IGNORE true)
+    """)
+    staging.replace(keyed_dir)
+    print(f"[bucket] done in {time.time()-t0:.0f}s")
+
+
+# ---------------------------------------------------------------------------
+# stage 3: merge
+# ---------------------------------------------------------------------------
+
+def per_language_columns() -> str:
+    """
+    For each language: pick ONE source row and take its text, flag, grouping
+    counts and corpus from that same row.
+
+    This deliberately avoids separate any_value() calls per field. Those are
+    independent aggregates -- given several candidate rows for one key and
+    language (exactly what happens with common boilerplate), each call may
+    pick a different row, so the clean flag could describe a translation that
+    was not the one kept. Packing the fields into a struct and unpacking after
+    aggregation keeps them from a single row.
+
+    max() on a struct compares field-by-field in declaration order, so putting
+    is_clean first makes a strict 1:1 link win over a grouped one, with the
+    text as a deterministic tiebreak. That is a policy choice, not a neutral
+    one: among equally valid candidates it prefers the cleanly-aligned link.
+
+    Three counters accompany each language:
+
+      <lang>_n_rows      how many source rows supplied a translation
+      <lang>_n_distinct  how many DIFFERENT translations among them
+      <lang>_n_corpora    how many distinct corpora contributed
+
+    n_distinct is the one that matters for quality: = 1 means every source
+    agreed, so the pick was arbitrary only between identical strings. The gap
+    between n_rows and n_distinct measures pure duplication -- on a sample it
+    ran ~80%, largely because several corpora in the download appear to be the
+    same data under different names. n_corpora separates "one corpus repeated"
+    from "many corpora agreeing".
+    """
+    parts = []
+    for lang in LANGS:
+        pick = (
+            f"max(CASE WHEN lang = '{lang}' THEN struct_pack("
+            f"is_clean := clean, txt := lang_text, "
+            f"n_en := en_n_ids, n_tgt := lang_n_ids, src := corpus) END)"
+        )
+        parts.append(f"{pick}.txt       AS {lang}_text")
+        parts.append(f"{pick}.is_clean  AS {lang}_clean")
+        parts.append(f"{pick}.n_en      AS {lang}_en_n_ids")
+        parts.append(f"{pick}.n_tgt     AS {lang}_n_ids")
+        parts.append(f"{pick}.src       AS {lang}_corpus")
+        parts.append(
+            f"count(*) FILTER (WHERE lang = '{lang}' AND lang_text IS NOT NULL) "
+            f"AS {lang}_n_rows"
+        )
+        parts.append(
+            f"count(DISTINCT CASE WHEN lang = '{lang}' THEN lang_text END) "
+            f"AS {lang}_n_distinct"
+        )
+        parts.append(
+            f"count(DISTINCT CASE WHEN lang = '{lang}' AND lang_text IS NOT NULL "
+            f"THEN corpus END) AS {lang}_n_corpora"
+        )
+    return ",\n            ".join(parts)
+
+
+def stage_merge(con, keyed_dir: Path, merged_dir: Path, n_buckets: int) -> None:
+    merged_dir.mkdir(parents=True, exist_ok=True)
+    cols = per_language_columns()
+    total = 0
+    for i in range(n_buckets):
+        src_dir = keyed_dir / f"bucket={i}"
+        dest = merged_dir / f"bucket_{i:04d}.parquet"
+        if dest.exists():
+            total += con.execute(f"SELECT count(*) FROM '{dest}'").fetchone()[0]
+            continue
+        if not src_dir.exists() or not any(src_dir.glob("*.parquet")):
+            print(f"[merge] bucket {i} empty, skipping")
+            continue
+        t0 = time.time()
+        tmp = dest.with_suffix(".parquet.partial")
+        con.execute(f"""
+            COPY (
+                SELECT
+                    merge_key,
+                    any_value(en_text) AS en_text,
+                    {cols}
+                FROM read_parquet('{src_dir}/*.parquet')
+                GROUP BY merge_key
+            ) TO '{tmp}' (FORMAT PARQUET)
+        """)
+        tmp.replace(dest)
+        n = con.execute(f"SELECT count(*) FROM '{dest}'").fetchone()[0]
+        total += n
+        print(f"[merge] bucket {i}/{n_buckets-1}: {n:,} keys, {time.time()-t0:.0f}s")
+    print(f"[merge] {total:,} unique English keys across {n_buckets} buckets")
+
+
+# ---------------------------------------------------------------------------
+# summary
+# ---------------------------------------------------------------------------
+
+def summarise(con, merged_dir: Path) -> None:
+    glob = f"{merged_dir}/*.parquet"
+    total = con.execute(f"SELECT count(*) FROM read_parquet('{glob}')").fetchone()[0]
+    print(f"\n{'='*64}\nunique English keys: {total:,}\n{'='*64}")
+    print(f"{'lang':<6}{'covered':>16}{'%':>8}{'clean':>16}{'ambiguous':>14}")
+    for lang in LANGS:
+        cov, clean, ambiguous = con.execute(f"""
+            SELECT count(*) FILTER (WHERE {lang}_text IS NOT NULL),
+                   count(*) FILTER (WHERE {lang}_clean),
+                   count(*) FILTER (WHERE {lang}_n_distinct > 1)
+            FROM read_parquet('{glob}')
+        """).fetchone()
+        pct = 100 * cov / total if total else 0
+        print(f"{lang:<6}{cov:>16,}{pct:>7.1f}%{clean:>16,}{ambiguous:>14,}")
+    print("\n'ambiguous' = keys where sources supplied genuinely DIFFERENT "
+          "translations.\nFilter on <lang>_n_distinct = 1 for the unambiguous "
+          "subset, <lang>_clean for strict 1:1 links.\nNote: <lang>_clean is "
+          "inflated by design -- the tiebreak prefers clean candidates.")
+
+
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--root", required=True, type=Path,
+                    help="directory holding the OPUS plain-text download")
+    ap.add_argument("--work", default=Path("build"), type=Path,
+                    help="working directory for all intermediate and final output")
+    ap.add_argument("--buckets", type=int, default=128,
+                    help="raise if a bucket runs out of memory during merge")
+    ap.add_argument("--memory-limit", default="100GB",
+                    help="keep comfortably under the container's ceiling")
+    ap.add_argument("--exclude", default="",
+                    help="comma-separated corpus names to skip entirely, e.g. "
+                         "MultiHPLT,MultiCCAligned,MultiParaCrawl,MultiMaCoCu")
+    ap.add_argument("--force-stage", default="", choices=["", "bucket", "merge"],
+                    help="redo a stage that is already on disk")
+    args = ap.parse_args()
+
+    work = args.work
+    out_dir = work / "extracted"
+    keyed_dir = work / "keyed"
+    merged_dir = work / "merged"
+    tmp_dir = work / "duckdb_tmp"
+    for d in (work, tmp_dir):
+        d.mkdir(parents=True, exist_ok=True)
+
+    exclude = {c.strip() for c in args.exclude.split(",") if c.strip()}
+
+    con = duckdb.connect()
+    con.execute("PRAGMA enable_progress_bar=true")
+    con.execute(f"SET memory_limit='{args.memory_limit}'")
+    con.execute(f"SET temp_directory='{tmp_dir}'")
+    con.execute("SET preserve_insertion_order=false")
+
+    started = time.time()
+
+    stage_extract(args.root, out_dir, exclude, work / "extract_report.csv")
+
+    if args.force_stage == "bucket" and keyed_dir.exists():
+        shutil.rmtree(keyed_dir)
+    if keyed_dir.exists():
+        print(f"[bucket] {keyed_dir}/ present -- skipping "
+              f"(--force-stage bucket to redo)")
+    else:
+        stage_bucket(con, out_dir, keyed_dir, args.buckets)
+
+    if args.force_stage == "merge" and merged_dir.exists():
+        shutil.rmtree(merged_dir)
+    stage_merge(con, keyed_dir, merged_dir, args.buckets)
+
+    summarise(con, merged_dir)
+    print(f"\ntotal wall time {(time.time()-started)/60:.1f} min")
+    print(f"query with: SELECT * FROM read_parquet('{merged_dir}/*.parquet')")
+
+
+if __name__ == "__main__":
+    main()

pages/students/2022/andrii_pervashov/README.md

@@ -16,6 +16,9 @@ Návrh na tému:
 
 Prepis reči pre tvorbu štruktúrovaného zdravotného záznamu
 
+Repo https://git.kemt.fei.tuke.sk/ap565wq/diplomova_praca
+
+
 Ciele:
 
 - Vytvorte systém pre prepis reči a naplnenie formulára pomocou lokálnych jazykových modelov
@@ -32,12 +35,49 @@ Teoretické úlohy:
 - Oboznámte sa s postupmi pre dotrénovanie jazykového modelu - LORA, PEFT.
 - Oboznámte sa s metódami Information Extraction. Vyhľadajte si články na túto tému a napíšte, aké metódy sa používajú. Vstupom je text v prir. jazyku, výstupom je niečo ako JSON.
 
-
 Zásobník úloh:
 - Vyskúšajte ako funguje rozpoznávanie reči cez OPeWEBUI. Navrhnute zlepšenia.
 - Ako vieme zistiť, ktoré informácie nám chýbajú?
 
+Stretnutie 24.9.2026
 
+Stav:
+
+- Urobený deployment na http://147.232.204.160:3000/ 
+- Prečítané základy Lora a information extraction podľa inštrukcií.
+
+Úlohy:
+
+- Presne špecifikovať scenár, ktorý riešime pomocou akustického a jazykového modelu. Nemusí byť z medicínskej oblasti. 
+- Pohľadajte vhodnú existujúcu dátovú množinu pre tento scenár. Nemusí byť po slovensky. Príkladom môžu byť úlohy súvisiace s prepisom stretnutí - meeting speech. Ako zdroje použite Huggingface, Kaggle, Clarin, ELRA. Nájdite viac  podobných množin. 
+- Použite existujúci prepisovať a jazykový model pre riešenie tejto úlohy.
+- Použite trénovaciu časť tejto množiny pre zlepšenie aktuálnych modelov. Môžete využiť PEFT alebo RAG.
+- Do písomnej časti napíšte definíciu úlohy, prehľad existujúcich dátových množín, prehľad metód riešenia definovanej úlohy a opis Vášho riešenia.
+- Otestujte Vaše riešenie na testovacej časti dátovej množiny.
+
+
+
+Stretnutie 10.6.2026
+
+Stav:
+
+- prepísaný kód rozhrania do knižnice next js. 
+- použitie lokálnych modelov cez ollama, zatiaľ qwen3-4B beží na PC. Model nejde veľmi dobre.
+- Na PC beží aj lokálny Whisper - funguje oveľa horšie.
+- aplikácia je kontajnerizovaná - docker compose.
+
+Úlohy:
+
+- Oboznámte sa s postupmi pre dotrénovanie jazykového modelu - LORA, PEFT.
+- Oboznámte sa s metódami Information Extraction. Vyhľadajte si články na túto tému a napíšte, aké metódy sa používajú. Vstupom je text v prir. jazyku, výstupom je niečo ako JSON. Napíšte si poznámky. 
+- Vyhľadajte články o podobných prístupoch - ako rečovo naplniť formulár.
+- Zistite podrobnosti o procese tvorby formulára "Záznam o zhodnotení zdravotného stavu osoby". Získajte vzor. Zistite otázky ktoré sú dôležité.
+
+Zásobník úloh:
+
+- Zostavte testovací scenár a testovaciu množinu.
+- Nasadte aplikáciu na školskej infraštruktúre a využite kvalitnejšie jazykové modely a modely pre rozpoznávanie reči.
+- Implementujte mechanizmus spätnej väzby - kontrola správnosti a doplnenie chýbajúcich hodnôt.
 
 
 ## Bakalárska práca 2025

pages/students/2022/jakub_schwarc/README.md

@@ -10,6 +10,36 @@ taxonomy:
 
 rok začiatku štúdia: 2022
 
+# Diplomová práca 2027
+
+Stretnutie 1.10.ľ2026
+
+Stav:
+
+- vytvorený repozitár s konfiguráciami
+- vyskúšaná AYA collection dataset - zbehlo 86 percent datasetu. Kolísala evaluácia.
+- vyskúšaná lm-eval a Alpaca. 
+- Momentálne máme k dispozicii SlovakAlpaca a slovenskú časť AYA colections.
+- porovnanie AYA a Alpaca dotrénovania. Alpaca vyzerá lepšie.
+- prípravených 10 experimentov s eval a loss priebehom.
+- výsledky sú na https://git.kemt.fei.tuke.sk/js886io/Diplomovka
+
+Úlohy:
+
+- Navrhnite scenár pre dotrénovanie jazykového modelu. Ake LORA spôsoby? Ako nastaviť lm factory? 
+- Pripravte experiment na optimalizáciu hyperparametrov. Najdôležitejší je LR. Na ostetné sa môžete spýtať AI. Tú istú kofiguráciu spúštate s roznym LR v "menšom" experimente a sledujete evall loss. Sledujte aj gradient pre identifikáciu "explosion". Porovnanie má zmysel iba v rámci tohot experimentu. 
+- Napíšte projekt na HPC Perun.
+- Pripravte skript, ktorý zozbiera a pripravý trénovacie dáta, ktoré mame k dispozícii. Dáta rozdeľte na 3 časti. train, test, eval. Test a eval by mali byť tak, nastavené, aby vyhodnotenie na nich netrovalo príáliš dlho. Stačí iba jedna mnoižina ak sú dáta podobné.
+- pripravte skript, ktorý vyhodnotí výsledný model. Na vyhodnotenie použite "eval" časť dát.
+- napíšte poznámky do DP, kde opíšete metódy ktoré používate - Supervised Fine Tuning, modely ktoré používate, spôsob vyhodnotenie. 
+
+Úlohy na neskôr:
+
+- zlepšite trénovacie dáta
+- použite vyhodnotenie SK-bench.
+- Použite iný multilinguálny model na dotrénovanie - napr. OLMO.
+
+
 # Diplomový projekt 2026
 
 
@@ -21,9 +51,42 @@ Ciele na semester:
 
 - Dotrénujte a vyhodnotte Slovak Mistral.
 
+Stretnutie 10.6.2026
+
+Stav:
+
+- kódy sú na servri titan
+- funguje dotrénovanie Slovak Mistral pomocou Slovak Alpaca na Titan, pomocou unsloth aj LlamaFactory. Používa sa qlora.
+- po dotrénovaní to je ručne vyskúšané. Nevie odborné výrazy. Model rozumie jednoduchým inštrukciám. Model je ukecaný.
+
+Úlohy:
+
+- Vytvorte GIT repozitár a dajte tam kódy.
+- Pre LLmamaFactory dávajte na GIT konfigurácie.
+- Rozšírte trénovaciu sadu - o zdroje v https://github.com/slovak-nlp/resources Zatiaľ najlepšie vyzerá byť CohereLabs/aya_collection_language_split
+- Model zverejnite na HuggingFace hube.
+- Napíšte si poznámky o aktuálnych metódach PEFT a SFT. Preštudujte si vedecké články z Google Scholar.
+- Vyhodnotte model pomocu lm-evaluation-harness. Pozrite si výsledky https://wandb.ai/hladek/lmeval?nw=nwuserhladek
+
+Príkaz na vyhodnotenie je 
+```
+/home/dh343ko/miniconda3/envs/transformers/bin/lm-eval --model hf --model_args pretrained=google/mt5-large --tasks arc_sk,hellaswag_sk,m_mmlu_sk,truthfulqa_sk_mc1,truthfulqa_sk_mc2,sklegal,skquad --output_path zzz --wandb_args project=lmeval_mt5-large --device cuda:0 --batch_size 8
+```
+ 
+
+Zásobník úloh:
+
+- Možno bude potrebné použiť lepší HW.  
+- Zlepšite proces vyhodnotenia. Dá sa použiť  sk bech ktorý je v príprave. 
+- Zistite, čo je to zarovnanie jazykových modelov. Pozrite si framework huggingface trl. Zistite, čo je to meóda DPO a RLHF.  Ku tomu existuje  DP práca Hyrenko.
+- Strojovo preložte vybranú množinu.
+- Vytvorte github repozitár so skriptami pre dotrénovanie jazykovéo modelu.
+
+
+
 Stretnutie 27.2.
 
-- Obozn8mte sa problematikou podľa zadaných zdrojov.
+- Oboznámte sa problematikou podľa zadaných zdrojov.
 - Pozrite si https://allenai.org/olmo
 
 Úlohy:

pages/students/2022/jan_ptak/README.md

@@ -10,6 +10,47 @@ taxonomy:
 
 rok začiatku štúdia: 2022
 
+# Diplomová práca 2027
+
+
+Téma:
+
+Agent pre manažment záverečných prác
+
+Úlohy na semester:
+
+Agent by mal vedieť:
+- získať aktuálne dáta z GITU,
+- vedieť v nich vyhľadávať a zodpovedať otázky z vyhľadávania.
+- vedieť vyhľadávať na CRZP záverečné práce.
+- mal by fungovať cez openwebui rozhranie.
+- Vytvorte komplenté nasadenie agenta pomocou DockerCompose. 
+
+Úlohy do budúcnosti:
+
+- vyhodnotte vyhľadávanie - porovnajte RAG a GraphRAG
+- Pripravte testovacei scenáre pre agenta a s ich pomocou vyhodnotte agenta. 
+
+
+Stretnutie 30.9.2026
+
+Stav:
+
+- Funguje RAG systém, prepojenie s OpenWEBUI. Zatiaľ len pomocou agenta - treba zistiť implementačné detaily.
+- Používa modely cez ui.tukekemt.xyz - Fast120 (Qwen3.5) a me5mini
+- začíname pracovať na GraphRAG  a Neo4J
+
+Úlohy:
+
+- Pokračujte v GraphRAG -  Naprogramujte načítanie existujúcich Markdown textov do Neo4j — vytvorte uzly pre každú záverečnú prácu, autora, tému a kľúčové slová. Vytvorte grafové relácie medzi uzlami (napr. rovnaký autor → rovnaká téma, rovnaký študijný program)
+- Napíšte poznámky o GraphRAG — definícia, ako funguje, rozdiel oproti klasickému RAG, výhody a nevýhody
+- Agenta rozdeľte na samostatné komponenty (násttroje - tools alebo skills). Každý nástroj dajte do osobitného adresára na GIte. Každý nástroj by sa mal z gitu dať nainštalovať do OpenWebUI.
+- Pridajte aj "hlavného agenta" - prompt, ktorý buyde pracovať s nástrojmi,
+- Agenta, ktorý bude vyhľadávať na GITe môžete koncipovať ako MCP server, ktorý bude bežať v Dockeri.
+- Obboznámte sa s pojmami MCP, Tool, Skill, AGENTS.md
+
+
+
 # Diplomový projekt 2026
 
 
@@ -30,8 +71,27 @@ Zásobník úloh:
 
 - Zistite, čo je to znalostný graf
 - Naučte sa čo je to GraphRAG
-- Využite znalostný graf pre zlepšenie práce alebo vysvetliteľnosti jazkového modelu
+- Využite znalostný graf pre zlepšenie práce alebo vysvetliteľnosti jazykového modelu
 
+Stretnutie 8.6.2026
+
+Stav:
+
+- Odovzdané nejaké zdrojové kódy na https://git.kemt.fei.tuke.sk/jp170na/dp-zp-agent - načítanie z markdown, indexovanie do SQLite a FastAPI.
+- Ostatné úlohy neboli vyriešené.
+
+Úlohy:
+
+- Pokračujte v otvorených úlohách. Vypracujte písomnú správu o preštudovaných materiáloch. 
+- Sústredte sa na GraphRAG. Použite google scholar a https://graphrag.com/
+- Pozrite si kódy na https://github.com/hladek/kemthesis
+- Pozrite si systém https://github.com/hkuds/minirag
+
+Zásobník úloh:
+
+- Nové smerovanie môže byť spracovanie textov záverečných prác. Vytvorte RAG systém pre vyhľadávanie v záverečných prácach. 
+- Napojte sa na systém CRZP a prepojte ho s LLM agentom.
+- Vytvorte vyhľadávanie v dodaných textoch záverečných prác. 
 
 Stretnutie 20.2.2026
 

pages/students/2022/oleh_poiasnik/README.md

@@ -13,13 +13,49 @@ rok začiatku štúdia: 2022
 
 # Diplomová práca 2027
 
+
 Expertný agentový systém na podporu rozhodovania v lekárni
 
+Návrh na zadanie (draft):
+
+- Opíšte spôsoby vyhľadávania pomcou znalostných grafov.
+- Opíšte spôsoby vyhodnotneia takýchto systémov. 
+- Opíšte Váš systém. 
+- Vyhodnoote Váš systém. 
+
+
 Cieľ:
 
-- Vylepšiť agenta pre prácu so znalostným grafom - interakcie a kontraindikácie.
+- Vylepšiť agenta pre prácu so znalostným grafom - interakcie a kontraindikácie aj indikácie. 
 - Zostaviť znalostný graf z databázy príbalových letákov adc a s jeho pomocou zlepšiť generovanie odpovede.
 
+
+Stretnutie 2.10.2026
+
+Stav:
+
+- Pomocou scrapera je získaná kompletná databáza ADC. Z týchto dát existuje štruktúrovaný znalostný graf pre 35000 liekov. Unikatny počet je cca 1500 až 2000.  LLM exctrahuje vzťahy aj entity. 
+- Prebieha deduplikácia - rôzna gramáž môže mať skoro ten istý leták.
+- Problém je rýchlosť - LLM za jeden deň dokáže spracovať cca 100 liekov. Celá databáza cca 2 až 3 týždne.
+- Plán je spracovávať menšie dáta, nie celý leták. Budeme sa sústrediť na sekcie s interakciami a kontraindikáciami.
+- Je potrebné prideliť školský server.
+- Ako vytvoriť web DEMO?
+- Kódy sú na školskom kemt gite. 
+
+Úlohy:
+
+- Vyhodnotte navrhnutý systém vo vzorových scenároch. 
+- Pracujte na texte diplomovej práce. Opíšte spôsoby vyhľadávania pomcou znalostných grafov. Opíšte spôsoby vyhodnotneia takýchto systémov. Opíšte Váš systém. Vyhodnoote Váš systém. 
+- Vypracujte webové demo s Vašim agentom. Do výsledkov pridajte overenie a odôvodnenie výžsledkov - zobrazenie relevantnej časti znalostného grafu aj z textov z ADC.
+- Pracujte aj s indikáciou.
+
+Zásobník úloh:
+
+- Pridajte znalosti o dávkovaní. 
+
+
+# Diplomový projekt 2026
+
 Stretnutie 14.5.
 
 Stav:

pages/students/2022/valerii_kutsenko/README.md

@@ -20,15 +20,37 @@ Myšlienky:
 
 Možné úlohy:
 
-- Navrhnite agenta, ktorý bude budovať a využívať znalostný graf pri vyhľadávaní.
-- Môže to byť v oblasti vzdelávania, práva alebo medicíny.
+- Navrhnite agenta, ktorý bude budovať a využívať znalostný graf pri vyhľadávaní. Môže to byť v oblasti vzdelávania, práva alebo medicíny.
 - Zostavte multilinguálny znalostný graf, ktorý môže pomôcť pri generovaní.
+- Napíšte vedecký článok.
+
+Stretnutie 2.10.2026
+
+Stav:
+
+- urobený experiment. Ako by sa dal využiť znalostný graf pri vyhľadávaní? Je tam zlepšenie? Urobené tri znalostné grafy z verejného anotovaného korpusu otázok a odpovedí. Grafy sú urobené pomocou LightRAG.
+- Vyzerá to tak, že vyhľadávanie s pomocou automaticky urobený graf dáva lepšie výsledky pri multi hop otázkach. Pri jednoduchých otázkach nemá lepšie výsledky.
+- Uzly sú entity extrahované z textu. 
+- Je to vyskúšané aj na slovenských dátach SkQuad.
+
+Úlohy:
+
+- Nájdite vhodné dátové množiny pre zostavenie a overenie multilinguálnych znalostných grafov. Dáta by mali mať prekrývajúcu sa časť - preloženú ručne alebo kvalitne strojovo. Potom môžeme porovnať automaticky vytvoreé znalostné grafy medzi viacerými jazykmi. Môžeme skúsiť "preložiť"  znalostný graf z jedného jazyka do druhého.
+- Zistite spôsoby vyhodnotenia znalostných gradov vzhľadom na textové dáta. Ako veľmi spolu "súvisia" a ako veľmi "súhlasia". Aké metriky sa používajú? graf vs text. Napíšte poznámky.
+
+Zásobník úloh:
+
+- porovnajte znalostný graf s textom, povedze ako súvisia
+- navrhnite spôsob multilinguálnej reprezentácie znalostných grafov. Ako využiť znalostný graf z jedného jazyka v inom jazyku. Dá sa spraviť znalostný graf ktorý je "nezávislý" na jazyku?
+
+
 
 Existujúca práca:
 
 - LightRAG - pozrite si to.
 
 
+
 Stretnutie 15.5.
 
 Stav:

pages/students/2024/adrian_ondra/README.md

@@ -0,0 +1,34 @@
+---
+title: Adrián Ondra
+published: true
+taxonomy:
+    category: [bp2027]
+    tag: [nlp,mind-maps,information-extraction]
+    author: Daniel Hladek
+---
+
+
+rok začiatku štúdia: 2024
+
+# Bakalársky projekt 2027
+
+Automatická tvorba myšlienkových máp
+
+
+Možné ciele semestrálneho projektu:
+
+- Vytvoriť vizualizáciu myšlienkovej mapy z automaticky extrahovaných entít.
+- Vytvoriť nástroj ktorý sa dá využiť pri vzdelávaní.
+- Vyhodnotiť kvalitu vytvoreného grafu. Ako veľmi je graf pravdivý vzhľadom na pôvvodný text.
+
+ úlohy:
+
+- Naučte sa Python, nainštalujte si Anaconda.
+- Zistite, čo je to myšlenkoá mapa, ako sa vytvára. Ako ju vieme zobraziť? Viaceré poznámkovače to majú v sebe zabudovanbé. Ako ju vieme využiť pri vzdelávaní? Urobte si poznámky na túto tému.
+- Zistite, ako je množné automaticky vytvárať myšlienkové mapy pomocou jazykových modelov. 
+- Zistite ako funguje rozpoznávanie pomenovaných entít (named entity recognition) a dependency parsing, a ako sa tieto techniky dajú využiť na identifikáciu kľúčových pojmov a ich vzťahov. Napíšte krátku správu (2-3 strany) s relevantnými vedeckými článkami
+- Oboznámte sa s nástrojmi na vizualizáciu grafov a znalostnycb grafov (napr. [NetworkX](https://networkx.org/), [Graphviz](https://graphviz.org/))
+
+- Porovnať rôzne metódy extrakcie kľúčových slov a zhodnotiť ich vhodnosť pre generovanie myšlienkových máp.
+
+

pages/students/2024/kristian_sokolsky/README.md

@@ -0,0 +1,54 @@
+---
+title: Kristián Sokolský
+published: true
+taxonomy:
+    category: [bp2027]
+    tag: [llm, alignment]
+    author: Daniel Hladek
+---
+
+
+rok začiatku štúdia: 2024
+
+# Bakalársky projekt 2027
+
+Zarovnávanie veľkých jazykových modelov
+
+Možné ciele semestrálneho projektu:
+
+- Zlepšenie bezpečnosti jazykových modelov.
+- Prípravu nových dát alebo zlepšenie existujúcich dát pre zarovnanie jazykových modelov. Napr. príprava korpusu Modrý koník alebo Modrá strecha.
+- Výber najlepších metód a hyperparametrov pre zarovanie LLM.
+
+Update 5.10
+
+Stav:
+
+- Preštudované problematika
+
+Úlohy:
+
+
+
+- Získajte dáta zo serra Modrý koník. Použite wget na získanie HTML súborov. 
+- Napíšte skript na tvorbu dátovej množiny vhodnej pre zarovnnie jazykového modelu pomocou frameworku trl.
+- Pokračujte v štúdu Python a reinformcement learning.
+- reporty vo formáte markdown, konfigurácie a kódy dávajte na kemt git.
+
+Stretnutie 23.9.2026 
+
+Úlohy:
+
+- Naučte sa [Python](https://student.kemt.fei.tuke.sk/python/home)
+- Nainštalujte si systém Anaconda
+- Oboznámte sa s knižnicou HF Transformers
+- Zistite, ako funguje neurónová sieť typu Transformer a ako sa trénuje veľký jazykový model. Napíšte o tom krátku správu (2 alebo 3 strany) kde uvediete aj relevantné vedecké články.
+- Pozrite si záznam z [DP Artur Hyrenko](https://zp.kemt.fei.tuke.sk/students/2021/artur_hyrenko)
+- Zistite, čo je to kontrolované učenie a čo je to učenie odmenou a trestom (reinforcement learning). Napíšte o tom krátku správu (2 alebo 3 strany) kde uvediete aj relevantné vedecké články.
+- Oboznámte sa s frameworkom [TRL](https://huggingface.co/docs/trl/en/index)
+
+
+
+
+
+

pages/students/2024/samuel_stucka/README.md

@@ -0,0 +1,53 @@
+---
+title: Samuel Štucka
+published: true
+taxonomy:
+    category: [bp2027]
+    tag: [nlp,corpus,text-processing]
+    author: Daniel Hladek
+---
+
+
+rok začiatku štúdia: 2024
+
+# Bakalársky projekt 2027
+
+Tvorba a spracovanie korpusu novinových článkov
+
+
+Predbežné úlohy:
+
+- Naučte sa Python, nainštalujte si Anaconda
+- Oboznámte sa s metódami získavania a extrakcie textu z HTML novinových článkov (napr. [Readability](https://github.com/buriy/python-readability), [Trafilatura](https://github.com/adbar/trafilatura))
+- Pozrite si: wget je nástorj na sťahovanie celých webov alebo ich sekcií. Druhá možnosť je použiť vlastný agent pre sťahovanie.
+- Na uloženie textových dát je dobré použiť kombináciu súborového systému a relačnej databázy (sqlite, postresql). 
+
+
+Možné ciele semestrálneho projektu:
+
+- Pripraviť čistý korpus novinových článkov s metadata informáciami.
+- Korpus by mal uchovať HTML aj obrázky z článkov (bez reklám a rozhrania). Mal by byť získaný "slušným" spôsobom. Mal by extrahovatť čo najviac metainformácií o článkoch - autor, zdroj, dátum vydania, sekcia, kľúčové slovíčka, nadpis, perex. Je dobré zachovať odkazy na obrázky. Ku obrázkom je dobré zachovať titulku, popis. 
+- Neskôr je možné aplikovať jayzkový model na zistenie alebo doplnenie ďalších metainformácií.
+- Neskôr môžeme spracovať aj blogy a diskusné skupiny. 
+- Môžeme dáta využiť na zlepšenie alebo overenie jazykových modelov. 
+- Implementovať pipeline na extrakciu a normalizáciu textu z rôznych zdrojov.
+
+Stretnutie 29.9. 2026
+
+Úlohy:
+
+- Učte sa Python, zistite ako prebieha trénovanie a dotrénovanie jazykových modelov. Napíšte krátku správu o tom ako sa trénuje jazykový model a ako sa dajú využiť kvalitné novinové dáta. 
+- Pozrite si predchádzajúce práce na tomto Wiki súvisiace s textovými a obrázkovými dátami.
+- Vytypujte si vhodné zdroje dát - články z servra Pravda. Aké iné noviny sú vhodné?
+- Pozrite si ako funguje Internet Archive a Wayback Machine.
+- Navrhnite vhodnú SQL relačnú schému. 
+- skripty a konfiguračné súbory dávajte ne KEMT git repozitár.
+- neskôr je možné využiť školský server na uloženie dát.
+
+Zásobník úloh:
+
+- stiahnuť a spracovať blogy.
+
+
+
+

pages/students/2024/sebastian_kiss/README.md

@@ -0,0 +1,41 @@
+---
+title: Sebastián Kišš
+published: true
+taxonomy:
+    category: [bp2027]
+    tag: [multimodal,dataset,evaluation]
+    author: Daniel Hladek
+---
+
+
+rok začiatku štúdia: 2024
+
+# Bakalársky projekt 2027
+
+Dáta pre vyhodnotenie multimodálnych jazykových modelov
+
+Ciel: Vytvoriť a použiť novú dátovú množinu pre vyhodnotenie muliimodálnych modelov s podporou slovenského jazyka
+
+Možné ciele semestrálneho projektu:
+
+- Pripraviť nový evalučný dátový súbor pre multimodálne jazykové modely.
+- Vytvoriť benchmark na porovnanie kvality výstupov rôznych multimodálnych modelov.
+- Implementovať automatickú metriku na hodnotenie semantickej zhody medzi textovými a vizuálnymi reprezentáciami.
+
+Stretnutie 30.9. 2026
+
+
+Úlohy:
+
+- Naučte sa Python, nainštalujte si Anaconda
+- Zistite, čo sú multimodálne jazykové modely (napr. BLIP, LLaVA, FLAN-PaLM). Ako sa hodnotí kvalita multimodálnych výstupov? Napíšte krátku správu (2-3 strany) s relevantnými vedeckými článkami
+- Oboznámte sa s existujúcimi multimodálnymi benchmarkmi (VQA, Visual Question Answering, Image Captioning)
+- Oboznámte sa s knižnicou [Hugging Face Datasets](https://huggingface.co/docs/datasets) a metódami hodnotenia multimodálnych modelov. - Pozrite si záznam o práci https://zp.kemt.fei.tuke.sk/interns/dries_huybens
+- Pozrite si zoznam existujúcich množín, poslaný cez Teams. 
+- Navrhnite svoju množinu - získanie z webu, digitalizácia nových dát alebo anotácia existujúcich dát. 
+
+Zásobník úloh:
+
+- Otestujme rozpoznávanie rukopisov a matematických výrazov.
+
+

pages/students/2024/yehor_piliavin/README.md

@@ -0,0 +1,28 @@
+---
+title: Yehor Piliavin
+published: true
+taxonomy:
+    category: [bp2027]
+    tag: [llm,alignment,steering-vectors]
+    author: Daniel Hladek
+---
+
+
+rok začiatku štúdia: 2024
+
+# Bakalársky projekt 2027
+
+Úprava generovania vo veľkých jazykových modeloch pomocou riadiacich vektorov
+
+Predbežné úlohy:
+
+- Naučte sa [Python](https://student.kemt.fei.tuke.sk/python/home)
+- Zistite, ako funguje neurónová sieť typu Transformer a ako sa trénuje veľký jazykový model. Napíšte o tom krátku správu (2 alebo 3 strany) kde uvediete aj relevantné vedecké články
+- Oboznámte sa s konceptom [steering vectors](https://arxiv.org/abs/2310.05915) -- ako sa vytvárajú, ako ovplyvňujú generovanie jazykových modelov
+- Pozrite sa na prácu s latentnými reprezentáciami v Transformeroch (napr. attention mechanisms, intermediate layer activations)
+
+Možné ciele semestrálneho projektu:
+
+- Vyvinúť metódu na vytváranie riadiacich vektorov pre konkrétne vlastnosti generovania.
+- Implementovať a vyhodnotiť vplyv steering vectors na kvalitu a štýl výstupov LLM.
+- Nájsť spôsob ako kombinovať viaceré steering vektory pre súčasné riadenie viacerých aspektov generovania.