From 7e4077abd1d16e3344575e8a86d47c6e9d7b7ff3 Mon Sep 17 00:00:00 2001 From: Krzysztof Rudnicki Date: Sun, 28 Dec 2025 17:42:23 +0100 Subject: [PATCH] feat: automatic and manual anki cards generator --- install_nvidia_nsight.sh | 91 ++ pytania/anki_approach_1.py | 91 ++ pytania/anki_approach_2.py | 115 ++ pytania/anki_egzamin_magisterski.txt | 330 +++++ pytania/anki_extract.txt | 1947 ++++++++++++++++++++++++++ pytania/anki_extract_main.txt | 40 + pytania/anki_filter.txt | 1217 ++++++++++++++++ pytania/anki_filter_extract.txt | 1883 +++++++++++++++++++++++++ pytania/anki_filter_extract_main.txt | 28 + pytania/anki_filter_main.txt | 28 + pytania/anki_generator.py | 331 +++++ pytania/anki_main.txt | 40 + pytania/anki_manual.txt | 118 ++ pytania/generate_anki.py | 185 +++ pytania/generate_anki_final.py | 288 ++++ pytania/generate_anki_v2.py | 183 +++ pytania/generate_anki_v3.py | 257 ++++ 17 files changed, 7172 insertions(+) create mode 100755 install_nvidia_nsight.sh create mode 100644 pytania/anki_approach_1.py create mode 100644 pytania/anki_approach_2.py create mode 100644 pytania/anki_egzamin_magisterski.txt create mode 100644 pytania/anki_extract.txt create mode 100644 pytania/anki_extract_main.txt create mode 100644 pytania/anki_filter.txt create mode 100644 pytania/anki_filter_extract.txt create mode 100644 pytania/anki_filter_extract_main.txt create mode 100644 pytania/anki_filter_main.txt create mode 100644 pytania/anki_generator.py create mode 100644 pytania/anki_main.txt create mode 100644 pytania/anki_manual.txt create mode 100644 pytania/generate_anki.py create mode 100644 pytania/generate_anki_final.py create mode 100644 pytania/generate_anki_v2.py create mode 100644 pytania/generate_anki_v3.py diff --git a/install_nvidia_nsight.sh b/install_nvidia_nsight.sh new file mode 100755 index 0000000..8bc4210 --- /dev/null +++ b/install_nvidia_nsight.sh @@ -0,0 +1,91 @@ +#!/bin/bash +# Install NVIDIA Nsight tools on Arch Linux +# This script installs Nsight Systems and Nsight Compute + +set -e + +echo "=== NVIDIA Nsight Installation Script for Arch Linux ===" +echo "" + +# Check if running on Arch Linux +if [ ! -f /etc/arch-release ]; then + echo "Error: This script is designed for Arch Linux." + exit 1 +fi + +# Update system first +echo "=== Updating system packages ===" +sudo pacman -Syu --noconfirm + +# Check NVIDIA drivers +echo "" +echo "=== Checking NVIDIA drivers ===" +if pacman -Qs nvidia-utils &> /dev/null; then + echo "NVIDIA utils already installed." +else + echo "Installing NVIDIA open drivers..." + sudo pacman -S --needed --noconfirm nvidia-open nvidia-utils nvidia-settings +fi + +# Install CUDA toolkit (optional but recommended) +echo "" +echo "=== Installing CUDA toolkit ===" +sudo pacman -S --needed --noconfirm cuda + +# Install Nsight tools from official repositories +echo "" +echo "=== Installing NVIDIA Nsight tools ===" + +echo "" +echo "Installing Nsight Systems (system-wide performance analysis)..." +sudo pacman -S --needed --noconfirm nsight-systems + +echo "" +echo "Installing Nsight Compute (CUDA kernel profiling)..." +sudo pacman -S --needed --noconfirm nsight-compute + +# Set up environment variables +echo "" +echo "=== Setting up environment variables ===" +CUDA_PATH="/opt/cuda" +if [ -d "$CUDA_PATH" ]; then + # Add to .bashrc if not already present + if ! grep -q "CUDA_HOME" ~/.bashrc 2>/dev/null; then + echo "" >> ~/.bashrc + echo "# NVIDIA CUDA and Nsight tools" >> ~/.bashrc + echo "export CUDA_HOME=$CUDA_PATH" >> ~/.bashrc + echo "export PATH=\$PATH:\$CUDA_HOME/bin" >> ~/.bashrc + echo "Environment variables added to ~/.bashrc" + else + echo "CUDA environment variables already configured in .bashrc" + fi + + # Add to .zshrc if zsh is used + if [ -f ~/.zshrc ]; then + if ! grep -q "CUDA_HOME" ~/.zshrc 2>/dev/null; then + echo "" >> ~/.zshrc + echo "# NVIDIA CUDA and Nsight tools" >> ~/.zshrc + echo "export CUDA_HOME=$CUDA_PATH" >> ~/.zshrc + echo "export PATH=\$PATH:\$CUDA_HOME/bin" >> ~/.zshrc + echo "Environment variables added to ~/.zshrc" + else + echo "CUDA environment variables already configured in .zshrc" + fi + fi +fi + +echo "" +echo "=== Installation Complete ===" +echo "" +echo "Installed tools:" +echo " - Nsight Systems: Performance analysis for CPU/GPU workloads" +echo " - Nsight Compute: Detailed CUDA kernel profiling" +echo "" +echo "To launch the tools, use:" +echo " nsys-ui (Nsight Systems GUI)" +echo " nsys (Nsight Systems CLI)" +echo " ncu-ui (Nsight Compute GUI)" +echo " ncu (Nsight Compute CLI)" +echo "" +echo "Note: You may need to restart your terminal or run 'source ~/.zshrc'" +echo " to use the CUDA tools from command line." diff --git a/pytania/anki_approach_1.py b/pytania/anki_approach_1.py new file mode 100644 index 0000000..8865c20 --- /dev/null +++ b/pytania/anki_approach_1.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python3 +""" +Approach 1: STRICT FILTERING ONLY +- Only include cards with answers > 100 characters +- No changes to extraction logic +""" + +import os +import re +from pathlib import Path + +def clean_text(text): + if not text: + return "" + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'(?\1', text) + text = text.replace('\t', ' ') + text = text.replace('"', '"') + text = re.sub(r' +', ' ', text) + return text.strip() + +def extract_cards(filepath): + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + num = match.group(1) if match else "00" + + subj_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subj_match.group(1) if subj_match else "Ogólne" + base_tags = f"egzamin pyt{num} {subject}" + + # Main question + q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if q_match: + main_q = re.sub(r'\s+', ' ', q_match.group(1).strip()) + + # Simple extraction - headers as answer + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)', content, re.DOTALL) + if answer_match: + headers = re.findall(r'^### (?:\d+\.\s*)?(.+)$', answer_match.group(1), re.MULTILINE) + if headers: + answer = '' + cards.append({'front': clean_text(main_q), 'back': answer, 'tags': base_tags}) + + # Detail cards - simple extraction + sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', content, re.MULTILINE | re.DOTALL) + for header, body in sections: + header = header.strip() + body = body.strip() + if len(body) < 50: + continue + + # Get first paragraph + paras = [p.strip() for p in body.split('\n\n') if p.strip() and not p.startswith('```')] + if paras: + answer = clean_text(paras[0][:400]) + cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': base_tags}) + + return cards + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_1_strict_filter.txt") + + all_cards = [] + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + all_cards.extend(extract_cards(md_file)) + + # APPROACH 1: Strict filtering - only cards with answer > 100 chars + filtered_cards = [c for c in all_cards if len(c['back']) > 100] + + # Remove duplicates + seen = set() + unique = [] + for c in filtered_cards: + if c['front'][:80] not in seen: + seen.add(c['front'][:80]) + unique.append(c) + + with open(output_file, 'w', encoding='utf-8') as f: + f.write("#separator:Tab\n#html:true\n#notetype:Basic\n#deck:Egzamin_1_StrictFilter\n\n") + for c in unique: + f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n") + + print(f"✅ Approach 1 (Strict Filter): {len(unique)} cards -> {output_file.name}") + +if __name__ == "__main__": + main() diff --git a/pytania/anki_approach_2.py b/pytania/anki_approach_2.py new file mode 100644 index 0000000..850ce2c --- /dev/null +++ b/pytania/anki_approach_2.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +""" +Approach 2: BETTER EXTRACTION ONLY +- Improved algorithm to get more complete content +- No minimum length filtering +""" + +import os +import re +from pathlib import Path + +def clean_text(text): + if not text: + return "" + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'(?\1', text) + text = text.replace('\t', ' ') + text = text.replace('"', '"') + text = re.sub(r' +', ' ', text) + return text.strip() + +def extract_structured_content(body): + """Better extraction - look for multiple content types.""" + parts = [] + + # 1. Look for definitions + def_match = re.search(r'#### Definicja[^\n]*\n([^\n#]+)', body) + if def_match: + parts.append(f"Definicja: {def_match.group(1).strip()}") + + # 2. Look for bullet points with bold terms + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)', body) + for term, desc in bullets[:5]: + if desc.strip(): + parts.append(f"• {term}: {desc.strip()}") + else: + parts.append(f"• {term}") + + # 3. Look for key-value patterns + if not parts: + kvs = re.findall(r'\*\*([^*]+)\*\*\s*[-:]\s*([^\n*]+)', body) + for k, v in kvs[:4]: + parts.append(f"{k}: {v.strip()}") + + # 4. Get paragraphs as fallback + if not parts: + paras = [p.strip() for p in body.split('\n\n') + if p.strip() and not p.startswith('```') and not p.startswith('|') and len(p.strip()) > 30] + for p in paras[:2]: + parts.append(p[:300]) + + return '
'.join([clean_text(p) for p in parts]) if parts else None + +def extract_cards(filepath): + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + num = match.group(1) if match else "00" + + subj_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subj_match.group(1) if subj_match else "Ogólne" + base_tags = f"egzamin pyt{num} {subject}" + + # Main question with better extraction + q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if q_match: + main_q = re.sub(r'\s+', ' ', q_match.group(1).strip()) + + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)', content, re.DOTALL) + if answer_match: + answer = extract_structured_content(answer_match.group(1)) + if answer: + cards.append({'front': clean_text(main_q), 'back': answer, 'tags': base_tags}) + + # Detail cards with better extraction + sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', content, re.MULTILINE | re.DOTALL) + for header, body in sections: + header = header.strip() + if 'Przykład' in header or '"' in header or len(body) < 50: + continue + + answer = extract_structured_content(body) + if answer: + cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': base_tags}) + + return cards + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_2_better_extract.txt") + + all_cards = [] + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + all_cards.extend(extract_cards(md_file)) + + # No filtering - just dedupe + seen = set() + unique = [] + for c in all_cards: + if c['front'][:80] not in seen: + seen.add(c['front'][:80]) + unique.append(c) + + with open(output_file, 'w', encoding='utf-8') as f: + f.write("#separator:Tab\n#html:true\n#notetype:Basic\n#deck:Egzamin_2_BetterExtract\n\n") + for c in unique: + f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n") + + print(f"✅ Approach 2 (Better Extraction): {len(unique)} cards -> {output_file.name}") + +if __name__ == "__main__": + main() diff --git a/pytania/anki_egzamin_magisterski.txt b/pytania/anki_egzamin_magisterski.txt new file mode 100644 index 0000000..04bb397 --- /dev/null +++ b/pytania/anki_egzamin_magisterski.txt @@ -0,0 +1,330 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin Magisterski ISY +#columns:Front Back Tags +#tags column:3 + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (FA): Języki regularne (Typ 3)

Automat ze Stosem (PDA): Języki bezkontekstowe (Typ 2)

Maszyna Turinga (TM): Języki rekurencyjnie przeliczalne (Typ 0) egzamin_magisterski pyt01 AISDI pytanie_glowne +Wyjaśnij: Hierarchia Chomsky'ego - fundament teoretyczny Noam Chomsky w 1956 roku zaproponował hierarchię czterech klas języków formalnych, gdzie każda kolejna klasa zawiera poprzednią: egzamin_magisterski pyt01 AISDI szczegoly +Wyjaśnij: Automat Skończony (Finite Automaton - FA) Automat skończony to piątka: M = (Q, Σ, δ, q₀, F) +- Q - skończony zbiór stanów
• Pamięć: Brak pamięci pomocniczej - tylko aktualny stan
• Moc obliczeniowa: Nie potrafi "liczyć" (porównywać ilości)
• Równoważne formalizmy egzamin_magisterski pyt01 AISDI szczegoly +Wyjaśnij: Automat ze Stosem (Pushdown Automaton - PDA) Automat ze stosem to siódemka: M = (Q, Σ, Γ, δ, q₀, Z₀, F) +- Q - skończony zbiór stanów
• Pamięć: Stos (LIFO) - pamięć potencjalnie nieskończona, ale z ograniczonym dostępem
• Moc obliczeniowa: Potrafi "liczyć" (porównywać pary ilości)
• DPDA ⊂ NPDA: Deterministyczne PDA są SŁABSZE niż niedeterministyczne!
• Równoważne formalizmy: Gramatyki bezkontekstowe (CFG) egzamin_magisterski pyt01 AISDI szczegoly +Wyjaśnij: Maszyna Turinga (Turing Machine - TM) Maszyna Turinga to siódemka: M = (Q, Σ, Γ, δ, q₀, qaccept, qreject) +- Q - skończony zbiór stanów
• Pamięć: Taśma nieskończona z dostępem swobodnym (R/W)
• Moc obliczeniowa: Maksymalna możliwa (teza Churcha-Turinga)
• DTM ≡ NTM: Deterministyczne i niedeterministyczne TM są RÓWNOWAŻNE pod względem mocy (ale różnią się złożonością czasową) egzamin_magisterski pyt01 AISDI szczegoly +Omówić i porównać algorytmy najkrótszej ścieżki wskazując ich kluczowe właściwości i logikę budowy: Dijkstry, Belmana-Forda, A*. Problem: Dany jest graf G = (V, E) z funkcją wag w: E → ℝ. Znajdź ścieżkę z wierzchołka źródłowego s do wierzchołka docelowego t o minimalnej sumie wag krawędzi. egzamin_magisterski pyt02 AISDI pytanie_glowne +Wyjaśnij: Wprowadzenie - problem najkrótszej ścieżki Problem: Dany jest graf G = (V, E) z funkcją wag w: E → ℝ. Znajdź ścieżkę z wierzchołka źródłowego s do wierzchołka docelowego t o minimalnej sumie wag krawędzi. egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Charakterystyka • Autor:: Edsger Dijkstra (1956, opublikowany 1959)
• Typ:: Zachłanny (greedy)
• Problem:: SSSP - najkrótsze ścieżki z jednego źródła do wszystkich wierzchołków
• Ograniczenie:: ⚠️ Tylko nieujemne wagi krawędzi (w(e) ≥ 0) egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Idea algorytmu (logika budowy) 1. Relaksacja: Stopniowe ulepszanie oszacowań odległości egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Pseudokod Q ← priority_queue(V) // min-heap według d[v] egzamin_magisterski pyt02 AISDI szczegoly +Dlaczego nie działa dla ujemnych wag? Dijkstra przetwarza wierzchołki w kolejności rosnącej odległości i oznacza je jako "zakończone". Jeśli waga może być ujemna, późniejszy wierzchołek może "poprawić" już zakończony. egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Złożoność czasowa O(V · E) - zawsze, niezależnie od implementacji egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Wykrywanie cyklu ujemnego Po |V|-1 iteracjach, wszystkie najkrótsze ścieżki (bez cykli) są znalezione. egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Optymalizacja: wczesne zakończenie if d[u] + w(u,v) < d[v]: egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Heurystyka - kluczowy element 1. Dopuszczalność (Admissibility): egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Przypadki specjalne: • h(n) = 0:: A* = Dijkstra egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Dijkstra • Nawigacja GPS: (drogi nie mają ujemnych odległości)
• Routing w sieciach: (OSPF protocol)
• Mapy Google/Apple: (dla małych obszarów) egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: Bellman-Ford • Routing w sieciach: (RIP protocol - prostszy)
• Arbitraż walutowy: (szukanie cykli ujemnych = zysk!)
• Systemy z "karami": (ujemne wagi = bonusy) egzamin_magisterski pyt02 AISDI szczegoly +Wyjaśnij: A* • Gry komputerowe: - pathfinding NPC, RTS
• Robotyka: - planowanie ruchu
• Puzzle: - 8-puzzle, 15-puzzle
• Nawigacja: - gdy znamy pozycję celu
• Dijkstra:: Relaksuje krawędzie wychodzące z wierzchołka o minimalnym d[v] egzamin_magisterski pyt02 AISDI szczegoly +Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. Redundancja (nadmiarowość) i normalizacja to dwa fundamentalne, przeciwstawne pojęcia w projektowaniu relacyjnych baz danych: egzamin_magisterski pyt03 BD2 pytanie_glowne +Wyjaśnij: Wprowadzenie • Redundancja: = niepożądane powtarzanie danych
• Normalizacja: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Definicja Redundancja występuje, gdy ta sama informacja jest przechowywana w wielu miejscach bazy danych, co prowadzi do: egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Trzy typy anomalii Problem: Nie można dodać danych bez dodania innych, niepotrzebnych danych. egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Podstawowe pojęcia X → Y oznacza: wartość X jednoznacznie określa wartość Y egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Hierarchia postaci normalnych 5NF ⊂ 4NF ⊂ BCNF ⊂ 3NF ⊂ 2NF ⊂ 1NF egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: 1NF - Pierwsza Postać Normalna 1. Atomowość wartości - każda komórka zawiera jedną, niepodzielną wartość egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: 2NF - Druga Postać Normalna 2. Każdy atrybut wtórny jest w pełni funkcyjnie zależny od całego klucza głównego (nie od jego części) egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: 3NF - Trzecia Postać Normalna 2. Brak przechodnich zależności funkcyjnych - atrybuty wtórne nie zależą od innych atrybutów wtórnych egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: BCNF - Postać Normalna Boyce'a-Codda 2. Dla każdej nietrywialnej FD X → Y, X jest nadkluczem egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: 4NF - Czwarta Postać Normalna 2. Brak nietrywialnych zależności wielowartościowych (MVD - Multivalued Dependencies) egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: 5NF - Piąta Postać Normalna (PJNF) 2. Brak zależności połączeniowych (Join Dependencies) egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Algorytm dekompozycji do 3NF 1. Znajdź pokrycie kanoniczne zbioru zależności funkcyjnych egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Własności dobrej dekompozycji Po dekompozycji można odtworzyć oryginalną relację przez złączenie naturalne. egzamin_magisterski pyt03 BD2 szczegoly +Kiedy stosować? • Optymalizacja wydajności: - złączenia są kosztowne
• Systemy OLAP/hurtownie danych: - dane głównie odczytywane
• Raportowanie: - predefiniowane zapytania egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Techniki denormalizacji: 1. Dodanie redundantnych kolumn - unikanie złączeń egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Kompromis: NORMALIZACJA ←————————————→ DENORMALIZACJA egzamin_magisterski pyt03 BD2 szczegoly +Wyjaśnij: Wzór na 3NF: > "Każdy atrybut zależy od klucza, całego klucza i tylko od klucza." egzamin_magisterski pyt03 BD2 szczegoly +Dlaczego baza danych stanowi dobry fundament do budowy wielu systemów informatycznych? Baza danych to centralny komponent większości systemów informatycznych, ponieważ zapewnia: egzamin_magisterski pyt04 BD2 pytanie_glowne +Wyjaśnij: Trójpoziomowa architektura ANSI/SPARC ┌─────────────────────────────────────────┐ egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Rodzaje niezależności Zmiana sposobu przechowywania (indeksy, partycjonowanie, kompresja) nie wpływa na aplikacje. egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Mechanizmy wymuszania integralności id INT PRIMARY KEY, -- Klucz główny egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Optymalizator zapytań 1. Analizuje zapytanie (parsing) egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Wielopoziomowe zabezpieczenia ┌─────────────────────────────────────────┐ egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Kontrola dostępu GRANT SELECT ON Sprzedaz TO analityk; egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Skalowanie poziome (Scale-out) • Replikacja: - kopie do odczytu
• Sharding: - podział danych między serwery
• Klastry: - wysoka dostępność egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: SQL jako lingua franca • Standardowy język: - SQL:2016, SQL:2023
• Przenośność: - kod działa na różnych SZBD
• Narzędzia: - uniwersalne IDE, ORM, ETL egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Bogaty ekosystem • ORM: (Hibernate, Entity Framework, SQLAlchemy)
• Narzędzia migracji: (Flyway, Liquibase)
• Monitorowanie: (Grafana, Datadog)
• Backup: (pg_dump, mysqldump, RMAN) egzamin_magisterski pyt04 BD2 szczegoly +Wyjaśnij: Polyglot Persistence Nowoczesne systemy często używają wielu baz - każda do swojego celu. egzamin_magisterski pyt04 BD2 szczegoly +Omówić główne kategorie elementów biblioteki STL. Jaka jest ich rola i wzajemne powiązania? Odpowiedź uzasadnić na przykładach. STL (Standard Template Library) to część standardowej biblioteki C++ zawierająca generyczne struktury danych i algorytmy. Została zaprojektowana przez Alexandra Stepanova i weszła do standardu C++98. egzamin_magisterski pyt05 PROI pytanie_glowne +Wyjaśnij: Filozofia STL • Generyczność: - szablony (templates) umożliwiają pracę z dowolnymi typami
• Wydajność: - zero-overhead abstraction
• Modularność: - komponenty są niezależne i wymienne
• Ortogonalność: - kontenery i algorytmy są rozdzielone (przez iteratory) egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Kategorie kontenerów Przechowują elementy w określonej kolejności. egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Hierarchia iteratorów Input Iterator Output Iterator egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Kategorie iteratorów std::vector vec = {1, 2, 3, 4, 5}; egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Iteratory specjalne std::vector vec = {1, 2, 3}; egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Kategorie algorytmów std::vector vec = {1, 2, 3, 4, 5, 3}; egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Rodzaje funktorów std::vector vec = {3, 1, 4, 1, 5}; egzamin_magisterski pyt05 PROI szczegoly +Wyjaśnij: Kluczowa zasada: Ortogonalność M kontenerów × N algorytmów = M + N implementacji (nie M × N!) egzamin_magisterski pyt05 PROI szczegoly +Omówić metody reużywalności kodu i struktur danych w obiektowych językach programowania. Reużywalność kodu (code reuse) to fundamentalna zasada inżynierii oprogramowania - "nie wynajduj koła na nowo". W programowaniu obiektowym mamy kilka mechanizmów umożliwiających wielokrotne wykorzystanie kodu. egzamin_magisterski pyt06 PROI pytanie_glowne +Wyjaśnij: Główne metody reużywalności ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Problem diamentu (Diamond Problem) class A { public: void metoda() {} }; egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Typy relacji obiektowych // Kompozycja - silnik "umiera" z samochodem egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Szablony w C++ // Użycie - kompilator generuje wersje dla każdego typu egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Generyki w Java/C# public void set(T value) { this.value = value; } egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Wzorzec strategii (Strategy Pattern) virtual void sort(std::vector& data) = 0; egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Mixiny (Mixins) Klasy dostarczające funkcjonalność do "wmieszania" do innych klas. egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Traity (Traits) fn move_to(&mut self, x: i32, y: i32); egzamin_magisterski pyt06 PROI szczegoly +Wyjaśnij: Poziomy reużywalności ┌─────────────────────────────────────────────────────┐ egzamin_magisterski pyt06 PROI szczegoly +Które serwery DNS najwięcej zyskują dzięki buforowaniu zapytań (caching) w serwerach rekursywnych? Jakie znasz rodzaje serwerów DNS? Przechowują oryginalne rekordy DNS dla danej domeny. Są "źródłem prawdy".

Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne.

Prosty klient DNS w systemie operacyjnym. Wysyła zapytanie do rekursywnego resolvera i czeka na odpowiedź. egzamin_magisterski pyt07 SKM pytanie_glowne +Wyjaśnij: Wprowadzenie do DNS DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: Hierarchia DNS . (root) egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: 1 Serwery autorytatywne (Authoritative) • 13 logicznych serwerów:: a.root-servers.net do m.root-servers.net
• Fizycznie:: Setki serwerów (anycast)
• Funkcja:: Wskazują serwery TLD
• gTLD:: .com, .org, .net (generic)
• ccTLD:: .pl, .de, .uk (country code) egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: 2 Serwery rekursywne (Recursive Resolvers) Definicja: Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne. egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: 3 Stub Resolvers (Resolwery klienckie) Definicja: Prosty klient DNS w systemie operacyjnym. Wysyła zapytanie do rekursywnego resolvera i czeka na odpowiedź. egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: 4 Forwarding Servers (Przekazujące) Definicja: Przyjmują zapytania i przekazują je do innego resolvera zamiast samodzielnie rozwiązywać. egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: Zapytanie rekursywne vs iteracyjne ZAPYTANIE REKURSYWNE (klient → resolver): egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: Pełny proces rozwiązywania Klient Recursive Root .com TLD example.com egzamin_magisterski pyt07 SKM szczegoly +Jak działa caching? 1. Resolver otrzymuje odpowiedź z serwera autorytatywnego egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: TTL (Time To Live) www.example.com. 300 IN A 93.184.216.34 egzamin_magisterski pyt07 SKM szczegoly +Dlaczego root servers zyskują najwięcej? ┌────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt07 SKM szczegoly +Dlaczego ROOT i TLD zyskują więcej niż authoritative? 1. Mniejsza liczba = więcej zapytań na serwer: egzamin_magisterski pyt07 SKM szczegoly +Wyjaśnij: Podsumowanie zysków z cachingu REDUKCJA RUCHU DZIĘKI CACHINGOWI: egzamin_magisterski pyt07 SKM szczegoly +Jaki jest cel uzgadniania trójetapowego (three way handshake) w protokole TCP? Jaka jest interpretacja numerów sekwencyjnych i potwierdzenia? Jaka jest wartość początkowa numeru sekwencyjnego? TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: egzamin_magisterski pyt08 SKM pytanie_glowne +Wyjaśnij: Wprowadzenie do TCP TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Cele uzgadniania trójetapowego 1. Nawiązanie połączenia - obie strony zgadzają się na komunikację egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Przebieg (diagram) Klient Serwer egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Szczegółowy opis kroków ┌────────────────────────────────────────┐ egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Interpretacja Sequence Number (SEQ) = numer pierwszego bajtu danych w segmencie egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Kumulatywne potwierdzenia TCP używa cumulative ACK - potwierdza wszystkie bajty do danego numeru: egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Selective ACK (SACK) Opcja TCP pozwalająca potwierdzać niesąsiednie bloki: egzamin_magisterski pyt08 SKM szczegoly +Dlaczego ISN nie zaczyna od 0? 1. Bezpieczeństwo - przewidywalny ISN umożliwia ataki (TCP hijacking) egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Generowanie ISN • M: = timer (jak wyżej)
• F: = funkcja kryptograficzna (MD5/SHA)
• secretkey: = tajny klucz serwera egzamin_magisterski pyt08 SKM szczegoly +Wyjaśnij: Zakres numerów sekwencyjnych SEQ: 32 bity → zakres 0 do 4,294,967,295 (2^32 - 1) egzamin_magisterski pyt08 SKM szczegoly +Procesy i wątki w systemie operacyjnym. Omówić budowę, szybkość działania i zakres zastosowania. Przedstawić problemy i możliwości komunikacji i synchronizacji. Proces i wątek to podstawowe jednostki wykonania w systemach operacyjnych. Różnią się poziomem izolacji i kosztami przełączania. egzamin_magisterski pyt09 SOI pytanie_glowne +Wyjaśnij: Budowa procesu ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: PCB (Process Control Block) Struktura w jądrze przechowująca informacje o procesie: egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Stany procesu ┌──────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Budowa wątku ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Wątki użytkownika (User-level Threads) ┌─────────────────────────────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Wątki jądra (Kernel-level Threads) ┌─────────────────────────────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Mechanizmy IPC ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Szczegóły mechanizmów // Potok nienazwany (anonimowy) egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Problemy współbieżności Wątek A: lock(mutex1) → czeka na mutex2 egzamin_magisterski pyt09 SOI szczegoly +Wyjaśnij: Mechanizmy synchronizacji • Binarny: (0/1) - jak mutex
• Licznikowy: - ogranicza liczbę wątków (np. pula połączeń) egzamin_magisterski pyt09 SOI szczegoly +Kiedy procesy? • Izolacja: - awaria jednego nie wpływa na inne
• Bezpieczeństwo: - różne uprawnienia
• Różne języki/technologie: - mikrousługi
• Niezawodność: - restart bez wpływu na system egzamin_magisterski pyt09 SOI szczegoly +Kiedy wątki? • Współdzielenie danych: - bez kopiowania
• Responsywność: - UI thread + worker threads
• Równoległość CPU: - obliczenia na wielu rdzeniach
• I/O asynchroniczne: - czekanie nie blokuje wszystkiego egzamin_magisterski pyt09 SOI szczegoly +Scharakteryzować problemy i mechanizmy zarządzania pamięcią. Porównać cechy i przeznaczenie mechanizmów stronicowania i segmentacji. Zarządzanie pamięcią to jeden z kluczowych zadań systemu operacyjnego: egzamin_magisterski pyt10 SOI pytanie_glowne +Wyjaśnij: 1 Fragmentacja ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: 3 Relokacja Problem: Program kompilowany z założeniem konkretnych adresów musi działać pod różnymi adresami. egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: 1 Partycjonowanie stałe (Fixed Partitioning) ┌────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: 2 Partycjonowanie dynamiczne (Dynamic Partitioning) ┌────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Idea • Strona (Page): - blok pamięci wirtualnej (4KB typowo)
• Ramka (Frame): - blok pamięci fizycznej (ten sam rozmiar) egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Translacja adresu Adres wirtualny (32-bit, strony 4KB): egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Wielopoziomowe tablice stron Problem: Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = 4MB per proces! egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: TLB (Translation Lookaside Buffer) Problem: Każdy dostęp do pamięci wymaga 2+ odczytów (tablica + dane). egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Ochrona w segmentacji • R: (Read) - odczyt dozwolony
• W: (Write) - zapis dozwolony
• X: (Execute) - wykonanie dozwolone egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Intel x86 (tryb chroniony) Adres logiczny (Selector:Offset) egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Zalety hybrydowego podejścia 1. Ochrona z segmentacji (kod vs dane vs stos) egzamin_magisterski pyt10 SOI szczegoly +Wyjaśnij: Algorytm Clock (Second Chance) ┌──→│ 1 │──┐ Bit referencji: egzamin_magisterski pyt10 SOI szczegoly +Scharakteryzować standardy i narzędzia do modelowania procesów biznesowych. | CO robimy (flow) | JAK robimy (instrukcja) | egzamin_magisterski pyt11 WSYZ pytanie_glowne +Wyjaśnij: Przegląd standardów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Podstawowe elementy BPMN ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Elementy Activity Diagrams ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Elementy EPC ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Reguły EPC 1. Start i koniec: Zdarzenie egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: IDEF0 - Modelowanie funkcji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Flowcharts (Schematy blokowe) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Value Stream Map (VSM) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Wyjaśnij: Petri Nets (Sieci Petriego) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt11 WSYZ szczegoly +Przedstawić sieciowe modele optymalizacji stosowane w systemach zarządzania. Omówić ich właściwości. Sieciowe modele optymalizacji to matematyczne reprezentacje problemów decyzyjnych w postaci grafów (sieci), gdzie: egzamin_magisterski pyt12 WSYZ pytanie_glowne +Wyjaśnij: Właściwości • NP-trudny: - brak algorytmu wielomianowego egzamin_magisterski pyt12 WSYZ szczegoly +Wyjaśnij: CPM (Critical Path Method) A(2)──┤ ├──E(2)──F(1) egzamin_magisterski pyt12 WSYZ szczegoly +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe. egzamin_magisterski pyt13 AASD pytanie_glowne +Wyjaśnij: Definicje fundamentalne Agent = system komputerowy umieszczony w środowisku, zdolny do autonomicznego działania w celu realizacji celów. egzamin_magisterski pyt13 AASD szczegoly +Wyjaśnij: Architektury agentów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt13 AASD szczegoly +Wyjaśnij: Standardy komunikacji agentów FIPA-ACL (Agent Communication Language): egzamin_magisterski pyt13 AASD szczegoly +Wyjaśnij: Protokoły interakcji ┌─────────┐ cfp ┌─────────┐ egzamin_magisterski pyt13 AASD szczegoly +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. Zastosowania: Przydział zadań, zarządzanie zasobami, e-commerce

Problem: Środowisko niestacjonarne (inni agenci się zmieniają)

Ordering constraints: flexible (równoległość gdy możliwa) egzamin_magisterski pyt14 AASD pytanie_glowne +Wyjaśnij: Algorytmy negocjacji i aukcji 1. ANNOUNCEMENT - Manager ogłasza zadanie (cfp) egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy konsensusu Stany węzłów: FOLLOWER → CANDIDATE → LEADER egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy koordynacji 1. Wyślij REQUEST(timestamp) do wszystkich egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy uczenia wieloagentowego Każdy agent uczy się niezależnie: egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy dla aktorów // One-for-One: restart tylko tego aktora egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy planowania (BDI) plan1: walk(X,Y) :- distance(X,Y) < 1km egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Algorytmy formowania koalicji Sprawiedliwy podział zysków w koalicji: egzamin_magisterski pyt14 AASD szczegoly +Wyjaśnij: Frameworki architektoniczne ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt15 AIS szczegoly +Wyjaśnij: Notacje i języki modelowania ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt15 AIS szczegoly +Wyjaśnij: ADR (Architecture Decision Records) System wymaga przechowywania danych użytkowników... egzamin_magisterski pyt15 AIS szczegoly +Wyjaśnij: Metody analizy architektury 2. Identify quality attribute scenarios egzamin_magisterski pyt15 AIS szczegoly +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne. Zasada: Warstwa zna tylko warstwę bezpośrednio niższą egzamin_magisterski pyt16 AIS pytanie_glowne +Wyjaśnij: Jak powstają wzorce • Nazwa: - identyfikator
• Kontekst: - kiedy stosować
• Problem: - co rozwiązuje
• Rozwiązanie: - struktura i zachowanie
• Konsekwencje: - trade-offs egzamin_magisterski pyt16 AIS szczegoly +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. Sprawdzenie: Wszystkie wartości własne $\lambda_i > 0 \Rightarrow H \succ 0$

Jeśli $x^*$ jest minimum i spełnione są warunki regularności:

LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne egzamin_magisterski pyt17 AMO pytanie_glowne +Wyjaśnij: Optymalizacja bez ograniczeń $$\min_{x \in \mathbb{R}^n} f(x)$$ egzamin_magisterski pyt17 AMO szczegoly +Wyjaśnij: Optymalizacja z ograniczeniami $$\text{s.t. } g_i(x) \leq 0, \quad i = 1, \ldots, m$$ egzamin_magisterski pyt17 AMO szczegoly +Wyjaśnij: Warunki KKT (Karush-Kuhn-Tucker) Jeśli $x^*$ jest minimum i spełnione są warunki regularności: egzamin_magisterski pyt17 AMO szczegoly +Wyjaśnij: Warunki regularności (Constraint Qualification) Warunki zapewniające, że KKT są konieczne: egzamin_magisterski pyt17 AMO szczegoly +Wyjaśnij: Warunki dostateczne II rzędu Jeśli spełnione KKT i dla hesjanu Lagrangianu: egzamin_magisterski pyt17 AMO szczegoly +Wyjaśnij: Metody optymalizacji nieliniowej x_{k+1} = x_k - [∇²f(x_k)]^{-1} ∇f(x_k) egzamin_magisterski pyt17 AMO szczegoly +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. Złożoność: O(2^n) worst-case, ale praktycznie bardzo szybki

Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin_magisterski pyt18 AMO pytanie_glowne +Wyjaśnij: Programowanie liniowe (LP) $$\text{s.t. } Ax = b, \quad x \geq 0$$ egzamin_magisterski pyt18 AMO szczegoly +Wyjaśnij: Programowanie kwadratowe (QP) $$\min \frac{1}{2} x^T Q x + c^T x$$ egzamin_magisterski pyt18 AMO szczegoly +Wyjaśnij: Metody rozwiązywania QP Idea: Traktuj aktywne ograniczenia jako równości egzamin_magisterski pyt18 AMO szczegoly +Wyjaśnij: Przypadki szczególne $$\min \|Ax - b\|_2^2 = \min x^T A^T A x - 2b^T A x + b^T b$$ egzamin_magisterski pyt18 AMO szczegoly +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). - Redukcja wymiarowości: 16kHz × 16bit → ~13-40 cech/ramkę

Typowo: p = 10-16 dla mowy (8kHz), p = 16-20 (16kHz) egzamin_magisterski pyt19 EASAR pytanie_glowne +Wyjaśnij: Cel parametryzacji mowy • Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę
• Ekstrakcja informacji fonetycznej: - Usunięcie informacji mówcy (częściowo)
• Reprezentacja kompaktowa: dla modeli (HMM, DNN) egzamin_magisterski pyt19 EASAR szczegoly +Wyjaśnij: MFCC (Mel-Frequency Cepstral Coefficients) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt19 EASAR szczegoly +Wyjaśnij: LPC (Linear Predictive Coding) • Dźwięczne:: pobudzenie okresowe (struny głosowe)
• Bezdźwięczne:: pobudzenie szumowe egzamin_magisterski pyt19 EASAR szczegoly +Wyjaśnij: Rozszerzenia Łączy LPC z percepcją słuchową: egzamin_magisterski pyt19 EASAR szczegoly +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:

Backtrace: ψ_t(j) = argmax_{i} [α_{t-1}(i) · a_{ij}] egzamin_magisterski pyt20 EASAR pytanie_glowne +Wyjaśnij: System rozpoznawania mowy - architektura ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt20 EASAR szczegoly +Wyjaśnij: HMM (Hidden Markov Model) - klasyczne podejście a₁₂ a₂₃ a₃₄ egzamin_magisterski pyt20 EASAR szczegoly +Wyjaśnij: Deep Learning w rozpoznawaniu mowy ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt20 EASAR szczegoly +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? Agent upostaciowiony = agent posiadający fizyczne ciało, osadzony w rzeczywistym środowisku, zdolny do: egzamin_magisterski pyt21 ERPM pytanie_glowne +Wyjaśnij: Agent upostaciowiony (Embodied Agent) • Percepcji: poprzez sensory
• Działania: poprzez efektory
• Interakcji: ze środowiskiem egzamin_magisterski pyt21 ERPM szczegoly +Wyjaśnij: Specyfikacja sterownika robota ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt21 ERPM szczegoly +Wyjaśnij: Formalny model agenta Agent: Percept* → Action (historia percepcji) egzamin_magisterski pyt21 ERPM szczegoly +Wyjaśnij: Zastosowanie w ROS (Robot Operating System) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt21 ERPM szczegoly +Wyjaśnij: Hybrydowa architektura 3T ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt21 ERPM szczegoly +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. | Cecha | RAPID (ABB) | KRL (KUKA) | Karel (FANUC) |

move_group = moveit_commander.MoveGroupCommander("arm") egzamin_magisterski pyt22 ERPM pytanie_glowne +Wyjaśnij: Klasyfikacja języków programowania robotów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt22 ERPM szczegoly +Wyjaśnij: Języki producentów robotów przemysłowych MoveJ pHome, v1000, z50, tool1; egzamin_magisterski pyt22 ERPM szczegoly +Wyjaśnij: Języki uniwersalne i frameworki from geometry_msgs.msg import Twist egzamin_magisterski pyt22 ERPM szczegoly +Wyjaśnij: Klasyfikacja wg poziomu abstrakcji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt22 ERPM szczegoly +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

Zdarzenie a happened-before b (a → b) jeśli:

Jeśli ¬(a → b) ∧ ¬(b → a), to a || b (współbieżne). egzamin_magisterski pyt23 ERSMS pytanie_glowne +Wyjaśnij: Problem czasu w systemach rozproszonych ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt23 ERSMS szczegoly +Wyjaśnij: Zegar Lamporta (Scalar Clock) Każdy proces P_i ma licznik C_i: egzamin_magisterski pyt23 ERSMS szczegoly +Wyjaśnij: Zegary wektorowe (Vector Clocks) Każdy z N procesów ma wektor V[1..N]: egzamin_magisterski pyt23 ERSMS szczegoly +Wyjaśnij: Zastosowania Put(key, value) z vector clock: egzamin_magisterski pyt23 ERSMS szczegoly +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. Implementacja: Consensus (Paxos, Raft), single leader

Niezależne zapisy mogą być widziane w różnej kolejności. egzamin_magisterski pyt24 ERSMS pytanie_glowne +Wyjaśnij: Problem spójności w systemach rozproszonych ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: Spektrum modeli spójności Silne ←─────────────────────────────────────────→ Słabe egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: Silne modele spójności Definicja: Każda operacja wygląda jakby wykonała się atomowo egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: Słabe modele spójności Definicja: Jeśli nie ma nowych zapisów, ostatecznie egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: CAP Theorem ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: Strategie rozwiązywania konfliktów Konflikt: write(x=1) || write(x=2) egzamin_magisterski pyt24 ERSMS szczegoly +Wyjaśnij: Definicja MIP (Mixed Integer Programming) Programowanie całkowitoliczbowe: egzamin_magisterski pyt25 MOD szczegoly +Wyjaśnij: Branch and Bound (B&B) - metoda dokładna 1. Relaksacja LP: rozwiąż bez ograniczeń całkowitoliczbowych egzamin_magisterski pyt25 MOD szczegoly +Wyjaśnij: Ulepszenia: Branch and Cut Branch and Bound + Cutting Planes: egzamin_magisterski pyt25 MOD szczegoly +Wyjaśnij: Kategorie narzędzi ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Porównanie wydajności (benchmark) Typowe czasy dla problemów MIPLIB (średnie): egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Języki modelowania var produce{PRODUCTS} >= 0 integer; egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Typowe wymagania sprzętowe Mały problem (< 1000 zmiennych): egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Diagnostyka problemów 1. solver.computeIIS() # znajdź konflikt egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Best practices ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt26 MOD szczegoly +Wyjaśnij: Model danych jako fundament systemu ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt27 MODA szczegoly +Wyjaśnij: Wpływ na różne aspekty projektu JOIN customers ON orders.customer_name = customers.name -- string comparison! egzamin_magisterski pyt27 MODA szczegoly +Wyjaśnij: Koszty naprawy złego modelu Koszt zmiany modelu danych w czasie: egzamin_magisterski pyt27 MODA szczegoly +Wyjaśnij: Wpływ na jakość danych (GIGO) │ Złe dane wejść. │ → Zły model → Złe decyzje biznesowe egzamin_magisterski pyt27 MODA szczegoly +Wyjaśnij: Model danych a architektura aplikacji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt27 MODA szczegoly +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. Brak typów danych, kluczy, atrybutów szczegółowych!

Encje: Klient, Zamówienie, Produkt, Kategoria, Dostawca, Płatność

┌────────────────────────┐ ┌────────────────────────┐ egzamin_magisterski pyt28 MODA pytanie_glowne +Wyjaśnij: Przegląd faz ewolucji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt28 MODA szczegoly +Wyjaśnij: Model konceptualny (Conceptual Data Model) Diagram ERD (Entity-Relationship) - uproszczony: egzamin_magisterski pyt28 MODA szczegoly +Wyjaśnij: Model logiczny (Logical Data Model) ERD szczegółowy (np. Crow's Foot): egzamin_magisterski pyt28 MODA szczegoly +Wyjaśnij: Model fizyczny (Physical Data Model) klient_id SERIAL PRIMARY KEY, egzamin_magisterski pyt28 MODA szczegoly +Wyjaśnij: Transformacje między fazami ┌──────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt28 MODA szczegoly +Wyjaśnij: Ewolucja w czasie (produkcja) ✓ Backward compatible (add, nie remove) egzamin_magisterski pyt28 MODA szczegoly +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? $$S_{max} = \lim_{n \to \infty} S(n) = \frac{1}{1-p}$$

Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.

┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt29 PORR pytanie_glowne +Wyjaśnij: Prawo Amdahla $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$ egzamin_magisterski pyt29 PORR szczegoly +Wyjaśnij: Wizualizacja ograniczenia 20 ┤ ........... p=99% egzamin_magisterski pyt29 PORR szczegoly +Co osłabia ograniczenie Amdahla? Amdahl: Stały problem, więcej procesorów egzamin_magisterski pyt29 PORR szczegoly +Wyjaśnij: Czynniki zmniejszające rzeczywiste przyśpieszenie S_real < S_Amdahl ze względu na: egzamin_magisterski pyt29 PORR szczegoly +Wyjaśnij: Efektywność równoległa $$E(n) = \frac{S(n)}{n} = \frac{1}{n \cdot (1-p) + p}$$ egzamin_magisterski pyt29 PORR szczegoly +Wyjaśnij: Rozszerzone prawo Amdahla (z overhead) $$S(n) = \frac{1}{(1-p) + \frac{p}{n} + O(n)}$$ egzamin_magisterski pyt29 PORR szczegoly +Wyjaśnij: Struktura modelu matematycznego ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnij: Metody modelowania ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnij: Typowe problemy w modelowaniu Problem: Ile zmiennych? Jakie typy? egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnij: Techniki modelowania Problem: xy (iloczyn zmiennych ciągłych) egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnij: Wielokryterialne podejmowanie decyzji min f₁(x), f₂(x), ..., f_k(x) ← konfliktujące cele egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnij: Analiza wrażliwości ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt30 MOM szczegoly +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$

$$f \text{ wypukła} \Leftrightarrow f(\lambda x + (1-\lambda)y) \leq \lambda f(x) + (1-\lambda) f(y)$$

$$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$ egzamin_magisterski pyt31 MOM pytanie_glowne +Wyjaśnij: Klasyfikacja problemów optymalizacyjnych ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Definicje kluczowe $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$ egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Znaczenie wypukłości Problem │ Złożoność │ Gwarancja egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Liniowość vs nieliniowość $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$ egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Testowanie wypukłości 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Problemy niewypukłe ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt31 MOM szczegoly +Wyjaśnij: Dualność Primal (P): Dual (D): egzamin_magisterski pyt31 MOM szczegoly +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? | Funkcja MPI | Blokująca? | Synchroniczna? | Opis |

MPI_Irecv(from=partner, data_in, &req_recv); // Nieblokujące recv egzamin_magisterski pyt32 PORR pytanie_glowne +Wyjaśnij: Definicje podstawowe ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt32 PORR szczegoly +Wyjaśnij: Problem zakleszczenia (Deadlock) // DEADLOCK! - oba procesy czekają na siebie nawzajem egzamin_magisterski pyt32 PORR szczegoly +Wyjaśnij: Rozwiązania problemu zakleszczenia // Proces 0: // Proces 1: egzamin_magisterski pyt32 PORR szczegoly +Wyjaśnij: Algorytm Jacobiego - pełny przykład // Iteracyjne rozwiązanie równania Laplace'a egzamin_magisterski pyt32 PORR szczegoly +Wyjaśnij: Wzorce komunikacji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt32 PORR szczegoly +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model. channel.queue_bind(exchange='logs', queue=queue_name)

| Cecha | Kafka | RabbitMQ | MQTT | Redis Pub/Sub |

2. CQRS (Command Query Responsibility Segregation): egzamin_magisterski pyt33 PSD pytanie_glowne +Wyjaśnij: Definicja modelu Pub/Sub ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt33 PSD szczegoly +Wyjaśnij: Wildcardy (MQTT) home/living-room/# → wszystko z living-room egzamin_magisterski pyt33 PSD szczegoly +Wyjaśnij: Gwarancje dostarczenia ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt33 PSD szczegoly +Wyjaśnij: Rozwiązania techniczne ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt33 PSD szczegoly +Wyjaśnij: Zalety i wady Pub/Sub ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt33 PSD szczegoly +Wyjaśnij: Wzorce użycia [Service] ─publish─→ [Kafka] ←─consume─ [Projections] egzamin_magisterski pyt33 PSD szczegoly +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. KStream source = builder.stream("input-topic");

| Cecha | Kafka Streams | Flink | Spark Streaming |

Query(x): min(h1[hash1(x)], h2[hash2(x)], h3[hash3(x)]) egzamin_magisterski pyt34 PSD pytanie_glowne +Wyjaśnij: Charakterystyka danych strumieniowych ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt34 PSD szczegoly +Wyjaśnij: Modele przetwarzania Event Time: Kiedy zdarzenie faktycznie nastąpiło egzamin_magisterski pyt34 PSD szczegoly +Wyjaśnij: Platformy Stream Processing StreamsBuilder builder = new StreamsBuilder(); egzamin_magisterski pyt34 PSD szczegoly +Wyjaśnij: Algorytmy strumieniowe Problem: Zlicz unikalne elementy w strumieniu egzamin_magisterski pyt34 PSD szczegoly +Wyjaśnij: Obsługa opóźnień i Out-of-Order ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt34 PSD szczegoly +Wyjaśnij: Exactly-Once Semantics ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt34 PSD szczegoly +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. ┌─────────────────────────────────────────────────────────────────┐

┌─────────────────────────────────────────────────────────────────┐

Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin_magisterski pyt35 SIU pytanie_glowne +Wyjaśnij: Definicja układów cyber-fizycznych (CPS) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt35 SIU szczegoly +Wyjaśnij: Specyfika modelowania CPS ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt35 SIU szczegoly +Wyjaśnij: Współpraca agentów w sieci Problem: Agenty mają osiągnąć wspólną wartość egzamin_magisterski pyt35 SIU szczegoly +Wyjaśnij: Problemy w osiąganiu pożądanego zachowania ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt35 SIU szczegoly +Wyjaśnij: Warunki zbieżności consensus Twierdzenie: Protokół consensus ẋ = -Lx zbiega do consensus ⟺ egzamin_magisterski pyt35 SIU szczegoly +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$

$$Q^\pi(s,a) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s, a_0 = a \right]$$

Q(s,a) = R(s,a) + γ Σ_s' P(s'|s,a) max_a' Q(s',a') egzamin_magisterski pyt36 SIU pytanie_glowne +Wyjaśnij: Model uczenia ze wzmocnieniem ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Markov Decision Process (MDP) P: P(s'|s,a) - prawdopodobieństwa przejść egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Funkcje wartości $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$ egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Algorytmy ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Klasyfikacja algorytmów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Własności i wyzwania ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt36 SIU szczegoly +Wyjaśnij: Właściwości rzeczywistych sieci ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Model Erdős-Rényi (Random Graph) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Model Watts-Strogatz (Small-World) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Model Barabási-Albert (Scale-Free) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Porównanie zbiorcze ┌──────────────┬───────────────┬───────────────┬───────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Modele rozszerzone ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt37 TASS szczegoly +Wyjaśnij: Grafy dwudzielne (Bipartite Graphs) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt38 TASS szczegoly +Wyjaśnij: Projekcja grafu dwudzielnego ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt38 TASS szczegoly +Wyjaśnij: Metody projekcji P = B · Bᵀ (dla projekcji na U) egzamin_magisterski pyt38 TASS szczegoly +Wyjaśnij: Zastosowanie w grupowaniu dokumentów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt38 TASS szczegoly +Wyjaśnij: Algorytmy grupowania na projekcji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt38 TASS szczegoly +Scharakteryzować problem segmentacji obrazu. Przedstawić podstawowe strategie i algorytmy segmentacji przy użyciu metod klasycznych oraz sieci neuronowych. ┌──────────────────┐ Threshold ┌──────────────────┐

| Architektura | mIoU (ADE20K) | Parametry | Cechy | egzamin_magisterski pyt39 TWM pytanie_glowne +Wyjaśnij: Definicja problemu segmentacji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt39 TWM szczegoly +Wyjaśnij: Metody klasyczne pixel_out = 255 if pixel_in > T else 0 egzamin_magisterski pyt39 TWM szczegoly +Wyjaśnij: Metody deep learning ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt39 TWM szczegoly +Wyjaśnij: Loss functions Problem: class imbalance (dużo tła, mało obiektów) egzamin_magisterski pyt39 TWM szczegoly +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? ┌─────────────────────────────────────────────────────────────────┐

┌─────────────────────────────────────────────────────────────────┐

┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt40 TWM pytanie_glowne +Wyjaśnij: Definicja problemu detekcji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt40 TWM szczegoly +Wyjaśnij: Metody Deep Learning ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt40 TWM szczegoly +Wyjaśnij: Konstrukcja detektora z klasyfikatora ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt40 TWM szczegoly +Wyjaśnij: Non-Maximum Suppression (NMS) Problem: Wiele overlapping detections egzamin_magisterski pyt40 TWM szczegoly +Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR pytanie_glowne +Wyjaśnij: Decyzje w warunkach ryzyka ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metody interaktywne - przegląd ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metoda loterii (Lottery Method) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metoda pewnego ekwiwalentu (Certainty Equivalent) CE (Certainty Equivalent) = pewna kwota równoważna loterii egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metoda AHP (Analytic Hierarchy Process) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metoda PROMETHEE ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Wyjaśnij: Metoda ELECTRE ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt41 WDWR szczegoly +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$

$$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$ egzamin_magisterski pyt42 WDWR pytanie_glowne +Wyjaśnij: Idea dominacji stochastycznej ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Dominacja stochastyczna pierwszego rzędu (FSD) $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Dominacja stochastyczna drugiego rzędu (SSD) $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Porównanie FSD i SSD ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Zastosowanie w modelach wyboru ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Testowanie dominacji ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt42 WDWR szczegoly +Wyjaśnij: Notacja Graham'a (α|β|γ) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt43 ZBOP szczegoly +Wyjaśnij: Pole α - Środowisko maszynowe Job 1 ──→ ┌───┐ ──→ ┌───┐ ──→ ┌───┐ ──→ egzamin_magisterski pyt43 ZBOP szczegoly +Wyjaśnij: Pole γ - Kryteria optymalizacji Lⱼ = Cⱼ - dⱼ (lateness, może być ujemne) egzamin_magisterski pyt43 ZBOP szczegoly +Wyjaśnij: Złożoność obliczeniowa ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt43 ZBOP szczegoly +Wyjaśnij: Algorytm Johnsona (F2 || Cmax) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt43 ZBOP szczegoly +Jakie problemy wiążą się z zarządzaniem zapasami w łańcuchu dostaw? Omówić przykładowy model zarządzania zapasami w łańcuchu dostaw. Ordering cost = K × (D/Q) (D/Q zamówień rocznie) egzamin_magisterski pyt44 ZBOP pytanie_glowne +Wyjaśnij: Łańcuch dostaw - struktura ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Problemy zarządzania zapasami ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Koszty zapasów ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Model EOQ (Economic Order Quantity) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Model z punktem zamawiania (ROP) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Model (s, S) / (R, Q) s │──────╲──────────────╲── egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Vendor Managed Inventory (VMI) ┌─────────────────────────────────────────────────────────────────┐ egzamin_magisterski pyt44 ZBOP szczegoly +Wyjaśnij: Pytanie "Jaki jest cel Pana pracy magisterskiej i dlaczego wybrano akurat temat porównania silników gier?" egzamin_magisterski pyt45 Ogólne szczegoly +Wyjaśnij: Odpowiedź wzorcowa Celem pracy jest kompleksowe porównanie wydajności i możliwości współczesnych silników gier (Unity i Unreal Engine), ze szczególnym uwzględnieniem ich wpływu na proces tworzenia gier oraz końcową jakość produktu. egzamin_magisterski pyt45 Ogólne szczegoly diff --git a/pytania/anki_extract.txt b/pytania/anki_extract.txt new file mode 100644 index 0000000..1b694cc --- /dev/null +++ b/pytania/anki_extract.txt @@ -0,0 +1,1947 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_extract + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Definicja: Automat skończony to piątka: M = (Q, Σ, δ, q₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (skończony zbiór symboli)
• δ: funkcja przejścia: Q × Σ → Q (DFA) lub Q × Σ → P(Q) (NFA)
• q₀: stan początkowy (q₀ ∈ Q)
• F: zbiór stanów akceptujących (F ⊆ Q) egzamin pyt01 AISDI main +Wyjaśnij: Hierarchia Chomsky'ego - fundament teoretyczny Noam Chomsky w 1956 roku zaproponował hierarchię czterech klas języków formalnych, gdzie każda kolejna klasa zawiera poprzednią: egzamin pyt01 AISDI detail +Wyjaśnij: Automat Skończony (Finite Automaton - FA) Definicja: Automat skończony to piątka: M = (Q, Σ, δ, q₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (skończony zbiór symboli)
• δ: funkcja przejścia: Q × Σ → Q (DFA) lub Q × Σ → P(Q) (NFA)
• q₀: stan początkowy (q₀ ∈ Q)
• F: zbiór stanów akceptujących (F ⊆ Q) egzamin pyt01 AISDI detail +Wyjaśnij: Automat ze Stosem (Pushdown Automaton - PDA) Definicja: Automat ze stosem to siódemka: M = (Q, Σ, Γ, δ, q₀, Z₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy
• Γ: alfabet stosowy
• δ: funkcja przejścia: Q × (Σ ∪ {ε}) × Γ → P(Q × Γ*)
• q₀: stan początkowy egzamin pyt01 AISDI detail +Wyjaśnij: Maszyna Turinga (Turing Machine - TM) Definicja: Maszyna Turinga to siódemka: M = (Q, Σ, Γ, δ, q₀, qaccept, qreject)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (nie zawiera symbolu pustego ␣)
• Γ: alfabet taśmowy (Σ ⊂ Γ, ␣ ∈ Γ)
• δ: funkcja przejścia: Q × Γ → Q × Γ × {L, R}
• q₀: stan początkowy egzamin pyt01 AISDI detail +Omówić i porównać algorytmy najkrótszej ścieżki wskazując ich kluczowe właściwości i logikę budowy: Dijkstry, Belmana-Forda, A*. Single-Source Shortest Path (SSSP): z jednego źródła do wszystkich wierzchołków
Single-Pair Shortest Path: z s do konkretnego t
All-Pairs Shortest Path (APSP): między wszystkimi parami (Floyd-Warshall) egzamin pyt02 AISDI main +Wyjaśnij: Wprowadzenie - problem najkrótszej ścieżki Single-Source Shortest Path (SSSP): z jednego źródła do wszystkich wierzchołków
Single-Pair Shortest Path: z s do konkretnego t
All-Pairs Shortest Path (APSP): między wszystkimi parami (Floyd-Warshall) egzamin pyt02 AISDI detail +Wyjaśnij: Charakterystyka • Autor:: Edsger Dijkstra (1956, opublikowany 1959)
• Typ:: Zachłanny (greedy)
• Problem:: SSSP - najkrótsze ścieżki z jednego źródła do wszystkich wierzchołków
• Ograniczenie:: ⚠️ Tylko nieujemne wagi krawędzi (w(e) ≥ 0) egzamin pyt02 AISDI detail +Wyjaśnij: Idea algorytmu (logika budowy) 1. Relaksacja: Stopniowe ulepszanie oszacowań odległości +2. Zachłanność: W każdym kroku wybieramy wierzchołek o najmniejszej znanej odległości +3. Optymalna podstruktura: Najkrótsza ścieżka składa się z najkrótszych podścieżek egzamin pyt02 AISDI detail +Wyjaśnij: Pseudokod ``` +DIJKSTRA(G, w, s): + // Inicjalizacja + for each v ∈ V: + d[v] ← ∞ + π[v] ← NIL + d[s] ← 0 + + Q ← priority_queue(V) // min-heap według d[v] + S ← ∅ // zbiór przetworzonych + + while Q ≠ ∅: + u ← EXTRACT-MIN(Q) + S ← S ∪ {u} egzamin pyt02 AISDI detail +Wyjaśnij: Złożoność czasowa | Implementacja kolejki | EXTRACT-MIN | DECREASE-KEY | Całkowita | +|----------------------|-------------|--------------|-----------| +| Lista/tablica | O(V) | O(1) | O(V²) | +| Kopiec binarny | O(log V) | O(log V) | O((V + E) log V) | +| Kopiec Fibonacciego | O(log V) | O(1) | **O(V log V + E egzamin pyt02 AISDI detail +Wyjaśnij: Dlaczego nie działa dla ujemnych wag? ``` + A ---(-5)--- B + | | + (1) (1) + | | + S -----------C + (2) +```
Dijkstra przetwarza wierzchołki w kolejności rosnącej odległości i oznacza je jako "zakończone". Jeśli waga może być ujemna, późniejszy wierzchołek może "poprawić" już zakończony. egzamin pyt02 AISDI detail +Wyjaśnij: Wykrywanie cyklu ujemnego Po |V|-1 iteracjach, wszystkie najkrótsze ścieżki (bez cykli) są znalezione. +Jeśli w iteracji |V| nadal można zrelaksować krawędź → istnieje cykl ujemny. egzamin pyt02 AISDI detail +Wyjaśnij: Heurystyka - kluczowy element 1. Dopuszczalność (Admissibility): + h(n) ≤ h(n) dla każdego n + + gdzie h(n) = rzeczywisty koszt n → cel + + → Gwarantuje optymalność rozwiązania
2. Spójność/Monotoniczność (Consistency): + h(n) ≤ w(n, m) + h(m) dla każdej krawędzi (n, m) + + → Gwarantuje, że węzeł nie musi być ponownie otwarty + → Spójność implikuje dopuszczalność egzamin pyt02 AISDI detail +Wyjaśnij: Przypadki specjalne: • h(n) = 0:: A* = Dijkstra egzamin pyt02 AISDI detail +Wyjaśnij: Dijkstra • Nawigacja GPS: (drogi nie mają ujemnych odległości)
• Routing w sieciach: (OSPF protocol)
• Mapy Google/Apple: (dla małych obszarów) egzamin pyt02 AISDI detail +Wyjaśnij: Bellman-Ford • Routing w sieciach: (RIP protocol - prostszy)
• Arbitraż walutowy: (szukanie cykli ujemnych = zysk!)
• Systemy z "karami": (ujemne wagi = bonusy) egzamin pyt02 AISDI detail +Wyjaśnij: A* • Gry komputerowe: pathfinding NPC, RTS
• Robotyka: planowanie ruchu
• Puzzle: 8-puzzle, 15-puzzle
• Nawigacja: gdy znamy pozycję celu
• Dijkstra:: Relaksuje krawędzie wychodzące z wierzchołka o minimalnym d[v] egzamin pyt02 AISDI detail +Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. • Redundancja: = niepożądane powtarzanie danych
• Normalizacja: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin pyt03 BD2 main +Wyjaśnij: Wprowadzenie • Redundancja: = niepożądane powtarzanie danych
• Normalizacja: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin pyt03 BD2 detail +Wyjaśnij: Definicja Redundancja występuje, gdy ta sama informacja jest przechowywana w wielu miejscach bazy danych, co prowadzi do: +- Marnowania pamięci +- Niespójności danych (anomalii) +- Trudności w utrzymaniu egzamin pyt03 BD2 detail +Wyjaśnij: Anomalie wynikające z redundancji Problemy:: "Bazy Danych" i "Dr Nowak" powtórzono 3 razy egzamin pyt03 BD2 detail +Wyjaśnij: Trzy typy anomalii #### 1. Anomalia wstawiania (Insertion Anomaly) +Problem: Nie można dodać danych bez dodania innych, niepotrzebnych danych.
Przykład: Nie możemy dodać nowego kursu "Sieci komputerowe" bez przypisania do niego studenta. egzamin pyt03 BD2 detail +Wyjaśnij: Podstawowe pojęcia #### Zależność funkcyjna (Functional Dependency - FD) +X → Y oznacza: wartość X jednoznacznie określa wartość Y
Przykład: StudentID → (Imię, Nazwisko) +- Znając StudentID, możemy jednoznacznie określić imię i nazwisko egzamin pyt03 BD2 detail +Wyjaśnij: Hierarchia postaci normalnych ``` +5NF ⊂ 4NF ⊂ BCNF ⊂ 3NF ⊂ 2NF ⊂ 1NF +```
Każda wyższa postać implikuje niższą. egzamin pyt03 BD2 detail +Wyjaśnij: 1NF - Pierwsza Postać Normalna Atomowość wartości: każda komórka zawiera jedną, niepodzielną wartość
Brak powtarzających się grup: brak tablic/list w komórkach egzamin pyt03 BD2 detail +Wyjaśnij: 2NF - Druga Postać Normalna #### Wymagania: +1. Spełnia 1NF +2. Każdy atrybut wtórny jest w pełni funkcyjnie zależny od całego klucza głównego (nie od jego części)
Dotyczy tylko tabel z kluczem złożonym (wielokolumnowym). egzamin pyt03 BD2 detail +Wyjaśnij: 3NF - Trzecia Postać Normalna Brak przechodnich zależności funkcyjnych: atrybuty wtórne nie zależą od innych atrybutów wtórnych egzamin pyt03 BD2 detail +Wyjaśnij: BCNF - Postać Normalna Boyce'a-Codda #### Wymagania: +1. Spełnia 3NF +2. Dla każdej nietrywialnej FD X → Y, X jest nadkluczem
BCNF jest silniejsza niż 3NF - eliminuje przypadki, gdy atrybut pierwszy zależy od atrybutu niebędącego nadkluczem. egzamin pyt03 BD2 detail +Wyjaśnij: 4NF - Czwarta Postać Normalna #### Wymagania: +1. Spełnia BCNF +2. Brak nietrywialnych zależności wielowartościowych (MVD - Multivalued Dependencies)
Zależność wielowartościowa X ↠ Y: Dla danego X istnieje zbiór wartości Y niezależny od innych atrybutów. egzamin pyt03 BD2 detail +Wyjaśnij: 5NF - Piąta Postać Normalna (PJNF) #### Wymagania: +1. Spełnia 4NF +2. Brak zależności połączeniowych (Join Dependencies) +3. Dekompozycja bez strat tylko na podstawie kluczy kandydujących
5NF eliminuje redundancję wynikającą z niemożliwości odtworzenia oryginalnej relacji przez złączenie jej projekcji. egzamin pyt03 BD2 detail +Wyjaśnij: Algorytm dekompozycji do 3NF 1. Znajdź pokrycie kanoniczne zbioru zależności funkcyjnych +2. Dla każdej FD X → A utwórz relację R(X, A) +3. Jeśli żadna relacja nie zawiera klucza kandydującego, dodaj relację z atrybutami klucza +4. Usuń relacje zawarte w innych relacjach egzamin pyt03 BD2 detail +Wyjaśnij: Własności dobrej dekompozycji #### 1. Bezstratność (Lossless Join) +Po dekompozycji można odtworzyć oryginalną relację przez złączenie naturalne.
Twierdzenie: Dekompozycja R na R₁ i R₂ jest bezstratna wtw gdy: +- R₁ ∩ R₂ → R₁, lub +- R₁ ∩ R₂ → R₂ egzamin pyt03 BD2 detail +Wyjaśnij: Kiedy stosować? • Optymalizacja wydajności: złączenia są kosztowne
• Systemy OLAP/hurtownie danych: dane głównie odczytywane
• Raportowanie: predefiniowane zapytania egzamin pyt03 BD2 detail +Wyjaśnij: Techniki denormalizacji: Dodanie redundantnych kolumn: unikanie złączeń
Tabele historyczne: snapshoty
Materializowane widoki: cache wyników egzamin pyt03 BD2 detail +Wyjaśnij: Wzór na 3NF: > "Każdy atrybut zależy od klucza, całego klucza i tylko od klucza." +> (The key, the whole key, and nothing but the key - so help me Codd!)
## ❓ Możliwe pytania dodatkowe (follow-up) egzamin pyt03 BD2 detail +Dlaczego baza danych stanowi dobry fundament do budowy wielu systemów informatycznych? Baza danych to centralny komponent większości systemów informatycznych, ponieważ zapewnia: +- Trwałe przechowywanie danych +- Współbieżny dostęp +- Integralność i spójność +- Niezależność danych od aplikacji egzamin pyt04 BD2 main +Wyjaśnij: Transakcyjność - gwarancje ACID | Właściwość | Opis | Znaczenie | +|------------|------|-----------| +| Atomicity (Atomowość) | Transakcja wykonuje się w całości lub wcale | Brak częściowych zmian | +| Consistency (Spójność) | Dane przechodzą z jednego spójnego stanu w drugi | Reguły biznesowe zawsze spełnione | +| Isolati egzamin pyt04 BD2 detail +Wyjaśnij: Trójpoziomowa architektura ANSI/SPARC ``` +┌─────────────────────────────────────────┐ +│ Poziom zewnętrzny (widoki) │ ← Aplikacje widzą różne "okna" +├─────────────────────────────────────────┤ +│ Poziom konceptualny (logiczny) │ ← Struktura logiczna danych +├─────────────────────────────────────────┤ +│ Poziom we egzamin pyt04 BD2 detail +Wyjaśnij: Rodzaje niezależności #### 1. Niezależność fizyczna +Zmiana sposobu przechowywania (indeksy, partycjonowanie, kompresja) nie wpływa na aplikacje.
Przykład: Dodanie indeksu przyspiesza zapytania bez zmiany kodu aplikacji. egzamin pyt04 BD2 detail +Wyjaśnij: Problem współbieżności Wiele aplikacji/użytkowników jednocześnie korzysta z tych samych danych. egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy kontroli współbieżności | Mechanizm | Opis | Zastosowanie | +|-----------|------|--------------| +| Blokady (Locks) | Pesymistyczne - blokuj przed dostępem | Wysokie konflikty | +| MVCC | Optymistyczne - wersjonowanie | Dużo odczytów | +| Timestamp Ordering | Szeregowanie po czasie | Systemy rozproszone | +| **Snaps egzamin pyt04 BD2 detail +Wyjaśnij: Poziomy izolacji (SQL Standard) | Poziom | Dirty Read | Non-repeatable Read | Phantom Read | +|--------|------------|---------------------|--------------| +| READ UNCOMMITTED | Możliwy | Możliwy | Możliwy | +| READ COMMITTED | Niemożliwy | Możliwy | Możliwy | +| REPEATABLE READ | Niemożliwy | Niemożliwy | Możliwy | +| SERIALIZABLE | Ni egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wymuszania integralności #### 1. Ograniczenia deklaratywne +```sql +CREATE TABLE Zamowienia ( + id INT PRIMARY KEY, -- Klucz główny + klient_id INT NOT NULL, -- NOT NULL + data DATE DEFAULT CURRENT_DATE, -- Wartość domyślna + kwota DECIMAL(10,2) CHECK (kwota >
#### 2. Wyzwalacze (Triggers) +```sql +CREATE TRIGGER sprawdz_saldo +BEFORE UPDATE ON Konta +FOR EACH ROW +BEGIN + IF NEW.saldo < 0 THEN + SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Brak środków'; + END IF; +END; +``` egzamin pyt04 BD2 detail +Wyjaśnij: Optymalizator zapytań SZBD automatycznie: +1. Analizuje zapytanie (parsing) +2. Generuje plany wykonania (alternatywy) +3. Szacuje koszty (statystyki) +4. Wybiera najlepszy plan (optymalizacja) egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wydajności | Mechanizm | Funkcja | +|-----------|---------| +| Indeksy | Szybkie wyszukiwanie (B-tree, Hash, GiST) | +| Buforowanie | Cache często używanych danych | +| Partycjonowanie | Podział dużych tabel | +| Materializowane widoki | Prekompilowane złączenia | +| Query cache | Cache wyników z egzamin pyt04 BD2 detail +Wyjaśnij: Wielopoziomowe zabezpieczenia ``` +┌─────────────────────────────────────────┐ +│ Autoryzacja (GRANT/REVOKE) │ +├─────────────────────────────────────────┤ +│ Autentykacja (użytkownicy, role) │ +├─────────────────────────────────────────┤ +│ Szyfrowanie (TDE, SSL/TLS) │ +├─────────────────────────────── egzamin pyt04 BD2 detail +Wyjaśnij: Kontrola dostępu -- Przypisanie użytkownika +GRANT analityk TO jan_kowalski;
-- Widok ograniczający dane +CREATE VIEW MojeZamowienia AS + SELECT * FROM Zamowienia WHERE sprzedawca = CURRENT_USER; +``` egzamin pyt04 BD2 detail +Wyjaśnij: Skalowanie pionowe (Scale-up) - Więcej RAM, szybsze CPU, dyski SSD +- Proste, ale ograniczone egzamin pyt04 BD2 detail +Wyjaśnij: Skalowanie poziome (Scale-out) • Replikacja: kopie do odczytu
• Sharding: podział danych między serwery
• Klastry: wysoka dostępność egzamin pyt04 BD2 detail +Wyjaśnij: Wysoka dostępność (HA) | Rozwiązanie | Opis | +|-------------|------| +| Replikacja Master-Slave | Odczyty z replik | +| Replikacja Master-Master | Zapisy na wielu węzłach | +| Failover automatyczny | Przełączanie przy awarii | +| Backup/Recovery | Odtwarzanie po katastrofie |
## 8. Standaryzacja i ekosystem egzamin pyt04 BD2 detail +Wyjaśnij: SQL jako lingua franca • Standardowy język: SQL:2016, SQL:2023
• Przenośność: kod działa na różnych SZBD
• Narzędzia: uniwersalne IDE, ORM, ETL egzamin pyt04 BD2 detail +Wyjaśnij: Bogaty ekosystem • ORM: (Hibernate, Entity Framework, SQLAlchemy)
• Narzędzia migracji: (Flyway, Liquibase)
• Monitorowanie: (Grafana, Datadog)
• Backup: (pg_dump, mysqldump, RMAN) egzamin pyt04 BD2 detail +Wyjaśnij: Jeden fundament, wiele modeli | Model | SZBD | Zastosowanie | +|-------|------|--------------| +| Relacyjny | PostgreSQL, MySQL, Oracle | OLTP, dane strukturalne | +| Dokumentowy | MongoDB, CouchDB | JSON, elastyczne schematy | +| Klucz-wartość | Redis, DynamoDB | Cache, sesje | +| Grafowy | Neo4j, Amazon Neptune | Re egzamin pyt04 BD2 detail +Wyjaśnij: Polyglot Persistence wielu baz: każda do swojego celu. egzamin pyt04 BD2 detail +Omówić główne kategorie elementów biblioteki STL. Jaka jest ich rola i wzajemne powiązania? Odpowiedź uzasadnić na przykładach. • Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami
• Wydajność: zero-overhead abstraction
• Modularność: komponenty są niezależne i wymienne
• Ortogonalność: kontenery i algorytmy są rozdzielone (przez iteratory) egzamin pyt05 PROI main +Wyjaśnij: Filozofia STL • Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami
• Wydajność: zero-overhead abstraction
• Modularność: komponenty są niezależne i wymienne
• Ortogonalność: kontenery i algorytmy są rozdzielone (przez iteratory) egzamin pyt05 PROI detail +Wyjaśnij: Kategorie kontenerów #### 1.1 Kontenery sekwencyjne (Sequence Containers)
Przechowują elementy w określonej kolejności. egzamin pyt05 PROI detail +Wyjaśnij: Hierarchia iteratorów ``` + Input Iterator Output Iterator + ↓ ↓ + Forward Iterator ←────────┘ + ↓ + Bidirectional Iterator + ↓ + Random Access Iterator egzamin pyt05 PROI detail +Wyjaśnij: Kategorie iteratorów | Kategoria | Operacje | Przykłady kontenerów | +|-----------|----------|---------------------| +| Input | `++`, ``, `==`, `!=` | istream_iterator | +| Output | `++`, `` (zapis) | ostream_iterator | +| Forward | Input + wielokrotne przejście | forward_list, unordered_* | +| **Bidirectional*
std::vector vec = {1, 2, 3, 4, 5}; egzamin pyt05 PROI detail +Wyjaśnij: Iteratory specjalne ```cpp +#include +#include +#include
std::vector vec = {1, 2, 3}; egzamin pyt05 PROI detail +Wyjaśnij: Kategorie algorytmów #### 3.1 Algorytmy niemodyfikujące
std::vector vec = {1, 2, 3, 4, 5, 3}; egzamin pyt05 PROI detail +Wyjaśnij: Rodzaje funktorów #### 4.1 Predefiniowane funktory (``)
std::vector vec = {3, 1, 4, 1, 5}; egzamin pyt05 PROI detail +Wyjaśnij: Kluczowa zasada: Ortogonalność M kontenerów × N algorytmów = M + N implementacji (nie M × N!)
Dzięki iteratorom: +- Algorytm `sort` działa z `vector`, `deque`, `array` +- Każdy nowy kontener automatycznie współpracuje z istniejącymi algorytmami +- Każdy nowy algorytm automatycznie współpracuje z istniejącymi kontenerami egzamin pyt05 PROI detail +Omówić metody reużywalności kodu i struktur danych w obiektowych językach programowania. Reużywalność kodu (code reuse) to fundamentalna zasada inżynierii oprogramowania - "nie wynajduj koła na nowo". W programowaniu obiektowym mamy kilka mechanizmów umożliwiających wielokrotne wykorzystanie kodu.
### Główne metody reużywalności egzamin pyt06 PROI main +Wyjaśnij: Główne metody reużywalności ``` +┌─────────────────────────────────────────────────────────────────┐ +│ METODY REUŻYWALNOŚCI │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ DZIEDZICZENIE │ KOMPOZYCJA │ PROGRAMOWANIE │ +│ (Inheritance) │ (C
## 1. Dziedziczenie (Inheritance) egzamin pyt06 PROI detail +Wyjaśnij: Typy dziedziczenia | Typ | Opis | Języki | +|-----|------|--------| +| Pojedyncze | Jedna klasa bazowa | Java, C# | +| Wielokrotne | Wiele klas bazowych | C++, Python | +| Wielopoziomowe | A → B → C | Wszystkie | +| Hierarchiczne | A → B, A → C | Wszystkie | egzamin pyt06 PROI detail +Wyjaśnij: Zalety i wady dziedziczenia | Zalety | Wady | +|--------|------| +| Naturalne modelowanie hierarchii | Silne wiązanie (tight coupling) | +| Polimorfizm | Problem kruchej klasy bazowej | +| Łatwe rozszerzanie | Problemy z wielodziedziczeniem (diamond) | +| Współdzielenie implementacji | Narusza enkapsulację | egzamin pyt06 PROI detail +Wyjaśnij: Problem diamentu (Diamond Problem) ``` + A + / \ + B C + \ / + D +```
D d; +// d.metoda(); // BŁĄD: niejednoznaczne! +d.B::metoda(); // OK - jawne wskazanie +``` egzamin pyt06 PROI detail +Wyjaśnij: Typy relacji obiektowych | Relacja | Siła | Cykl życia | Przykład | +|---------|------|------------|----------| +| Kompozycja | Silna | Zależny (owns) | Samochód → Silnik | +| Agregacja | Słaba | Niezależny (uses) | Uniwersytet → Student | +| Asocjacja | Luźna | Niezależny | Klient ↔ Zamówienie |
// Agregacja - student istnieje niezależnie od uniwersytetu +class Uniwersytet { +private: + std::vector> studenci; // Wskaźniki/referencje +public: + void dodajStudenta(Student s) { studenci.push_back(s); } + // ~Uniwersytet() NIE niszczy studentów +}; +``` egzamin pyt06 PROI detail +Wyjaśnij: Szablony w C++ ```cpp +// Szablon funkcji +template +T maximum(T a, T b) { + return (a > b) ? a : b; +}
// Użycie - kompilator generuje wersje dla każdego typu +int m1 = maximum(3, 5); // int +double m2 = maximum(3.14, 2.71); // double +std::string m3 = maximum("abc", "xyz"); // string egzamin pyt06 PROI detail +Wyjaśnij: Generyki w Java/C# ```java +// Java +public class Box { + private T value; + + public void set(T value) { this.value = value; } + public T get() { return value; } +}
// Ograniczenia typów (bounded type parameters) +public > T max(T a, T b) { + return a.compareTo(b) > 0 ? a : b; +} +``` egzamin pyt06 PROI detail +Wyjaśnij: Zalety programowania generycznego | Zaleta | Opis | +|--------|------| +| Type safety | Błędy wykrywane w czasie kompilacji | +| Brak duplikacji | Jeden kod dla wielu typów | +| Wydajność | C++: specjalizacja w kompilacji, brak rzutowania | +| Czytelność | Jawne wymagania typów | egzamin pyt06 PROI detail +Wyjaśnij: Interfejsy vs Klasy abstrakcyjne | Cecha | Interfejs | Klasa abstrakcyjna | +|-------|-----------|-------------------| +| Wielodziedziczenie | TAK | NIE (Java/C#) | +| Pola | NIE (do Java 8) | TAK | +| Konstruktor | NIE | TAK | +| Implementacja metod | default (Java 8+) | TAK | +| Cel | Definiuje kontrakt | Współdzieli implementację | egzamin pyt06 PROI detail +Wyjaśnij: Wzorzec strategii (Strategy Pattern) ```cpp +// Interfejs strategii +class SortStrategy { +public: + virtual void sort(std::vector& data) = 0; + virtual ~SortStrategy() = default; +};
class QuickSort : public SortStrategy { +public: + void sort(std::vector& data) override { / quicksort / } +}; egzamin pyt06 PROI detail +Wyjaśnij: Mixiny (Mixins) Klasy dostarczające funkcjonalność do "wmieszania" do innych klas.
class XMLSerializableMixin: + def to_xml(self): + # implementacja... + pass egzamin pyt06 PROI detail +Wyjaśnij: Traity (Traits) ```rust +// Rust - traits +trait Drawable { + fn draw(&self); +}
trait Movable { + fn move_to(&mut self, x: i32, y: i32); +} egzamin pyt06 PROI detail +Wyjaśnij: Poziomy reużywalności ``` +┌─────────────────────────────────────────────────────┐ +│ FRAMEWORK │ +│ (IoC, definiuje architekturę aplikacji) │ +├─────────────────────────────────────────────────────┤ +│ BIBLIOTEKA │ +│ (kolekcja egzamin pyt06 PROI detail +Wyjaśnij: Wzorce wspierające reużywalność | Wzorzec | Typ | Cel | +|---------|-----|-----| +| Factory Method | Kreacyjny | Delegacja tworzenia obiektów | +| Abstract Factory | Kreacyjny | Rodziny powiązanych obiektów | +| Prototype | Kreacyjny | Klonowanie obiektów | +| Adapter | Strukturalny | Dopasowanie interfejsów | +| **Decor egzamin pyt06 PROI detail +Które serwery DNS najwięcej zyskują dzięki buforowaniu zapytań (caching) w serwerach rekursywnych? Jakie znasz rodzaje serwerów DNS? DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin pyt07 SKM main +Wyjaśnij: Wprowadzenie do DNS DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin pyt07 SKM detail +Wyjaśnij: Hierarchia DNS ``` + . (root) + /|\ + / | \ + com org pl + /|\ | + / | \ | + google amazon pw + | | + www elka +``` egzamin pyt07 SKM detail +Wyjaśnij: 1 Serwery autorytatywne (Authoritative) • 13 logicznych serwerów:: a.root-servers.net do m.root-servers.net
• Fizycznie:: Setki serwerów (anycast)
• Funkcja:: Wskazują serwery TLD
• gTLD:: .com, .org, .net (generic)
• ccTLD:: .pl, .de, .uk (country code) egzamin pyt07 SKM detail +Wyjaśnij: 2 Serwery rekursywne (Recursive Resolvers) Definicja: Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne. egzamin pyt07 SKM detail +Wyjaśnij: 3 Stub Resolvers (Resolwery klienckie) Definicja: Prosty klient DNS w systemie operacyjnym. Wysyła zapytanie do rekursywnego resolvera i czeka na odpowiedź.
- Windows: usługa DNS Client +- Linux: libc resolver (nsswitch.conf, resolv.conf) +- Nie wykonuje rekurencji sam egzamin pyt07 SKM detail +Wyjaśnij: 4 Forwarding Servers (Przekazujące) Definicja: Przyjmują zapytania i przekazują je do innego resolvera zamiast samodzielnie rozwiązywać.
## 2. Proces rozwiązywania DNS (Resolution) egzamin pyt07 SKM detail +Wyjaśnij: Zapytanie rekursywne vs iteracyjne ``` +ZAPYTANIE REKURSYWNE (klient → resolver): +"Daj mi odpowiedź na www.example.com" +→ Resolver musi zwrócić ostateczną odpowiedź lub błąd
ZAPYTANIE ITERACYJNE (resolver → authoritative): +"Co wiesz o www.example.com?" +→ Serwer zwraca odpowiedź lub odesłanie (referral) +``` egzamin pyt07 SKM detail +Wyjaśnij: Pełny proces rozwiązywania ``` +Klient Recursive Root .com TLD example.com + │ Resolver │ │ │ + │──(1) www.example.com?──→│ │ │ │ + │ │──(2) query?───→│ │ │
## 3. Buforowanie (Caching) w DNS egzamin pyt07 SKM detail +Wyjaśnij: Jak działa caching? Po wygaśnięciu TTL: pyta ponownie serwer autorytatywny egzamin pyt07 SKM detail +Wyjaśnij: TTL (Time To Live) ``` +; Fragment strefy DNS +www.example.com. 300 IN A 93.184.216.34 + ↑ + TTL = 300 sekund (5 minut) +```
## 4. Które serwery zyskują najwięcej na cachingu? egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego root servers zyskują najwięcej? ``` +BEZ CACHINGU: +┌────────────────────────────────────────────────────────────────┐ +│ Każde zapytanie DNS → najpierw pytanie do root server │ +│ Miliardy zapytań dziennie → root servers byłyby przeciążone! │ +└────────────────────────────────────────────────────────────────┘
Z CACHINGIEM: +┌────────────────────────────────────────────────────────────────┐ +│ Resolver pyta root server RAZ o serwery .com │ +│ Cache przechowuje referral przez długi czas (np. 48h) │ +│ Kolejne tysiące zapytań o .com → z cache, bez root │ +└──────────────────── egzamin pyt07 SKM detail +Wyjaśnij: Analiza ilościowa | Poziom | Liczba domen | Zapytania bez cache | Z cache | +|--------|--------------|---------------------|---------| +| Root | 1 (.) | ~100% zapytań | ~0.01% | +| TLD | ~1500 | ~100% zapytań | ~0.1% | +| Authoritative | Miliony | Proporcjonalnie | Zależne od TTL | egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego ROOT i TLD zyskują więcej niż authoritative? Mniejsza liczba = więcej zapytań na serwer:: 13 root servers vs miliony domen
Długie TTL referrali:: Root NS referrals: TTL 48h - 7 dni egzamin pyt07 SKM detail +Wyjaśnij: Podsumowanie zysków z cachingu ``` +REDUKCJA RUCHU DZIĘKI CACHINGOWI:
Root Servers: ████████████████████████████░░ ~99.9% redukcja +TLD Servers: ██████████████████████████░░░░ ~99% redukcja +Authoritative: ████████████░░░░░░░░░░░░░░░░░░ ~50-90% redukcja* egzamin pyt07 SKM detail +Jaki jest cel uzgadniania trójetapowego (three way handshake) w protokole TCP? Jaka jest interpretacja numerów sekwencyjnych i potwierdzenia? Jaka jest wartość początkowa numeru sekwencyjnego? TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: +- Niezawodne dostarczanie danych +- Kontrolę przepływu +- Kontrolę przeciążenia +- Połączeniowość (connection-oriented) egzamin pyt08 SKM main +Wyjaśnij: Wprowadzenie do TCP TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: +- Niezawodne dostarczanie danych +- Kontrolę przepływu +- Kontrolę przeciążenia +- Połączeniowość (connection-oriented)
## 1. Three-Way Handshake - cel i przebieg egzamin pyt08 SKM detail +Wyjaśnij: Cele uzgadniania trójetapowego Nawiązanie połączenia: obie strony zgadzają się na komunikację
Synchronizacja numerów sekwencyjnych: ISN (Initial Sequence Number)
Uzgodnienie parametrów: MSS, Window Scale, SACK, Timestamps
Weryfikacja dostępności: obie strony są aktywne i gotowe egzamin pyt08 SKM detail +Wyjaśnij: Przebieg (diagram) ``` + Klient Serwer + │ │ + │ (1) SYN, seq=x │ + │──────────────────────────────────────────→│ + │ │ + │ (2) SYN+ACK, seq=y, ack= egzamin pyt08 SKM detail +Wyjaśnij: Szczegółowy opis kroków #### Krok 1: SYN (Synchronize) +``` +Klient → Serwer: +┌────────────────────────────────────────┐ +│ Flaga: SYN = 1 │ +│ Sequence Number: x (ISN klienta) │ +│ Acknowledgment Number: 0 (nieistotny) │ +│ Opcje: MSS, Window Scale, SACK, etc. │ +└────────────────────────────────
#### Krok 2: SYN-ACK (Synchronize-Acknowledge) +``` +Serwer → Klient: +┌────────────────────────────────────────┐ +│ Flagi: SYN = 1, ACK = 1 │ +│ Sequence Number: y (ISN serwera) │ +│ Acknowledgment Number: x + 1 │ +│ Opcje: MSS, Window Scale, etc. │ +└──────────────── egzamin pyt08 SKM detail +Wyjaśnij: Interpretacja Sequence Number (SEQ) = numer pierwszego bajtu danych w segmencie
Segment 1: SEQ=0, dane = bajty 0-4 (5 bajtów) +Segment 2: SEQ=5, dane = bajty 5-9 (5 bajtów) +Segment 3: SEQ=10, dane = bajty 10-12 (3 bajty) +``` egzamin pyt08 SKM detail +Wyjaśnij: Funkcje numerów sekwencyjnych | Funkcja | Opis | +|---------|------| +| Kolejność | Odbiorca składa segmenty we właściwej kolejności | +| Wykrywanie duplikatów | Ten sam SEQ = duplikat | +| Wykrywanie braków | Luka w SEQ = brakujący segment | +| Potwierdzanie | ACK wskazuje oczekiwany następny SEQ | egzamin pyt08 SKM detail +Wyjaśnij: Kumulatywne potwierdzenia cumulative ACK: potwierdza wszystkie bajty do danego numeru: egzamin pyt08 SKM detail +Wyjaśnij: Selective ACK (SACK) Opcja TCP pozwalająca potwierdzać niesąsiednie bloki:
## 4. Wartość początkowa numeru sekwencyjnego (ISN) egzamin pyt08 SKM detail +Wyjaśnij: Dlaczego ISN nie zaczyna od 0? Bezpieczeństwo: przewidywalny ISN umożliwia ataki (TCP hijacking)
Unikanie kolizji: stare segmenty z poprzednich połączeń nie będą mylone z nowymi egzamin pyt08 SKM detail +Wyjaśnij: Generowanie ISN • M: = timer (jak wyżej)
• F: = funkcja kryptograficzna (MD5/SHA)
• secretkey: = tajny klucz serwera egzamin pyt08 SKM detail +Wyjaśnij: Właściwości dobrego ISN | Właściwość | Powód | +|------------|-------| +| Losowy | Utrudnia ataki typu sequence prediction | +| Unikalny | Różny dla każdego połączenia | +| Monotonicznie rosnący | Unikanie kolizji z poprzednimi połączeniami | egzamin pyt08 SKM detail +Wyjaśnij: Zakres numerów sekwencyjnych ``` +SEQ: 32 bity → zakres 0 do 4,294,967,295 (2^32 - 1)
Przy szybkości 1 Gbps: +- 125 MB/s danych +- Przepełnienie (wrap-around) co ~34 sekundy! egzamin pyt08 SKM detail +Procesy i wątki w systemie operacyjnym. Omówić budowę, szybkość działania i zakres zastosowania. Przedstawić problemy i możliwości komunikacji i synchronizacji. Proces i wątek to podstawowe jednostki wykonania w systemach operacyjnych. Różnią się poziomem izolacji i kosztami przełączania. egzamin pyt09 SOI main +Wyjaśnij: Budowa procesu ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PRZESTRZEŃ ADRESOWA PROCESU │ +├─────────────────────────────────────────────────────────────────┤ +│ ┌─────────────────┐ │ +│ │ STOS │ egzamin pyt09 SOI detail +Wyjaśnij: PCB (Process Control Block) Struktura w jądrze przechowująca informacje o procesie: egzamin pyt09 SOI detail +Wyjaśnij: Stany procesu ``` + ┌──────────────────┐ + (utworzenie) │ │ (zakończenie) + ↓ │ │ ↓ + ┌─────────┐ │ ┌──────────┐ │ ┌──────────┐ + │ NEW │───┼──→│ READY │←──┼──│TERMINATED│ + └─────────┘ │ └──────────┘ │ egzamin pyt09 SOI detail +Wyjaśnij: Budowa wątku ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROCES │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ WSPÓŁDZIELONE: egzamin pyt09 SOI detail +Wyjaśnij: TCB (Thread Control Block) | Pole | Opis | +|------|------| +| TID | Identyfikator wątku | +| Stan | Running, Ready, Blocked | +| Rejestry | PC, SP, rejestry ogólne | +| Stos | Wskaźnik do prywatnego stosu | +| Priorytet | Szeregowanie | +| Wskaźnik do PCB | Proces macierzysty |
## 3. Porównanie: Proces vs Wątek egzamin pyt09 SOI detail +Wyjaśnij: Tabela porównawcza | Cecha | Proces | Wątek | +|-------|--------|-------| +| Przestrzeń adresowa | Własna, izolowana | Współdzielona z procesem | +| Tworzenie | Wolne (~ms) | Szybkie (~μs) | +| Przełączanie kontekstu | Wolne (TLB flush) | Szybkie (tylko rejestry) | +| Komunikacja | IPC (pipe, socket, shm) | egzamin pyt09 SOI detail +Wyjaśnij: Koszty czasowe (typowe) | Operacja | Czas | +|----------|------| +| Tworzenie procesu | 1-10 ms | +| Tworzenie wątku | 10-100 μs | +| Przełączanie procesu | 1-10 μs | +| Przełączanie wątku | 0.1-1 μs | +| Komunikacja IPC | 1-100 μs | +| Współdzielona pamięć | 10-100 ns | egzamin pyt09 SOI detail +Wyjaśnij: Wątki użytkownika (User-level Threads) ``` +┌─────────────────────────────────────────┐ +│ PRZESTRZEŃ UŻYTKOWNIKA │ +│ ┌─────────────────────────────────┐ │ +│ │ Biblioteka wątków (pthread) │ │ +│ │ ┌─────┐ ┌─────┐ ┌─────┐ │ │ +│ │ │ W1 │ │ W2 │ │ W3 │ │ │ +│ │ └─────┘ └─────┘ └─────┘
Zalety: Szybkie przełączanie, przenośność +Wady: Blokujące wywołanie blokuje wszystkie wątki, brak prawdziwej równoległości egzamin pyt09 SOI detail +Wyjaśnij: Wątki jądra (Kernel-level Threads) ``` +┌─────────────────────────────────────────┐ +│ PRZESTRZEŃ UŻYTKOWNIKA │ +│ ┌─────┐ ┌─────┐ ┌─────┐ │ +│ │ W1 │ │ W2 │ │ W3 │ │ +│ └──┬──┘ └──┬──┘ └──┬──┘ │ +├─────────┼───────┼───────┼───────────────┤ +│ ↓ ↓ ↓
Zalety: Prawdziwa równoległość, blokada jednego nie blokuje innych +Wady: Wolniejsze operacje (wywołanie systemowe) egzamin pyt09 SOI detail +Wyjaśnij: Modele mapowania | Model | Opis | Przykłady | +|-------|------|-----------| +| 1:1 | 1 wątek user = 1 wątek kernel | Linux, Windows | +| N:1 | N wątków user = 1 wątek kernel | Green threads | +| M:N | M wątków user = N wątków kernel | Solaris, Go goroutines |
## 5. Komunikacja między procesami (IPC) egzamin pyt09 SOI detail +Wyjaśnij: Mechanizmy IPC ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MECHANIZMY IPC │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ SYGNAŁY │ POTOKI │ PAMIĘĆ WSPÓŁDZIELONA │ +│ (Signals) │ egzamin pyt09 SOI detail +Wyjaśnij: Szczegóły mechanizmów // Potok nazwany (FIFO) +mkfifo("/tmp/myfifo", 0666); +```
Cechy: Jednokierunkowe, FIFO, między powiązanymi procesami (anonimowe) egzamin pyt09 SOI detail +Wyjaśnij: Problemy współbieżności Mutual exclusion: zasób może mieć tylko jeden właściciel
Hold and wait: trzymaj i czekaj na więcej
No preemption: nie można odebrać zasobu
Circular wait: cykliczne oczekiwanie egzamin pyt09 SOI detail +Wyjaśnij: Mechanizmy synchronizacji • Binarny: (0/1) - jak mutex
• Licznikowy: ogranicza liczbę wątków (np. pula połączeń) egzamin pyt09 SOI detail +Wyjaśnij: Kiedy procesy? • Izolacja: awaria jednego nie wpływa na inne
• Bezpieczeństwo: różne uprawnienia
• Różne języki/technologie: mikrousługi
• Niezawodność: restart bez wpływu na system egzamin pyt09 SOI detail +Wyjaśnij: Kiedy wątki? • Współdzielenie danych: bez kopiowania
• Responsywność: UI thread + worker threads
• Równoległość CPU: obliczenia na wielu rdzeniach
• I/O asynchroniczne: czekanie nie blokuje wszystkiego egzamin pyt09 SOI detail +Scharakteryzować problemy i mechanizmy zarządzania pamięcią. Porównać cechy i przeznaczenie mechanizmów stronicowania i segmentacji. Zarządzanie pamięcią to jeden z kluczowych zadań systemu operacyjnego: +- Przydzielanie pamięci procesom +- Ochrona pamięci między procesami +- Efektywne wykorzystanie ograniczonego zasobu +- Abstrakcja (programista nie musi znać fizycznych adresów) egzamin pyt10 SOI main +Wyjaśnij: 1 Fragmentacja #### Fragmentacja zewnętrzna (External Fragmentation)
Problem: Wolna pamięć jest rozproszona w małych, nieciągłych blokach. egzamin pyt10 SOI detail +Wyjaśnij: 2 Ochrona pamięci - Proces A nie może czytać/pisać pamięci procesu B +- Jądro chronione przed aplikacjami użytkownika +- Mechanizmy: rejestry bazowy/graniczny, bity ochrony, ringi egzamin pyt10 SOI detail +Wyjaśnij: 3 Relokacja Rozwiązania:: Relokacja statyczna (loader) egzamin pyt10 SOI detail +Wyjaśnij: 4 Współdzielenie - Biblioteki współdzielone (DLL, .so) +- Pamięć współdzielona między procesami +- Copy-on-Write (COW) egzamin pyt10 SOI detail +Wyjaśnij: 5 Ograniczona pamięć fizyczna - Więcej procesów niż RAM +- Rozwiązanie: pamięć wirtualna + swap
## 2. Mechanizmy zarządzania pamięcią egzamin pyt10 SOI detail +Wyjaśnij: 1 Partycjonowanie stałe (Fixed Partitioning) ``` +┌────────────────────────────────────────────────────────────────┐ +│ Pamięć podzielona na stałe partycje: │ +│ ┌──────────┬──────────┬──────────┬──────────┐ │ +│ │ Partycja │ Partycja │ Partycja │ Partycja │ │ +│ │ 1MB │ 2MB │ egzamin pyt10 SOI detail +Wyjaśnij: 2 Partycjonowanie dynamiczne (Dynamic Partitioning) ``` +┌────────────────────────────────────────────────────────────────┐ +│ Partycje tworzone według potrzeb: │ +│ ┌─────┬───────────┬────────┬─────────────────────────────┐ │ +│ │ P1 │ P2 │ P3 │ WOLNA │ │ +│ │ 3MB │ 5MB │ 2MB egzamin pyt10 SOI detail +Wyjaśnij: Idea • Strona (Page): blok pamięci wirtualnej (4KB typowo)
• Ramka (Frame): blok pamięci fizycznej (ten sam rozmiar) egzamin pyt10 SOI detail +Wyjaśnij: Translacja adresu ``` +Adres wirtualny (32-bit, strony 4KB): +┌────────────────────────┬──────────────┐ +│ Numer strony (20b) │ Offset (12b) │ +└────────────────────────┴──────────────┘ + │ │ + ↓ │ + Tablica stron │ + │ egzamin pyt10 SOI detail +Wyjaśnij: Wielopoziomowe tablice stron Problem: Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = 4MB per proces!
Rozwiązanie: Hierarchiczna tablica stron egzamin pyt10 SOI detail +Wyjaśnij: TLB (Translation Lookaside Buffer) Problem: Każdy dostęp do pamięci wymaga 2+ odczytów (tablica + dane).
Rozwiązanie: Cache translacji adresów egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady stronicowania | Zalety | Wady | +|--------|------| +| Brak fragmentacji zewnętrznej | Fragmentacja wewnętrzna (ostatnia strona) | +| Prosta alokacja (bitmapa ramek) | Narzut tablicy stron | +| Łatwe współdzielenie (COW) | TLB miss kosztowny | +| Pamięć wirtualna naturalna | Nie odpowiada strukturze programu |
## 4. Segmentacja (Segmentation) egzamin pyt10 SOI detail +Wyjaśnij: Ochrona w segmentacji • R: (Read) - odczyt dozwolony
• W: (Write) - zapis dozwolony
• X: (Execute) - wykonanie dozwolone egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady segmentacji | Zalety | Wady | +|--------|------| +| Odpowiada strukturze programu | Fragmentacja zewnętrzna | +| Naturalna ochrona (per segment) | Segmenty o zmiennej wielkości | +| Łatwe współdzielenie (cały segment) | Kompaktowanie potrzebne | +| Dynamiczny wzrost segmentów | Skomplikowana alokacja |
## 5. Porównanie: Stronicowanie vs Segmentacja egzamin pyt10 SOI detail +Wyjaśnij: Intel x86 (tryb chroniony) flat memory model: wszystkie segmenty pokrywają całą przestrzeń adresową, efektywnie wyłączając segmentację. egzamin pyt10 SOI detail +Wyjaśnij: Zalety hybrydowego podejścia 1. Ochrona z segmentacji (kod vs dane vs stos) +2. Brak fragmentacji zewnętrznej ze stronicowania +3. Pamięć wirtualna ze stronicowania
## 7. Pamięć wirtualna (Virtual Memory) egzamin pyt10 SOI detail +Wyjaśnij: Algorytmy zastępowania stron | Algorytm | Opis | Właściwości | +|----------|------|-------------| +| FIFO | Najstarsza strona | Prosty, anomalia Bélády'ego | +| LRU | Najdawniej używana | Optymalny offline, kosztowny | +| LRU Approximation | Clock, Second Chance | Praktyczny kompromis | +| LFU | Najrzadziej używana | egzamin pyt10 SOI detail +Wyjaśnij: Algorytm Clock (Second Chance) ``` + ┌───┐ + ┌──→│ 1 │──┐ Bit referencji: + │ └───┘ │ 1 = używana ostatnio + │ ↓ 0 = kandydat do usunięcia +┌───┐ ┌───┐ +│ 0 │ │ 1 │ Wskazówka zegara: +└───┘ └───┘ - Jeśli bit=1: zeruj, idź dalej + ↑ │ - Jeśli bit=0: zastąp egzamin pyt10 SOI detail +Scharakteryzować standardy i narzędzia do modelowania procesów biznesowych. Modelowanie procesów biznesowych to graficzne przedstawienie przepływu pracy, działań i decyzji w organizacji. Służy do: +- Dokumentowania procesów +- Analizy i optymalizacji +- Automatyzacji (workflow, BPM) +- Komunikacji między działami egzamin pyt11 WSYZ main +Wyjaśnij: Przegląd standardów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ STANDARDY MODELOWANIA PROCESÓW │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ BPMN │ UML │ EPC │ +│ Business │ Act
## 2. BPMN (Business Process Model and Notation) egzamin pyt11 WSYZ detail +Wyjaśnij: Podstawowe elementy BPMN #### Flow Objects (Obiekty przepływu)
┌─────────────────────────────────────────────────────────────────┐ +│ CZYNNOŚCI (Activities) │ +│ │ +│ ┌─────────┐ │ +│ │ │ Zadanie ( egzamin pyt11 WSYZ detail +Wyjaśnij: Elementy Activity Diagrams ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WĘZŁY AKCJI │ +│ │ +│ ╭─────────╮ │ +│ │ Akcja │ Actio
┌─────────────────────────────────────────────────────────────────┐ +│ WĘZŁY STERUJĄCE │ +│ │ +│ ● Initial Node (początek) │ +│ ◉ Activity Final (kon egzamin pyt11 WSYZ detail +Wyjaśnij: Porównanie BPMN vs UML Activity | Cecha | BPMN | UML Activity | +|-------|------|--------------| +| Cel | Procesy biznesowe | Logika oprogramowania | +| Odbiorcy | Analitycy, biznes | Programiści, architekci | +| Swimlanes | Pool/Lane | Partition | +| Zdarzenia | Bogate (timer, message...) | Ograniczone | +| **Automatyza
## 4. EPC (Event-driven Process Chain) egzamin pyt11 WSYZ detail +Wyjaśnij: Elementy EPC ``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ ⬡ Zdarzenie (Event) - pasywne, opisuje stan │ +│ np. "Zamówienie otrzymane" │ +│ egzamin pyt11 WSYZ detail +Wyjaśnij: Reguły EPC 1. Start i koniec: Zdarzenie +2. Naprzemienność: Zdarzenie → Funkcja → Zdarzenie +3. Łączniki: Między zdarzeniami a funkcjami
⬡ Zamówienie otrzymane + │ + ↓ + ▭ Sprawdź dostępność + │ + ↓ + XOR + / \ + ↓ ↓ +⬡ Produkt ⬡ Produkt + dostępny niedostępny + │ │ + ↓ ↓ +▭ Przygotuj ▭ Złóż + wysyłkę zamówienie + │ u dostawcy + ↓ egzamin pyt11 WSYZ detail +Wyjaśnij: Rodzina IDEF | Standard | Nazwa | Zastosowanie | +|----------|-------|--------------| +| IDEF0 | Function Modeling | Hierarchia funkcji | +| IDEF1 | Information Modeling | Struktura danych | +| IDEF1X | Data Modeling | Bazy danych (ERD) | +| IDEF3 | Process Description | Przepływ procesów | +| **IDEF4* egzamin pyt11 WSYZ detail +Wyjaśnij: IDEF0 - Modelowanie funkcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ KONTROLA (C) │ +│ │ │ +│ ↓ │ +│ WEJŚCIE (I) ────→ ┌ egzamin pyt11 WSYZ detail +Wyjaśnij: Dekompozycja IDEF0 ``` +Poziom 0: A0 - Całość procesu + │ + ├── A1 - Podfunkcja 1 + │ ├── A11 + │ ├── A12 + │ └── A13 + │ + ├── A2 - Podfunkcja 2 + │ + └── A3 - Podfunkcja 3 +``` egzamin pyt11 WSYZ detail +Wyjaśnij: Flowcharts (Schematy blokowe) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Symbole: │ +│ │ +│ ⬭ Terminal (Start/End) │ +│ ▭ Process (Operac
Zalety: Proste, uniwersalne, znane +Wady: Brak standaryzacji, niewystarczające dla złożonych procesów egzamin pyt11 WSYZ detail +Wyjaśnij: Value Stream Map (VSM) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Lean Manufacturing │ +│ │ +│ Supplier ──→ [Magazyn] ──→ [Produkcja] ──→ [QC] ──→ Customer │ +│ Inv: 5d egzamin pyt11 WSYZ detail +Wyjaśnij: Petri Nets (Sieci Petriego) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Formalizm matematyczny dla współbieżności │ +│ │ +│ ○ Place (Miejsce) - stan │ +│ ▭ Transition (Prz egzamin pyt11 WSYZ detail +Wyjaśnij: Przegląd narzędzi | Narzędzie | Standardy | Typ | Cena | +|-----------|-----------|-----|------| +| Bizagi Modeler | BPMN | Dedykowane | Free/Paid | +| Camunda Modeler | BPMN, DMN | Open Source | Free | +| Signavio | BPMN, EPC | Cloud | Paid | +| ARIS | EPC, BPMN | Enterprise | Paid | +| **Enterprise Archit egzamin pyt11 WSYZ detail +Wyjaśnij: Funkcjonalności narzędzi | Funkcja | Podstawowe | Zaawansowane | +|---------|------------|--------------| +| Modelowanie graficzne | ✓ | ✓ | +| Walidacja modelu | ✗ | ✓ | +| Symulacja | ✗ | ✓ | +| Wykonywanie (engine) | ✗ | ✓ | +| Eksport (XML, PDF) | ✓ | ✓ | +| Współpraca | ✗/Cloud | ✓ | +| Integracja z IT | ✗ | ✓ | egzamin pyt11 WSYZ detail +Przedstawić sieciowe modele optymalizacji stosowane w systemach zarządzania. Omówić ich właściwości. • Węzły: = punkty decyzyjne, lokalizacje, zdarzenia
• Krawędzie: = połączenia, przepływy, zależności
• Wagi: = koszty, czasy, przepustowości egzamin pyt12 WSYZ main +Wyjaśnij: Zastosowania w zarządzaniu - Optymalizacja tras dostaw +- Planowanie logistyki +- Routing w sieciach telekomunikacyjnych
## 2. Problem maksymalnego przepływu (Max Flow) egzamin pyt12 WSYZ detail +Wyjaśnij: Zastosowania - Planowanie produkcji (przepustowość linii) +- Zarządzanie siecią dystrybucji +- Przydział zasobów
## 3. Problem minimalnego kosztu przepływu (Min Cost Flow) egzamin pyt12 WSYZ detail +Wyjaśnij: Właściwości • NP-trudny: brak algorytmu wielomianowego
NP-trudny: brak algorytmu wielomianowego egzamin pyt12 WSYZ detail +Wyjaśnij: CPM (Critical Path Method) ``` + ┌──B(3)──┐ + ╱ ╲ +A(2)──┤ ├──E(2)──F(1) + ╲ ╱ + └──C(4)──D(1)
Ścieżka krytyczna: A→C→D→E→F (czas: 2+4+1+2+1=10) +``` egzamin pyt12 WSYZ detail +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. prywatny stan: Komunikuje się wyłącznie przez
wiadomości: Może tworzyć nowych aktorów egzamin pyt13 AASD main +Wyjaśnij: Definicje fundamentalne prywatny stan: Komunikuje się wyłącznie przez
wiadomości: Może tworzyć nowych aktorów egzamin pyt13 AASD detail +Wyjaśnij: Agent vs Aktor | Cecha | Agent | Aktor | +|-------|-------|-------| +| Cel | Inteligentne zachowanie | Współbieżność | +| Stan | Beliefs, Goals, Intentions | Prywatny, izolowany | +| Komunikacja | ACL (semantyka) | Wiadomości (asynchroniczne) | +| Autonomia | Wysoka (decyzje) | Średnia (reaktywność) | +| egzamin pyt13 AASD detail +Wyjaśnij: Architektury agentów #### BDI (Belief-Desire-Intention)
#### Subsumption Architecture (Brooks) egzamin pyt13 AASD detail +Wyjaśnij: Standardy komunikacji agentów #### FIPA (Foundation for Intelligent Physical Agents)
FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD detail +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. ### 1. Algorytmy negocjacji i aukcji
#### Contract Net Protocol (CNP) egzamin pyt14 AASD main +Wyjaśnij: Algorytmy negocjacji i aukcji #### Contract Net Protocol (CNP)
Manager Contractors + │ ┌───┬───┬───┐ + │────── cfp ──────────→│ A │ B │ C │ + │ └───┴───┴───┘ + │←───── propose ─────── │ │ + │←───── propose ──────────── │ + │←───── propose ── egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy konsensusu #### Raft (dla systemów aktorowych)
Leader Election: +1. Follower timeout → staje się Candidate +2. Candidate wysyła RequestVote do wszystkich +3. Większość głosów → nowy Leader +4. Leader wysyła heartbeats egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy koordynacji #### Distributed Mutual Exclusion
Algorytm Ricarta-Agrawali: +``` +Wejście do sekcji krytycznej: +1. Wyślij REQUEST(timestamp) do wszystkich +2. Czekaj na REPLY od wszystkich +3. Wejdź do sekcji krytycznej egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy uczenia wieloagentowego #### Q-Learning (Independent Learners)
Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)] egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy dla aktorów #### Supervision Strategies (Akka)
// All-for-One: restart wszystkich dzieci +override val supervisorStrategy = + AllForOneStrategy() { + case _: Exception => Restart + } +``` egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy planowania (BDI) Plans: + plan1: walk(X,Y) :- distance(X,Y) < 1km + plan2: drive(X,Y) :- have(car), distance(X,Y) >= 1km + plan3: take_bus(X,Y) :- bus_available(X,Y)
Wybór planu na podstawie: +- Kontekstu (beliefs) +- Preferencji +- Kosztu +``` egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy formowania koalicji φᵢ = Σ [|S|!(n-|S|-1)!/n!] × [v(S∪{i}) - v(S)]
Gdzie: +- S = podzbiór agentów bez i +- v(S) = wartość koalicji S +- n = liczba agentów egzamin pyt14 AASD detail +Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury. Domeny TOGAF:: Business Architecture egzamin pyt15 AIS main +Wyjaśnij: Cele modelowania architektury | Cel | Opis | +|-----|------| +| Komunikacja | Wspólny język dla stakeholderów | +| Dokumentacja | Zapis decyzji architektonicznych | +| Analiza | Weryfikacja atrybutów jakościowych | +| Planowanie | Roadmapa rozwoju systemu | +| Zarządzanie złożonością | Abstrakcja, dekompozycja | egzamin pyt15 AIS detail +Wyjaśnij: Frameworki architektoniczne Domeny TOGAF:: Business Architecture egzamin pyt15 AIS detail +Wyjaśnij: Notacje i języki modelowania #### UML (Unified Modeling Language)
Zasada: Zoom in/out między poziomami +``` egzamin pyt15 AIS detail +Wyjaśnij: ADR (Architecture Decision Records) ```markdown +# ADR-001: Wybór bazy danych
## Context +System wymaga przechowywania danych użytkowników... egzamin pyt15 AIS detail +Wyjaśnij: Metody analizy architektury #### ATAM (Architecture Tradeoff Analysis Method)
#### Quality Attributes (ISO 25010) egzamin pyt15 AIS detail +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne. • Nazwa: identyfikator
• Kontekst: kiedy stosować
• Problem: co rozwiązuje
• Rozwiązanie: struktura i zachowanie
• Konsekwencje: trade-offs egzamin pyt16 AIS main +Wyjaśnij: Cel wzorców architektonicznych | Cel | Opis | +|-----|------| +| Reużywalność | Sprawdzone rozwiązania typowych problemów | +| Komunikacja | Wspólne słownictwo ("używamy MVC") | +| Dokumentacja | Zapis wiedzy architektonicznej | +| Jakość | Adresowanie atrybutów jakościowych | +| Edukacja | Nauka z doświadczeń innyc egzamin pyt16 AIS detail +Wyjaśnij: Jak powstają wzorce • Nazwa: identyfikator
• Kontekst: kiedy stosować
• Problem: co rozwiązuje
• Rozwiązanie: struktura i zachowanie
• Konsekwencje: trade-offs egzamin pyt16 AIS detail +Wyjaśnij: Katalogowanie wzorców | Katalog | Zakres | Przykłady | +|---------|--------|-----------| +| POSA (Pattern-Oriented Software Architecture) | Architektura | Layers, Pipes&Filters | +| GoF (Gang of Four) | Projektowe | Factory, Observer | +| EIP (Enterprise Integration Patterns) | Integracja | Message Router, Aggreg egzamin pyt16 AIS detail +Wyjaśnij: Porównanie wzorców | Wzorzec | Skalowalność | Złożoność | Use Case | +|---------|--------------|-----------|----------| +| Monolith | Niska | Niska | MVP, małe zespoły | +| Layered | Średnia | Niska | Enterprise CRUD | +| Microservices | Wysoka | Wysoka | Duże systemy | +| Event-Driven | Wysoka | Średnia | egzamin pyt16 AIS detail +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. ### 1. Optymalizacja bez ograniczeń
#### Problem +$$\min_{x \in \mathbb{R}^n} f(x)$$ egzamin pyt17 AMO main +Wyjaśnij: Optymalizacja bez ograniczeń #### Problem +$$\min_{x \in \mathbb{R}^n} f(x)$$
#### Warunki konieczne (I rzędu) +Jeśli $x^$ jest minimum lokalnym i $f$ jest różniczkowalna: +$$\nabla f(x^) = 0$$ egzamin pyt17 AMO detail +Wyjaśnij: Optymalizacja z ograniczeniami #### Problem ogólny +$$\min_{x} f(x)$$ +$$\text{s.t. } g_i(x) \leq 0, \quad i = 1, \ldots, m$$ +$$\quad\quad h_j(x) = 0, \quad j = 1, \ldots, p$$
#### Lagrangian +$$L(x, \lambda, \mu) = f(x) + \sum_{i=1}^{m} \lambda_i g_i(x) + \sum_{j=1}^{p} \mu_j h_j(x)$$ egzamin pyt17 AMO detail +Wyjaśnij: Warunki KKT (Karush-Kuhn-Tucker) Jeśli $x^*$ jest minimum i spełnione są warunki regularności:
1. Stacjonarność: +$$\nabla_x L(x^, \lambda^, \mu^*) = 0$$ egzamin pyt17 AMO detail +Wyjaśnij: Warunki regularności (Constraint Qualification) Warunki zapewniające, że KKT są konieczne:
LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne egzamin pyt17 AMO detail +Wyjaśnij: Warunki dostateczne II rzędu Jeśli spełnione KKT i dla hesjanu Lagrangianu: +$$d^T \nabla_{xx}^2 L(x^, \lambda^, \mu^*) d > 0$$
dla wszystkich $d \neq 0$ spełniających: +- $\nabla g_i(x^)^T d = 0$ dla aktywnych $g_i$ +- $\nabla h_j(x^)^T d = 0$ dla wszystkich $h_j$ egzamin pyt17 AMO detail +Wyjaśnij: Metody optymalizacji nieliniowej #### Metody gradientowe (bez ograniczeń)
Newton: +x_{k+1} = x_k - [∇²f(x_k)]^{-1} ∇f(x_k) +``` egzamin pyt17 AMO detail +Wyjaśnij: Porównanie metod | Metoda | Ograniczenia | Złożoność iter. | Zbieżność | +|--------|--------------|-----------------|-----------| +| Gradient | Bez | O(n) | Liniowa | +| Newton | Bez | O(n³) | Kwadratowa | +| BFGS | Bez | O(n²) | Superlinearna | +| SQP | Z | O(n³) per QP | Superlinearna | +| **Interior Poi egzamin pyt17 AMO detail +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. ### 1. Programowanie liniowe (LP)
#### Postać standardowa +$$\min c^T x$$ +$$\text{s.t. } Ax = b, \quad x \geq 0$$ egzamin pyt18 AMO main +Wyjaśnij: Programowanie liniowe (LP) #### Postać standardowa +$$\min c^T x$$ +$$\text{s.t. } Ax = b, \quad x \geq 0$$
c^T x = const + ↘ + ●───────● + /│ /│ + / │ / │ Wielościan dopuszczalny + ●──┼────● │ + │ ●────┼──● + │ / │ / + │/ │/ + ●───────● ← optimum (wierzchołek) +``` egzamin pyt18 AMO detail +Wyjaśnij: Programowanie kwadratowe (QP) #### Postać ogólna +$$\min \frac{1}{2} x^T Q x + c^T x$$ +$$\text{s.t. } Ax \leq b, \quad Ex = d$$
Gdzie Q jest macierzą symetryczną. egzamin pyt18 AMO detail +Wyjaśnij: Metody rozwiązywania QP 1. Zgadnij zbiór aktywnych ograniczeń W +2. Rozwiąż QP z ograniczeniami W jako równości +3. Sprawdź: + - Czy rozwiązanie dopuszczalne? (jeśli nie: usuń z W) + - Czy mnożniki ≥ 0? (jeśli nie: dodaj do W) +4. Powtarzaj do zbieżności +```
Zalety: Dokładne rozwiązanie, warm start +Wady: Liczba iteracji zależy od kombinatoryki egzamin pyt18 AMO detail +Wyjaśnij: Przypadki szczególne #### Least Squares (najmniejsze kwadraty) +$$\min \|Ax - b\|_2^2 = \min x^T A^T A x - 2b^T A x + b^T b$$
Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO detail +Wyjaśnij: Narzędzia | Narzędzie | Typ | Metody | +|-----------|-----|--------| +| CPLEX | Komercyjny | Simplex, Barrier, QP | +| Gurobi | Komercyjny | Simplex, Barrier, QP | +| GLPK | Open source | Simplex | +| OSQP | Open source | ADMM dla QP | +| CVXPY | Python | Interfejs do solverów | egzamin pyt18 AMO detail +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). • Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę
• Ekstrakcja informacji fonetycznej: Usunięcie informacji mówcy (częściowo)
• Reprezentacja kompaktowa: dla modeli (HMM, DNN)
• Dźwięczne:: pobudzenie okresowe (struny głosowe)
• Bezdźwięczne:: pobudzenie szumowe egzamin pyt19 EASAR main +Wyjaśnij: Cel parametryzacji mowy • Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę
• Ekstrakcja informacji fonetycznej: Usunięcie informacji mówcy (częściowo)
• Reprezentacja kompaktowa: dla modeli (HMM, DNN) egzamin pyt19 EASAR detail +Wyjaśnij: MFCC (Mel-Frequency Cepstral Coefficients) mel(f) = 2595 · log₁₀(1 + f/700)
Hz: 0 500 1000 2000 4000 8000 +Mel: 0 607 1000 1500 2146 2840 egzamin pyt19 EASAR detail +Wyjaśnij: LPC (Linear Predictive Coding) • Dźwięczne:: pobudzenie okresowe (struny głosowe)
• Bezdźwięczne:: pobudzenie szumowe egzamin pyt19 EASAR detail +Wyjaśnij: Porównanie MFCC vs LPC | Cecha | MFCC | LPC | +|-------|------|-----| +| Podstawa | Percepcja słuchowa | Model produkcji mowy | +| Filtracja | Bank filtrów Mel | Model all-pole | +| Wymiarowość | 12-13 + delty | 10-20 | +| Zastosowanie | Rozpoznawanie mowy | Kodowanie, synteza | +| Korelacja | Niska (DCT dek egzamin pyt19 EASAR detail +Wyjaśnij: Rozszerzenia #### PLP (Perceptual Linear Prediction) +Łączy LPC z percepcją słuchową: +- Filtracja w skali Bark +- Krzywa równej głośności +- Kompresja intensity-loudness
#### Filter Banks (dla DNN) +Nowoczesne podejście: +- Log Mel filterbanks (bez DCT) +- 40-80 filtrów +- DNN uczy się własnych cech egzamin pyt19 EASAR detail +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. ### 1. System rozpoznawania mowy - architektura
### 2. HMM (Hidden Markov Model) - klasyczne podejście egzamin pyt20 EASAR main +Wyjaśnij: System rozpoznawania mowy - architektura ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Sygnał audio │ +│ ↓ │ +│ [Ekstrakcja cech] ──→ MFCC/Filterbanks │ +│ ↓ egzamin pyt20 EASAR detail +Wyjaśnij: HMM (Hidden Markov Model) - klasyczne podejście Każdy stan emituje obserwacje (MFCC) według rozkładu GMM: +b_j(o) = Σ_m c_{jm} N(o; μ_{jm}, Σ_{jm}) +```
α_t(j) = max_{i} [α_{t-1}(i) · a_{ij}] · b_j(o_t) egzamin pyt20 EASAR detail +Wyjaśnij: Deep Learning w rozpoznawaniu mowy Attention-based (Seq2Seq): +┌──────────────────────────────────────────────────────────────┐ +│ Audio → [Encoder] → [Attention] → [Decoder] → Tekst │ +│ ↓ │ +│ Wyrównanie uczone │ +│
Audio waveform + ↓ +[CNN Feature Encoder] + ↓ +[Transformer Encoder] × N + ↓ +[CTC / Attention Decoder] + ↓ +Tekst egzamin pyt20 EASAR detail +Wyjaśnij: Porównanie HMM vs DNN | Aspekt | GMM-HMM | DNN-HMM | End-to-End | +|--------|---------|---------|------------| +| Model akustyczny | GMM | DNN | DNN | +| Model czasowy | HMM | HMM | CTC/Attention | +| Wyrównanie | Viterbi | Viterbi | Uczone/CTC | +| Trening | EM (Baum-Welch) | Backprop | Backprop | +| **Interpr egzamin pyt20 EASAR detail +Wyjaśnij: Ewolucja wydajności ``` +WER na Switchboard (telefon):
Rok Model WER +2010 GMM-HMM ~18% +2012 DNN-HMM ~12% +2015 LSTM-HMM ~8% +2017 LAS (Seq2Seq) ~6% +2020 Conformer ~4% +2023 Whisper Large ~3% + Poziom ludzki ~4% +``` egzamin pyt20 EASAR detail +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? • Percepcji: poprzez sensory
• Działania: poprzez efektory
• Interakcji: ze środowiskiem egzamin pyt21 ERPM main +Wyjaśnij: Agent upostaciowiony (Embodied Agent) • Percepcji: poprzez sensory
• Działania: poprzez efektory
• Interakcji: ze środowiskiem egzamin pyt21 ERPM detail +Wyjaśnij: Specyfikacja sterownika robota #### Architektura agentowa sterownika egzamin pyt21 ERPM detail +Wyjaśnij: Formalny model agenta Formalnie: + see: E → P (funkcja percepcji) + action: P* → A (funkcja decyzyjna) + next: E × A → E (funkcja przejścia środowiska) +```
#### Specyfikacja w logice temporalnej egzamin pyt21 ERPM detail +Wyjaśnij: Zastosowanie w ROS (Robot Operating System) [Selector ?] + / | \ + / | \ + [Seq→] [Seq→] [Idle] + / \ | + / \ | +[Check] [Pick] [Navigate]
Węzły: +- Sequence (→): wykonaj wszystkie po kolei +- Selector (?): wykonaj pierwszy sukces +- Action: atomowa akcja +- Condition: sprawdzenie warunku +``` egzamin pyt21 ERPM detail +Wyjaśnij: Hybrydowa architektura 3T ``` +┌─────────────────────────────────────────────────────────────────┐ +│ THREE-TIER (3T) Architecture │ +│ │ +│ ┌─────────────────────────────────────────────────────────┐ │ +│ │ PLANNER (deliberati egzamin pyt21 ERPM detail +Wyjaśnij: Korzyści podejścia agentowego | Korzyść | Opis | +|---------|------| +| Modularność | Rozdzielenie percepcji, decyzji, akcji | +| Abstrakcja | Ukrycie szczegółów sprzętu | +| Autonomia | Robot sam decyduje o działaniach | +| Reużywalność | Zachowania przenośne między platformami | +| Weryfikowalność | Formalna spec egzamin pyt21 ERPM detail +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. ### 1. Klasyfikacja języków programowania robotów
### 2. Klasyfikacja wg metody programowania egzamin pyt22 ERPM main +Wyjaśnij: Klasyfikacja języków programowania robotów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ JĘZYKI PROGRAMOWANIA ROBOTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ POZIOM ABSTRAKCJI: │ +│ egzamin pyt22 ERPM detail +Wyjaśnij: Klasyfikacja wg metody programowania | Metoda | Opis | Przykłady | +|--------|------|-----------| +| Online (Teach-in) | Programowanie przez demonstrację | Pendant, prowadzenie ręczne | +| Offline | Programowanie bez robota | Symulacja, CAD/CAM | +| Tekstowe | Kod źródłowy | RAPID, KRL, Karel | +| Graficzne | Bloki, flowchar egzamin pyt22 ERPM detail +Wyjaśnij: Języki producentów robotów przemysłowych ! MoveJ = ruch w przestrzeni złączy (Joint) +! MoveL = ruch liniowy (Linear) +! v500 = prędkość 500 mm/s +! fine/z50 = dokładność (fine = dokładnie) +```
; PTP = Point-to-Point (ruch złączowy) +; LIN = ruch liniowy +; CIRC = ruch kołowy +``` egzamin pyt22 ERPM detail +Wyjaśnij: Porównanie języków producentów | Cecha | RAPID (ABB) | KRL (KUKA) | Karel (FANUC) | +|-------|-------------|------------|---------------| +| Paradygmat | Proceduralny | Proceduralny | Proceduralny | +| Typy ruchów | MoveJ, MoveL, MoveC | PTP, LIN, CIRC | MOVE TO | +| Zmienne | VAR, PERS, CONST | DECL | VAR | +| I/O | S egzamin pyt22 ERPM detail +Wyjaśnij: Języki uniwersalne i frameworki #### ROS (Robot Operating System)
rospy.init_node('robot_controller') +pub = rospy.Publisher('/cmd_vel', Twist, queue_size=10) egzamin pyt22 ERPM detail +Wyjaśnij: Języki graficzne | Narzędzie | Producent | Opis | +|-----------|-----------|------| +| RobotStudio | ABB | RAPID + symulacja 3D | +| KUKA.Sim | KUKA | KRL + symulacja | +| ROBOGUIDE | FANUC | Karel + symulacja | +| Blockly | Google | Programowanie wizualne (edukacja) | +| Scratch for Robots | MIT | Edu egzamin pyt22 ERPM detail +Wyjaśnij: Klasyfikacja wg poziomu abstrakcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Task-Level: │ +│ "Złóż produkt X z części A, B, C" │ +│ → Planowanie automatyczne, AI │ +│ Przykłady: STRIPS, PDD egzamin pyt22 ERPM detail +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. ### 1. Problem czasu w systemach rozproszonych
Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji. egzamin pyt23 ERSMS main +Wyjaśnij: Problem czasu w systemach rozproszonych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Brak globalnego zegara: │ +│ │ +│ Node A: ──●────────●────────●──→ czas lokalny A │ +│ e1 e2
Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji. egzamin pyt23 ERSMS detail +Wyjaśnij: Zegar Lamporta (Scalar Clock) 1. Przed każdym zdarzeniem lokalnym: + C_i := C_i + 1
2. Wysyłając wiadomość m: + C_i := C_i + 1 + Dołącz timestamp(m) = C_i egzamin pyt23 ERSMS detail +Wyjaśnij: Zegary wektorowe (Vector Clocks) 1. Przed każdym zdarzeniem lokalnym: + V_i[i] := V_i[i] + 1
2. Wysyłając wiadomość m: + V_i[i] := V_i[i] + 1 + Dołącz timestamp(m) = V_i egzamin pyt23 ERSMS detail +Wyjaśnij: Porównanie | Cecha | Lamport | Vector Clock | +|-------|---------|--------------| +| Rozmiar | O(1) | O(N) | +| a → b ⟹ C(a) < C(b) | ✅ | ✅ | +| C(a) < C(b) ⟹ a → b | ❌ | ✅ | +| Wykrycie współbieżności | ❌ | ✅ | +| Zastosowanie | Uporządkowanie | Wykrywanie konfliktów | egzamin pyt23 ERSMS detail +Wyjaśnij: Warianty i rozszerzenia | Wariant | Opis | +|---------|------| +| Interval Tree Clocks | Dynamiczna liczba procesów | +| Bloom Clocks | Probabilistyczne, kompaktowe | +| Hybrid Logical Clocks | Lamport + czas fizyczny | +| Matrix Clocks | Wiedza o wiedzy innych | egzamin pyt23 ERSMS detail +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. ### 1. Problem spójności w systemach rozproszonych
### 2. Spektrum modeli spójności egzamin pyt24 ERSMS main +Wyjaśnij: Problem spójności w systemach rozproszonych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Repliki danych: │ +│ │ +│ Client A Client B │ +│ │ write(x=1) egzamin pyt24 ERSMS detail +Wyjaśnij: Spektrum modeli spójności ``` +Silne ←─────────────────────────────────────────→ Słabe + +Linearizability Eventual + │ Consistency + ↓ ↑ +Sequential egzamin pyt24 ERSMS detail +Wyjaśnij: Silne modele spójności #### Linearizability (Linearyzacja)
Timeline: +Client A: ─────[write(x=1)]─────────────────────→ +Client B: ───────────[read(x)]──────────────────→ + ↓ + Musi zwrócić 1! egzamin pyt24 ERSMS detail +Wyjaśnij: Słabe modele spójności Timeline: +write(x=1) @ Replica A + ↓ (propagacja) + ↓ + ↓ ... czas ... + ↓ +read(x)=1 @ Replica B (eventually)
Gwarancje: +✅ Dostępność (AP w CAP) +✅ Niska latencja +❌ Stare dane przez jakiś czas +❌ Możliwe konflikty +``` egzamin pyt24 ERSMS detail +Wyjaśnij: CAP Theorem ``` +┌─────────────────────────────────────────────────────────────────┐ +│ CAP Theorem │ +│ │ +│ Consistency (C) │ +│ egzamin pyt24 ERSMS detail +Wyjaśnij: Porównanie modeli | Model | Gwarancje | Wydajność | Przykłady | +|-------|-----------|-----------|-----------| +| Linearizable | Najsilniejsze | Niska | Spanner, CockroachDB | +| Sequential | Silne | Średnia | Zookeeper | +| Causal | Przyczynowe | Dobra | COPS, MongoDB | +| Session | Per-sesja | Dobra | Dy egzamin pyt24 ERSMS detail +Wyjaśnij: Strategie rozwiązywania konfliktów #### Last-Writer-Wins (LWW) +``` +Konflikt: write(x=1) || write(x=2) +Rozwiązanie: Większy timestamp wygrywa +Problem: Utrata danych! +```
#### Multi-Value (Siblings) +``` +Konflikt: write(x=1) || write(x=2) +Rozwiązanie: Przechowaj oba: x=[1,2] +Klient rozwiązuje przy odczycie (Riak) +``` egzamin pyt24 ERSMS detail +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. ### 1. Definicja MIP (Mixed Integer Programming)
min c^T x +s.t. Ax ≤ b + x_i ∈ Z dla i ∈ I (zmienne całkowite) + x_j ∈ R dla j ∈ J (zmienne ciągłe) + x ≥ 0 egzamin pyt25 MOD main +Wyjaśnij: Definicja MIP (Mixed Integer Programming) ``` +Programowanie całkowitoliczbowe:
min c^T x +s.t. Ax ≤ b + x_i ∈ Z dla i ∈ I (zmienne całkowite) + x_j ∈ R dla j ∈ J (zmienne ciągłe) + x ≥ 0 egzamin pyt25 MOD detail +Wyjaśnij: Metody rozwiązywania | Metoda | Typ | Gwarancja optimum | +|--------|-----|-------------------| +| Branch and Bound | Dokładna | ✅ | +| Branch and Cut | Dokładna | ✅ | +| Branch and Price | Dokładna | ✅ | +| Cutting Planes | Dokładna | ✅ | +| Heurystyki | Przybliżona | ❌ | +| Metaheurystyki | Przybliżon egzamin pyt25 MOD detail +Wyjaśnij: Branch and Bound (B&B) - metoda dokładna LP relaxation + x* = 2.7 + /\ + / \ + x ≤ 2 x ≥ 3 + / \ + LP: z=10 LP: z=8 + / \ + (dalej) (przycinaj jeśli + najlepsze ≥ 8) +```
#### Przykład: Max 3x + 2y, x + y ≤ 4, x,y ∈ Z+ egzamin pyt25 MOD detail +Wyjaśnij: Czynniki wpływające na efektywność B&B | Czynnik | Wpływ | Strategie | +|---------|-------|-----------| +| Jakość relaksacji | Lepsza → mniej węzłów | Silne formulacje, cutting planes | +| Wybór zmiennej do branch | Balans drzewa | Most fractional, strong branching | +| Wybór węzła | DFS vs BFS | Best-first (best bound) | +| **Prz
#### Strategie wyboru zmiennej (branching) egzamin pyt25 MOD detail +Wyjaśnij: Ulepszenia: Branch and Cut ``` +Branch and Bound + Cutting Planes:
W każdym węźle: +1. Rozwiąż LP relaksację +2. Jeśli rozwiązanie niecałkowite: + - Generuj cięcia (Gomory, Cover, Clique...) + - Dodaj cięcia do LP + - Powtórz do limitu +3. Jeśli nadal niecałkowite → branch egzamin pyt25 MOD detail +Scharakteryzować informatyczne narzędzia optymalizacji dyskretnej. Jakie są warunki i wymagania, jakie możliwości oraz trudności wiążą się ze stosowaniem gotowych narzędzi. ### Porównanie wydajności (benchmark)
CPLEX ████████████████████████████ 100% +Gurobi ███████████████████████████ 98% +SCIP ████████████████ 60% +CBC ████████████ 45% +GLPK ████████ 30% +``` egzamin pyt26 MOD main +Wyjaśnij: Kategorie narzędzi ``` +┌─────────────────────────────────────────────────────────────────┐ +│ NARZĘDZIA OPTYMALIZACJI DYSKRETNEJ │ +├─────────────────────────────────────────────────────────────────┤ +│ SOLVERY MIP │ SOLVERY CP │ METAHEURYSTYKI │ +│ (Mixed Integer │ egzamin pyt26 MOD detail +Wyjaśnij: Solvery MIP | Solver | Licencja | Cechy | +|--------|----------|-------| +| CPLEX | Komercyjny (IBM) | Najszybszy dla dużych MIP | +| Gurobi | Komercyjny (academic free) | Bardzo szybki, dobry API | +| SCIP | Open source (ZIB) | Framework extensible | +| CBC | Open source (COIN-OR) | Dobry darmowy so egzamin pyt26 MOD detail +Wyjaśnij: Porównanie wydajności (benchmark) ``` +Typowe czasy dla problemów MIPLIB (średnie):
CPLEX ████████████████████████████ 100% +Gurobi ███████████████████████████ 98% +SCIP ████████████████ 60% +CBC ████████████ 45% +GLPK ████████ 30% +``` egzamin pyt26 MOD detail +Wyjaśnij: Solvery Constraint Programming | Solver | Język | Cechy | +|--------|-------|-------| +| CP-SAT | Python/C++ | Google, bardzo szybki | +| Gecode | C++ | Akademicki, elastyczny | +| Chuffed | MiniZinc | Lazy clause generation | +| OR-Tools | Multi | Google, CP + routing + MIP | egzamin pyt26 MOD detail +Wyjaśnij: Kiedy CP vs MIP? | Aspekt | MIP | CP | +|--------|-----|-----| +| Ograniczenia globalne | Słabo | Świetnie (alldiff, cumulative) | +| Relaksacja | LP (silna) | Słabsza | +| Scheduling | Średnio | Świetnie | +| Kombinatoryczne | Dobrze | Bardzo dobrze | egzamin pyt26 MOD detail +Wyjaśnij: Języki modelowania #### AMPL +```ampl +set PRODUCTS; +param profit{PRODUCTS}; +param capacity;
var produce{PRODUCTS} >= 0 integer; egzamin pyt26 MOD detail +Wyjaśnij: Warunki i wymagania | Wymaganie | Opis | +|-----------|------| +| Licencja | Komercyjne (CPLEX, Gurobi) vs Open source | +| API/Język | Python, C++, Java, Julia | +| Format modelu | MPS, LP, AMPL, własny | +| Pamięć | Duże modele = duże wymagania RAM | +| Wielowątkowość | Parallel B&B, concurrent LP | egzamin pyt26 MOD detail +Wyjaśnij: Typowe wymagania sprzętowe ``` +Mały problem (< 1000 zmiennych): + - RAM: 4 GB + - CPU: dowolny + - Czas: sekundy
Średni problem (1000-100k zmiennych): + - RAM: 16-32 GB + - CPU: multi-core + - Czas: minuty-godziny egzamin pyt26 MOD detail +Wyjaśnij: Możliwości | Możliwość | Opis | +|-----------|------| +| Gwarancja optimum | Metody dokładne (B&B, B&C) | +| Gap tracking | Śledzenie jakości rozwiązania | +| Callbacks | Własne cięcia, heurystyki, lazy constraints | +| Warm start | Start od znanego rozwiązania | +| Tuning | Automatyczne dostraja egzamin pyt26 MOD detail +Wyjaśnij: Trudności | Trudność | Opis | Rozwiązanie | +|----------|------|-------------| +| Czas obliczeń | NP-trudność | Heurystyki, time limit | +| Słaba formulacja | Duży integrality gap | Silniejsze modele, cięcia | +| Symetria | Wiele równoważnych rozw. | Symmetry breaking | +| Numeryka | Błędy zaokrągl egzamin pyt26 MOD detail +Wyjaśnij: Diagnostyka problemów Diagnoza: +1. solver.computeIIS() # znajdź konflikt +2. Sprawdź constraints +3. Poluzuj ograniczenia
Diagnoza: +1. Gap się nie zmniejsza → słaba formulacja +2. Dużo węzłów B&B → symetria +3. LP wolne → presolve, scaling +``` egzamin pyt26 MOD detail +Wyjaśnij: Best practices ``` +┌─────────────────────────────────────────────────────────────────┐ +│ 1. FORMULACJA │ +│ - Unikaj big-M (słaba relaksacja) │ +│ - Używaj wskaźnikowych (indicator constraints) │ +│ - Tight bounds na zmi egzamin pyt26 MOD detail +Dlaczego jakość modelu danych jest krytycznie ważnym czynnikiem jakości projektu informatycznego? Reguła 1:10:100:: Naprawa w fazie projektowania: 1x egzamin pyt27 MODA main +Wyjaśnij: Model danych jako fundament systemu ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ARCHITEKTURA SYSTEMU │ +│ │ +│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ +│ │ UI │ │ egzamin pyt27 MODA detail +Wyjaśnij: Konsekwencje złego modelu danych | Problem | Konsekwencje | +|---------|--------------| +| Redundancja | Anomalie (insert, update, delete), niespójność | +| Brak normalizacji | Duplikacja, trudna aktualizacja | +| Nadmierna normalizacja | Wolne zapytania (wiele JOIN) | +| Złe typy danych | Błędy konwersji, utrata precyzj egzamin pyt27 MODA detail +Wyjaśnij: Wpływ na różne aspekty projektu Dobry model: +SELECT * FROM orders o +JOIN customers c ON o.customer_id = c.id -- integer FK +JOIN products p ON o.product_id = p.id +WHERE c.city_id = 1; -- indexed lookup +→ Index scans, szybkie JOIN na integer PK/FK +```
Dobry model: +- Dedykowane tabele i kolumny z opisowymi nazwami +- ENUM lub tabela słownikowa dla statusów +- Komentarze w schemacie, dokumentacja ERD +``` egzamin pyt27 MODA detail +Wyjaśnij: Koszty naprawy złego modelu Reguła 1:10:100:: Naprawa w fazie projektowania: 1x egzamin pyt27 MODA detail +Wyjaśnij: Cechy dobrego modelu danych | Cecha | Opis | +|-------|------| +| Poprawność | Odzwierciedla dziedzinę biznesową | +| Kompletność | Wszystkie wymagane dane | +| Spójność | Brak sprzeczności, integralność | +| Minimalizm | Brak zbędnej redundancji | +| Elastyczność | Możliwość rozszerzenia | +| Wydajność | Odpo egzamin pyt27 MODA detail +Wyjaśnij: Wpływ na jakość danych (GIGO) ┌──────────────────┐ +│ Złe dane wejść. │ → Zły model → Złe decyzje biznesowe +│ (brak walidacji) │ +└──────────────────┘
Dobry model wymusza jakość: +- NOT NULL gdzie wymagane +- CHECK constraints (age > 0) +- FOREIGN KEY (referential integrity) +- UNIQUE (brak duplikatów) +- Trigger dla złożonej walidacji +``` egzamin pyt27 MODA detail +Wyjaśnij: Model danych a architektura aplikacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Model danych wpływa na: │ +│ │ +│ • ORM mapping (Entity classes) │ +│ • API endpoints (REST r egzamin pyt27 MODA detail +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. ### 2. Model konceptualny (Conceptual Data Model)
#### Cel +- Zrozumienie dziedziny biznesowej +- Komunikacja z interesariuszami (nietechnicznymi) +- Identyfikacja głównych encji i relacji egzamin pyt28 MODA main +Wyjaśnij: Przegląd faz ewolucji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ FAZY EWOLUCJI MODELU DANYCH │ +│ │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ KONCEPTUALNY │ → │ egzamin pyt28 MODA detail +Wyjaśnij: Model konceptualny (Conceptual Data Model) #### Cel +- Zrozumienie dziedziny biznesowej +- Komunikacja z interesariuszami (nietechnicznymi) +- Identyfikacja głównych encji i relacji
┌──────────┐ ┌──────────┐ + │ KLIENT │ składa │ZAMÓWIENIE│ + │ │ 1────M │ │ + └──────────┘ └──────────┘ + │ + │ zawiera + │ M + │ egzamin pyt28 MODA detail +Wyjaśnij: Model logiczny (Logical Data Model) #### Cel +- Szczegółowa struktura danych +- Normalizacja +- Definicja atrybutów i kluczy +- Niezależność od DBMS
┌────────────────────────┐ ┌────────────────────────┐ +│ KLIENT │ │ ZAMÓWIENIE │ +├────────────────────────┤ ├────────────────────────┤ +│ PK klient_id │───┐ │ PK zamowienie_id │ +│ imie │ │ │ FK klient_id │─ egzamin pyt28 MODA detail +Wyjaśnij: Model fizyczny (Physical Data Model) #### Cel +- Implementacja w konkretnym DBMS +- Optymalizacja wydajności +- Definicja indeksów, partycji, storage
CREATE INDEX idx_klient_email ON klient(email); +CREATE INDEX idx_klient_nazwisko ON klient(nazwisko); egzamin pyt28 MODA detail +Wyjaśnij: Porównanie faz | Aspekt | Konceptualny | Logiczny | Fizyczny | +|--------|--------------|----------|----------| +| Odbiorcy | Biznes | Analitycy, projektanci | DBA, developerzy | +| Abstrakcja | Wysoka | Średnia | Niska | +| DBMS | Niezależny | Niezależny | Specyficzny | +| Typy danych | Brak | Logiczne egzamin pyt28 MODA detail +Wyjaśnij: Transformacje między fazami ``` +┌──────────────────────────────────────────────────────────────────┐ +│ Konceptualny → Logiczny: │ +│ • Encje → Tabele │ +│ • Atrybuty → Kolumny │ +│ • Relacje M:N → Ta egzamin pyt28 MODA detail +Wyjaśnij: Ewolucja w czasie (produkcja) ``` +Wersja 1.0 → 1.1 → 2.0 → ...
Narzędzia migracji: +- Flyway +- Liquibase +- Django migrations +- Alembic (SQLAlchemy) egzamin pyt28 MODA detail +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$
Gdzie: +- $S(n)$ = przyśpieszenie (speedup) +- $p$ = część programu, która może być zrównoleglona (0 ≤ p ≤ 1) +- $n$ = liczba procesorów/rdzeni +- $(1-p)$ = część sekwencyjna egzamin pyt29 PORR main +Wyjaśnij: Prawo Amdahla $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$
Gdzie: +- $S(n)$ = przyśpieszenie (speedup) +- $p$ = część programu, która może być zrównoleglona (0 ≤ p ≤ 1) +- $n$ = liczba procesorów/rdzeni +- $(1-p)$ = część sekwencyjna egzamin pyt29 PORR detail +Wyjaśnij: Wizualizacja ograniczenia ``` +Speedup + ↑ +20 ┤ ........... p=99% + │ ...... + │ ...... +15 ┤ ..... + │ ..... + │ .... ______ p=95% +10 ┤ .... _____/
Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk. egzamin pyt29 PORR detail +Wyjaśnij: Co osłabia ograniczenie Amdahla? #### 3.1 Prawo Gustafsona-Barsisa (Scaled Speedup)
S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n egzamin pyt29 PORR detail +Wyjaśnij: Czynniki zmniejszające rzeczywiste przyśpieszenie ``` +S_real < S_Amdahl ze względu na:
┌─────────────────────────────────────────────────────────────────┐ +│ 1. OVERHEAD SYNCHRONIZACJI │ +│ - Mutex, semaphore contention │ +│ - Barrier wait time │ +│ - Lock granularity (coar egzamin pyt29 PORR detail +Wyjaśnij: Efektywność równoległa $$E(n) = \frac{S(n)}{n} = \frac{1}{n \cdot (1-p) + p}$$
Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR detail +Wyjaśnij: Rozszerzone prawo Amdahla (z overhead) $$S(n) = \frac{1}{(1-p) + \frac{p}{n} + O(n)}$$
Gdzie $O(n)$ = overhead zależny od n (komunikacja, synchronizacja). egzamin pyt29 PORR detail +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych. ### 1. Struktura modelu matematycznego
#### 2.1 Etapy tworzenia modelu egzamin pyt30 MOM main +Wyjaśnij: Struktura modelu matematycznego ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MODEL OPTYMALIZACYJNY │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ min/max f(x) egzamin pyt30 MOM detail +Wyjaśnij: Metody modelowania #### 2.1 Etapy tworzenia modelu egzamin pyt30 MOM detail +Wyjaśnij: Typowe problemy w modelowaniu #### 3.1 Wybór zmiennych decyzyjnych
Przykład - planowanie produkcji: egzamin pyt30 MOM detail +Wyjaśnij: Techniki modelowania McCormick envelopes: +w ≥ x·LB_y + y·LB_x - LB_x·LB_y +w ≥ x·UB_y + y·UB_x - UB_x·UB_y +w ≤ x·LB_y + y·UB_x - LB_y·UB_x +w ≤ x·UB_y + y·LB_x - UB_y·LB_x
Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM detail +Wyjaśnij: Wielokryterialne podejmowanie decyzji ``` +min f₁(x), f₂(x), ..., f_k(x) ← konfliktujące cele
1. WEIGHTED SUM: + min Σ w_i · f_i(x) + Problem: nie znajduje wszystkich Pareto-optymalnych egzamin pyt30 MOM detail +Wyjaśnij: Analiza wrażliwości ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Co się zmieni gdy zmienią się dane wejściowe? │ +├─────────────────────────────────────────────────────────────────┤ +│ Shadow price (dual variable): │ +│ - Ile warta jest jedn egzamin pyt30 MOM detail +Wyjaśnij: Częste błędy | Błąd | Konsekwencja | Rozwiązanie | +|------|--------------|-------------| +| Brak bounds | Unbounded lub słaba relaxation | Zawsze definiuj LB, UB | +| Za duże M | Numerical issues, wolne | Tight big-M | +| Redundantne ograniczenia | Wolniejsze, confusion | Minimalizuj | +| Zła skala | egzamin pyt30 MOM detail +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. ### 1. Klasyfikacja problemów optymalizacyjnych
$$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$ egzamin pyt31 MOM main +Wyjaśnij: Klasyfikacja problemów optymalizacyjnych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ KLASYFIKACJA PROBLEMÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LINIOW egzamin pyt31 MOM detail +Wyjaśnij: Definicje kluczowe $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$
$$f \text{ wypukła} \Leftrightarrow f(\lambda x + (1-\lambda)y) \leq \lambda f(x) + (1-\lambda) f(y)$$ egzamin pyt31 MOM detail +Wyjaśnij: Znaczenie wypukłości #### Własności problemów wypukłych egzamin pyt31 MOM detail +Wyjaśnij: Liniowość vs nieliniowość #### Programowanie liniowe (LP)
$$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$ egzamin pyt31 MOM detail +Wyjaśnij: Testowanie wypukłości 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x
2. Kompozycja: + - Suma wypukłych → wypukła + - max(f, g) gdzie f, g wypukłe → wypukła + - f(Ax+b) gdzie f wypukła → wypukła egzamin pyt31 MOM detail +Wyjaśnij: Problemy niewypukłe #### Strategie dla niewypukłych egzamin pyt31 MOM detail +Wyjaśnij: Dualność ``` +Primal (P): Dual (D): +min f(x) max L(λ, μ) +s.t. g(x) ≤ 0 s.t. λ ≥ 0 + h(x) = 0
Lagrangian: L(x,λ,μ) = f(x) + λᵀg(x) + μᵀh(x) egzamin pyt31 MOM detail +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? #### Synchroniczna vs Asynchroniczna
KOMUNIKACJA ASYNCHRONICZNA: +┌─────────────────────────────────────────────────────────────────┐ +│ Nadawca nie czeka na odbiorcę │ +│ │ +│ Proces A Proces B │ egzamin pyt32 PORR main +Wyjaśnij: Definicje podstawowe #### Synchroniczna vs Asynchroniczna
KOMUNIKACJA ASYNCHRONICZNA: +┌─────────────────────────────────────────────────────────────────┐ +│ Nadawca nie czeka na odbiorcę │ +│ │ +│ Proces A Proces B │ egzamin pyt32 PORR detail +Wyjaśnij: Kombinacje w MPI | Funkcja MPI | Blokująca? | Synchroniczna? | Opis | +|-------------|------------|----------------|------| +| `MPI_Send` | Blokująca | Zależne od impl. | Standard send | +| `MPI_Ssend` | Blokująca | Synchroniczna | Czeka na recv | +| `MPI_Bsend` | Blokująca | Asynchroniczna | Buforowana | +| `MPI_Rsend` egzamin pyt32 PORR detail +Wyjaśnij: Problem zakleszczenia (Deadlock) #### Scenariusz: Algorytm Jacobiego
// Proces 0: // Proces 1: +MPI_Send(to=1, data); MPI_Send(to=0, data); +MPI_Recv(from=1, data); MPI_Recv(from=0, data); egzamin pyt32 PORR detail +Wyjaśnij: Rozwiązania problemu zakleszczenia #### 4.1 Zmiana kolejności operacji
Przebieg: +┌──────────────────┬──────────────────┐ +│ PROCES 0 │ PROCES 1 │ +├──────────────────┼──────────────────┤ +│ Send(to=1) ──────│──→ Recv(from=0) │ +│ [zakończone] │ [zakończone] │ +│ Recv(from=1) ←───│─── Send(to=0) │ +│ [zakończone] │ [zakończone] │ +└───────── egzamin pyt32 PORR detail +Wyjaśnij: Porównanie rozwiązań | Rozwiązanie | Zalety | Wady | +|-------------|--------|------| +| Zmiana kolejności | Proste, brak overhead | Wymaga asymetrii kodu | +| Isend/Irecv | Elastyczne, overlap | Złożoność kodu | +| Sendrecv | Proste, bezpieczne | Mniej elastyczne | +| Bsend | Podobne do standardowego | Wymag egzamin pyt32 PORR detail +Wyjaśnij: Algorytm Jacobiego - pełny przykład ```c +// Iteracyjne rozwiązanie równania Laplace'a +// Grid podzielony między procesy
for (int iter = 0; iter < MAX_ITER; iter++) { + // Wymiana granic z sąsiadami + + // Bezpieczna wymiana z lewym sąsiadem + if (rank > 0) { + MPI_Sendrecv( + &u[1], 1, MPI_DOUBLE, rank-1, 0, // wyślij lewą granicę + &u[0], 1, MPI_DOUBLE, rank-1, 0, // odbi egzamin pyt32 PORR detail +Wyjaśnij: Wzorce komunikacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ RING (pierścień) - każdy z sąsiadami: │ +│ │ +│ ┌───→ P0 ───→ P1 ───→ P2 ───→ P3 ───┐ │ +│ └─────────────────── egzamin pyt32 PORR detail +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model. ### 1. Definicja modelu Pub/Sub
Subskrypcje: + home/living-room/# → wszystko z living-room + home/+/temperature → temperatura ze wszystkich pomieszczeń + home/# → wszystko z home +``` egzamin pyt33 PSD main +Wyjaśnij: Definicja modelu Pub/Sub ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MODEL PUBLISH-SUBSCRIBE │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ PUBLISHERS egzamin pyt33 PSD detail +Wyjaśnij: Typy subskrypcji | Typ | Opis | Przykład | +|-----|------|----------| +| Topic-based | Subskrypcja na nazwany temat | `subscribe("orders")` | +| Content-based | Filtrowanie po zawartości | `price > 100 AND category = "electronics"` | +| Type-based | Na podstawie typu wiadomości | `subscribe(OrderEvent.class) egzamin pyt33 PSD detail +Wyjaśnij: Wildcardy (MQTT) ``` +Hierarchia tematów: + home/living-room/temperature + home/living-room/humidity + home/bedroom/temperature + home/kitchen/temperature
Subskrypcje: + home/living-room/# → wszystko z living-room + home/+/temperature → temperatura ze wszystkich pomieszczeń + home/# → wszystko z home +``` egzamin pyt33 PSD detail +Wyjaśnij: Gwarancje dostarczenia ``` +┌─────────────────────────────────────────────────────────────────┐ +│ QoS (Quality of Service) levels: │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ QoS 0: AT MOST ONCE (f egzamin pyt33 PSD detail +Wyjaśnij: Rozwiązania techniczne // Producer +producer.send(new ProducerRecord<>("orders", key, value));
// Consumer +consumer.subscribe(Arrays.asList("orders")); +while (true) { + ConsumerRecords records = consumer.poll(Duration.ofMillis(100)); + for (ConsumerRecord record : records) { + process(record); + } +} +``` egzamin pyt33 PSD detail +Wyjaśnij: Zalety i wady Pub/Sub ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ZALETY: │ +│ ✓ Luźne powiązanie (decoupling) │ +│ ✓ Skalowalność (dodawanie subskrybentów bez zmian publishera) │ +│ ✓ Asynchroniczność (brak egzamin pyt33 PSD detail +Wyjaśnij: Wzorce użycia ``` +1. EVENT SOURCING: + [Service] ─publish─→ [Kafka] ←─consume─ [Projections] + Wszystkie zmiany jako events, rebuild state z log
2. CQRS (Command Query Responsibility Segregation): + [Write Model] ─events─→ [Event Bus] ─→ [Read Model] + Oddzielne modele do zapisu i odczytu egzamin pyt33 PSD detail +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. ### 1. Charakterystyka danych strumieniowych
#### Event Time vs Processing Time egzamin pyt34 PSD main +Wyjaśnij: Charakterystyka danych strumieniowych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DANE STRUMIENIOWE vs BATCH │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ BATCH: egzamin pyt34 PSD detail +Wyjaśnij: Modele przetwarzania #### Event Time vs Processing Time
Timeline: +Event time: ─●─────●───●─────────●───→ + E1 E2 E3 E4 egzamin pyt34 PSD detail +Wyjaśnij: Platformy Stream Processing KStream source = builder.stream("input-topic");
KTable, Long> counts = source + .groupByKey() + .windowedBy(TimeWindows.of(Duration.ofMinutes(5))) + .count(); egzamin pyt34 PSD detail +Wyjaśnij: Porównanie platform | Cecha | Kafka Streams | Flink | Spark Streaming | +|-------|---------------|-------|-----------------| +| Model | True streaming | True streaming | Micro-batch | +| Deployment | Library | Cluster | Cluster | +| Latency | Niska | Bardzo niska | Średnia (~100ms) | +| State | RocksDB | Roc egzamin pyt34 PSD detail +Wyjaśnij: Algorytmy strumieniowe #### Approximate counting - HyperLogLog
HyperLogLog: +• O(1) space (kilka KB) +• ~2% error dla 12-bit registers +• Używa hash → trailing zeros egzamin pyt34 PSD detail +Wyjaśnij: Obsługa opóźnień i Out-of-Order ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WATERMARKS + LATE DATA │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Stream: ─●(t=1)──●( egzamin pyt34 PSD detail +Wyjaśnij: Exactly-Once Semantics ``` +┌─────────────────────────────────────────────────────────────────┐ +│ GWARANCJE PRZETWARZANIA: │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ AT-MOST-ONCE: egzamin pyt34 PSD detail +Wyjaśnij: Use Cases | Use Case | Technologia | Opis | +|----------|-------------|------| +| Fraud detection | Flink CEP | Pattern matching w czasie rzeczywistym | +| IoT analytics | Kafka Streams | Agregacja danych z sensorów | +| Real-time dashboards | Spark + Druid | Metryki biznesowe | +| Log analysis | E egzamin pyt34 PSD detail +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. ### 1. Definicja układów cyber-fizycznych (CPS)
### 2. Specyfika modelowania CPS egzamin pyt35 SIU main +Wyjaśnij: Definicja układów cyber-fizycznych (CPS) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ CYBER-PHYSICAL SYSTEM (CPS) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌────────────────── egzamin pyt35 SIU detail +Wyjaśnij: Specyfika modelowania CPS #### Hybrid Systems (systemy hybrydowe) egzamin pyt35 SIU detail +Wyjaśnij: Współpraca agentów w sieci Protokół consensus: + ẋᵢ = Σⱼ∈Nᵢ aᵢⱼ(xⱼ - xᵢ)
gdzie: +- xᵢ = stan agenta i +- Nᵢ = sąsiedzi agenta i +- aᵢⱼ = waga połączenia egzamin pyt35 SIU detail +Wyjaśnij: Problemy w osiąganiu pożądanego zachowania #### 4.1 Problemy komunikacyjne egzamin pyt35 SIU detail +Wyjaśnij: Warunki zbieżności consensus ``` +Twierdzenie: Protokół consensus ẋ = -Lx zbiega do consensus ⟺ + Graf komunikacji jest (słabo) spójny
Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU detail +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. ### 1. Model uczenia ze wzmocnieniem
### Markov Decision Process (MDP) egzamin pyt36 SIU main +Wyjaśnij: Model uczenia ze wzmocnieniem ``` +┌─────────────────────────────────────────────────────────────────┐ +│ REINFORCEMENT LEARNING LOOP │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌─ egzamin pyt36 SIU detail +Wyjaśnij: Elementy składowe | Element | Symbol | Opis | +|---------|--------|------| +| State | s ∈ S | Obserwacja środowiska | +| Action | a ∈ A | Decyzja agenta | +| Reward | r ∈ ℝ | Sygnał zwrotny | +| Policy | π(a\|s) | Strategia wyboru akcji | +| Value function | V(s), Q(s,a) | Oczekiwana nagroda | +| **Disco egzamin pyt36 SIU detail +Wyjaśnij: Markov Decision Process (MDP) S: Zbiór stanów +A: Zbiór akcji +P: P(s'|s,a) - prawdopodobieństwa przejść +R: R(s,a,s') - funkcja nagrody +γ: Współczynnik dyskontowania
Właściwość Markowa: + P(sₜ₊₁|s₀,a₀,...,sₜ,aₜ) = P(sₜ₊₁|sₜ,aₜ) + + Przyszłość zależy tylko od obecnego stanu! +``` egzamin pyt36 SIU detail +Wyjaśnij: Funkcje wartości $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$
#### Action Value Function Q(s,a) egzamin pyt36 SIU detail +Wyjaśnij: Algorytmy ┌─────────────────────────────────────────────────────────────────┐ +│ SARSA (on-policy) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Q(s,a) ← Q(s,a) + α[r + γ Q egzamin pyt36 SIU detail +Wyjaśnij: Klasyfikacja algorytmów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ ┌── Model-based (zna/uczy się P, R) │ +│ RL Methods ─┤ │ +│ └── Model egzamin pyt36 SIU detail +Wyjaśnij: Exploration vs Exploitation | Strategia | Opis | +|-----------|------| +| ε-greedy | Z prawdop. ε losowa akcja | +| Softmax/Boltzmann | P(a) ∝ exp(Q(s,a)/τ) | +| UCB | a = argmax[Q(s,a) + c√(ln N / n(a))] | +| Thompson Sampling | Próbkowanie z posterior | +| Curiosity-driven | Bonus za nowość | egzamin pyt36 SIU detail +Wyjaśnij: Własności i wyzwania ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WŁASNOŚCI: │ +│ ✓ Uczenie przez interakcję (nie supervised) │ +│ ✓ Delayed rewards (kredyt za sekwencję akcji) │ +│ ✓ Generalizacja (do nowyc egzamin pyt36 SIU detail +Porównać podstawowe modele sieci złożonych. Jak odpowiadają one własnościom rzeczywistych sieci? ### 1. Właściwości rzeczywistych sieci
### 2. Model Erdős-Rényi (Random Graph) egzamin pyt37 TASS main +Wyjaśnij: Właściwości rzeczywistych sieci ``` +┌─────────────────────────────────────────────────────────────────┐ +│ TYPOWE CECHY SIECI RZECZYWISTYCH │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. SMALL-WORLD EFFECT: egzamin pyt37 TASS detail +Wyjaśnij: Model Erdős-Rényi (Random Graph) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ G(n, p) - Graf losowy │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Porównanie z rzeczywistością | Cecha | ER Model | Rzeczywiste sieci | +|-------|----------|-------------------| +| Clustering | C = p (niski) | C >> p (wysoki) ❌ | +| Średnia ścieżka | L ~ log(n) ✓ | L ~ log(n) ✓ | +| Rozkład stopni | Poisson | Power-law ❌ | +| Huby | Brak | Istnieją ❌ | egzamin pyt37 TASS detail +Wyjaśnij: Model Watts-Strogatz (Small-World) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ SMALL-WORLD MODEL │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Model Barabási-Albert (Scale-Free) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PREFERENTIAL ATTACHMENT MODEL │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Porównanie zbiorcze ``` +┌──────────────┬───────────────┬───────────────┬───────────────┐ +│ Właściwość │ Erdős-Rényi │ Watts-Strogatz│ Barabási-Albert│ +├──────────────┼───────────────┼───────────────┼───────────────┤ +│ Clustering │ Niski (C=p) │ Wysoki │ Niski │ +│ Śr. ścieżka │ log(n) │ lo
Rzeczywiste sieci (WWW, social, biological): +• Wysoki clustering → WS lepszy +• Power-law → BA lepszy +• Short paths → wszystkie OK egzamin pyt37 TASS detail +Wyjaśnij: Modele rozszerzone ``` +┌─────────────────────────────────────────────────────────────────┐ +│ HOLME-KIM MODEL (BA + clustering): │ +│ Po preferential attachment → dodaj trójkąt z prawdop. p │ +│ Łączy power-law z wysokim clustering │ +├────────────────────────── egzamin pyt37 TASS detail +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. ### 1. Grafy dwudzielne (Bipartite Graphs)
### 2. Projekcja grafu dwudzielnego egzamin pyt38 TASS main +Wyjaśnij: Grafy dwudzielne (Bipartite Graphs) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ GRAF DWUDZIELNY │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Zbiór U (np. dokume egzamin pyt38 TASS detail +Wyjaśnij: Projekcja grafu dwudzielnego ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROJEKCJA = przekształcenie grafu dwudzielnego na jednomodowy │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Graf dwudzielny: egzamin pyt38 TASS detail +Wyjaśnij: Metody projekcji #### 3.1 Projekcja binarna (Simple/Unweighted)
P = B · Bᵀ (dla projekcji na U) +P = Bᵀ · B (dla projekcji na V) egzamin pyt38 TASS detail +Wyjaśnij: Zastosowanie w grupowaniu dokumentów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PIPELINE GRUPOWANIA DOKUMENTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. PREPROCESSING
Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS detail +Wyjaśnij: Algorytmy grupowania na projekcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ LOUVAIN (Community Detection): │ +│ • Optymalizuje modularność Q │ +│ • Iteracyjne przenoszenie węzłów między grupami │ +│ • O(n log n) - szybki egzamin pyt38 TASS detail +Wyjaśnij: Problemy i rozwiązania | Problem | Opis | Rozwiązanie | +|---------|------|-------------| +| Gęstość | Projekcja tworzy gęste grafy | Threshold na wagi | +| Huby | Popularne słowa łączą wszystko | TF-IDF, filtering | +| Skalowalność | O(n²) krawędzi | Sparse representation, LSH | +| Utrata info | Projekcja trac egzamin pyt38 TASS detail +Scharakteryzować problem segmentacji obrazu. Przedstawić podstawowe strategie i algorytmy segmentacji przy użyciu metod klasycznych oraz sieci neuronowych. ### 1. Definicja problemu segmentacji
#### 2.1 Thresholding (progowanie) egzamin pyt39 TWM main +Wyjaśnij: Definicja problemu segmentacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ SEGMENTACJA OBRAZU │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Obraz wejściowy: egzamin pyt39 TWM detail +Wyjaśnij: Metody klasyczne #### 2.1 Thresholding (progowanie)
Otsu (automatyczny próg): + - Maksymalizuje wariancję między klasami + - σ²_between = w₀w₁(μ₀ - μ₁)² egzamin pyt39 TWM detail +Wyjaśnij: Porównanie metod klasycznych | Metoda | Zalety | Wady | +|--------|--------|------| +| Thresholding | Szybki, prosty | Tylko 2 klasy, wrażliwy na oświetlenie | +| Region Growing | Intuicyjny | Wymaga seedów, over-segmentation | +| Watershed | Dobre krawędzie | Over-segmentation | +| Mean Shift | Brak k | Wolny, param egzamin pyt39 TWM detail +Wyjaśnij: Metody deep learning #### 4.1 FCN (Fully Convolutional Network)
#### 4.4 Transformer-based (SegFormer, Mask2Former) egzamin pyt39 TWM detail +Wyjaśnij: Porównanie architektur DL | Architektura | mIoU (ADE20K) | Parametry | Cechy | +|--------------|---------------|-----------|-------| +| FCN | ~30% | ~135M | Pierwsze DL dla segmentacji | +| U-Net | - | ~31M | Medical, skip connections | +| DeepLabv3+ | ~45% | ~60M | ASPP, dilated conv | +| SegFormer-B5 | ~51% | ~8 egzamin pyt39 TWM detail +Wyjaśnij: Loss functions ``` +Cross-Entropy Loss: + L = -Σᵢ Σc yᵢc log(pᵢc) + + Problem: class imbalance (dużo tła, mało obiektów)
Dice Loss: + L = 1 - 2|X ∩ Y| / (|X| + |Y|) + + Bezpośrednio optymalizuje IoU-like metric egzamin pyt39 TWM detail +Wyjaśnij: Metryki | Metryka | Formuła | Opis | +|---------|---------|------| +| Pixel Accuracy | TP / (TP+FP+FN+TN) | % poprawnych pikseli | +| IoU (Jaccard) | TP / (TP+FP+FN) | Intersection over Union | +| mIoU | mean IoU per class | Standard dla segmentacji | +| Dice | 2TP / (2TP+FP+FN) | F1 dla segmenta egzamin pyt39 TWM detail +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? ### 1. Definicja problemu detekcji
#### 2.1 Sliding Window + HOG/SIFT egzamin pyt40 TWM main +Wyjaśnij: Definicja problemu detekcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DETEKCJA OBIEKTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Obraz wejściowy: egzamin pyt40 TWM detail +Wyjaśnij: Metody Deep Learning #### 3.1 Two-Stage Detectors (R-CNN family)
┌─────────────────────────────────────────────────────────────────┐ +│ Fast R-CNN (2015) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Image → CNN → Feature map egzamin pyt40 TWM detail +Wyjaśnij: Konstrukcja detektora z klasyfikatora ``` +┌─────────────────────────────────────────────────────────────────┐ +│ JAK ZROBIĆ DETEKTOR MAJĄC KLASYFIKATOR? │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Metoda 1: SLIDING WINDO egzamin pyt40 TWM detail +Wyjaśnij: Non-Maximum Suppression (NMS) ``` +Problem: Wiele overlapping detections
┌─────────┐ + │ ┌──────┼──┐ + │ │ 🚗 │ │ ← 3 nakładające się bbox + │ │ │ │ + └──┼──────┘ │ + └─────────┘ egzamin pyt40 TWM detail +Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. ### 1. Decyzje w warunkach ryzyka
### 2. Metody interaktywne - przegląd egzamin pyt41 WDWR main +Wyjaśnij: Decyzje w warunkach ryzyka ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WARUNKI PODEJMOWANIA DECYZJI │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ PEWNOŚĆ: Znamy do egzamin pyt41 WDWR detail +Wyjaśnij: Metody interaktywne - przegląd ``` +┌─────────────────────────────────────────────────────────────────┐ +│ INTERAKTYWNE = Dialog z decydentem │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌──────────────┐ egzamin pyt41 WDWR detail +Wyjaśnij: Metoda loterii (Lottery Method) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ELICYTACJA FUNKCJI UŻYTECZNOŚCI │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Cel: Wyznaczyć U(x) dla egzamin pyt41 WDWR detail +Wyjaśnij: Metoda pewnego ekwiwalentu (Certainty Equivalent) ``` +CE (Certainty Equivalent) = pewna kwota równoważna loterii
Dla loterii L = (p₁: x₁, p₂: x₂, ...): + CE(L) taki że U(CE) = E[U(L)] = Σ pᵢ U(xᵢ) egzamin pyt41 WDWR detail +Wyjaśnij: Metoda AHP (Analytic Hierarchy Process) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ AHP - Hierarchiczna struktura problemu (Saaty) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌─── egzamin pyt41 WDWR detail +Wyjaśnij: Metoda PROMETHEE ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROMETHEE - Preference Ranking Organization Method │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. Dla każdego kryteriu egzamin pyt41 WDWR detail +Wyjaśnij: Metoda ELECTRE ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ELECTRE - ELimination Et Choix Traduisant la REalité │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Outranking: "a jest co n egzamin pyt41 WDWR detail +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? ### 1. Idea dominacji stochastycznej
### 2. Dominacja stochastyczna pierwszego rzędu (FSD) egzamin pyt42 WDWR main +Wyjaśnij: Idea dominacji stochastycznej ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DOMINACJA STOCHASTYCZNA (Stochastic Dominance) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Cel: Porównać rozkłady egzamin pyt42 WDWR detail +Wyjaśnij: Dominacja stochastyczna pierwszego rzędu (FSD) $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$
gdzie $F(x) = P(X \leq x)$ to dystrybuanta (CDF) egzamin pyt42 WDWR detail +Wyjaśnij: Dominacja stochastyczna drugiego rzędu (SSD) $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$
$$E[U(A)] \geq E[U(B)] \quad \forall U: U' \geq 0, U'' \leq 0$$ egzamin pyt42 WDWR detail +Wyjaśnij: Porównanie FSD i SSD ``` +┌─────────────────────────────────────────────────────────────────┐ +│ FSD vs SSD │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Przykład 1: FSD egzamin pyt42 WDWR detail +Wyjaśnij: Zastosowanie w modelach wyboru Test SSD: +• E[A] = 10% > E[B] = 8% ✓ +• σ[A] = 15% < σ[B] = 20% ✓
Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: + A dominuje B (SSD) egzamin pyt42 WDWR detail +Wyjaśnij: Testowanie dominacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ALGORYTM SPRAWDZANIA SD │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dane: Dwa rozkłady emp egzamin pyt42 WDWR detail +Wyjaśnij: Ograniczenia | Ograniczenie | Opis | +|--------------|------| +| Częściowe uporządkowanie | Nie wszystkie pary porównywalne | +| Konserwatywność | Wiele par bez dominacji | +| Wymóg pełnego rozkładu | Potrzebna cała dystrybuanta | +| Brak dominacji ≠ obojętność | Brak dominacji nie znaczy równoważność egzamin pyt42 WDWR detail +Jakie cechy zadań szeregowania wykorzystuje się do ich klasyfikacji? Omówić przykładową metodę dla wybranego problemu szeregowania. ### 1. Notacja Graham'a (α|β|γ)
### 2. Pole α - Środowisko maszynowe egzamin pyt43 ZBOP main +Wyjaśnij: Notacja Graham'a (α|β|γ) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ NOTACJA KLASYFIKACJI ZADAŃ SZEREGOWANIA │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ α | egzamin pyt43 ZBOP detail +Wyjaśnij: Pole α - Środowisko maszynowe | Symbol | Opis | +|--------|------| +| 1 | Jedna maszyna | +| P | Maszyny równoległe identyczne | +| Pm | m maszyn równoległych identycznych | +| Q | Maszyny równoległe o różnych prędkościach | +| R | Maszyny niezwiązane (unrelated) | +| F | Flow shop (linia produkcyjna) | +| Fm
MASZYNY RÓWNOLEGŁE (Pm): + Job 1 ──→ ┌───┐ + │M1 │ ──→ + Job 2 ──→ ├───┤ + │M2 │ ──→ Output + Job 3 ──→ ├───┤ + │M3 │ ──→ + └───┘ egzamin pyt43 ZBOP detail +Wyjaśnij: Pole β - Charakterystyki zadań | Symbol | Opis | +|--------|------| +| rⱼ | Release dates (terminy dostępności) | +| dⱼ | Due dates (terminy wymagane) | +| d̄ⱼ | Deadlines (nieprzekraczalne terminy) | +| prec | Precedence constraints (kolejność) | +| pmtn | Preemption allowed (przerwanie dozwolone) | +| pⱼ=1 | Un egzamin pyt43 ZBOP detail +Wyjaśnij: Pole γ - Kryteria optymalizacji | Symbol | Nazwa | Formuła | +|--------|-------|---------| +| Cmax | Makespan | max Cⱼ | +| ΣCⱼ | Total completion time | Σ Cⱼ | +| Σwⱼ Cⱼ | Weighted completion | Σ wⱼ Cⱼ | +| Lmax | Max lateness | max(Cⱼ - dⱼ) | +| Tmax | Max tardiness | max(0, Cⱼ - dⱼ) | +| ΣTⱼ | Total tardiness | egzamin pyt43 ZBOP detail +Wyjaśnij: Złożoność obliczeniowa ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ZŁOŻONOŚĆ WYBRANYCH PROBLEMÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ WIELOMIANOWE (P): egzamin pyt43 ZBOP detail +Wyjaśnij: Inne klasyczne reguły | Reguła | Problem | Opis | +|--------|---------|------| +| SPT | 1 \|\| ΣCⱼ | Shortest Processing Time | +| WSPT | 1 \|\| ΣwⱼCⱼ | Weighted SPT (wⱼ/pⱼ malejąco) | +| EDD | 1 \|\| Lmax | Earliest Due Date | +| LPT | Pm \|\| Cmax | Longest Processing Time (heur.) | +| Moore | 1 \|\| ΣUⱼ egzamin pyt43 ZBOP detail +Wyjaśnij: Algorytm Johnsona (F2 || Cmax) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ALGORYTM JOHNSONA - Flow shop 2 maszyny │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dane: n zadań, czasy (a egzamin pyt43 ZBOP detail +Jakie problemy wiążą się z zarządzaniem zapasami w łańcuchu dostaw? Omówić przykładowy model zarządzania zapasami w łańcuchu dostaw. ### 1. Łańcuch dostaw - struktura
### 2. Problemy zarządzania zapasami egzamin pyt44 ZBOP main +Wyjaśnij: Łańcuch dostaw - struktura ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ŁAŃCUCH DOSTAW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dostawcy → Producent egzamin pyt44 ZBOP detail +Wyjaśnij: Problemy zarządzania zapasami #### 2.1 Bullwhip Effect (Efekt byczego bicza) egzamin pyt44 ZBOP detail +Wyjaśnij: Koszty zapasów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ STRUKTURA KOSZTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. KOSZTY UTRZYMANIA ( egzamin pyt44 ZBOP detail +Wyjaśnij: Model EOQ (Economic Order Quantity) Ordering cost = K × (D/Q) (D/Q zamówień rocznie) +Holding cost = h × (Q/2) (średni zapas = Q/2)
┌──────────┐ + Q* = │ 2·K·D │ + │ ────── │ + │ h │ + └──────────┘ egzamin pyt44 ZBOP detail +Wyjaśnij: Model z punktem zamawiania (ROP) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ REORDER POINT (ROP) - uwzględnienie lead time │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Poziom zapasu: egzamin pyt44 ZBOP detail +Wyjaśnij: Model (s, S) / (R, Q) | Model | Opis | +|-------|------| +| (s, Q) | Zamów Q gdy poziom spadnie do s | +| (s, S) | Zamów do poziomu S gdy spadnie do s | +| (R, S) | Co R okresów uzupełnij do S | +| (R, s, S) | Co R okresów: jeśli ≤ s, uzupełnij do S |
Polityka: Gdy poziom ≤ s, zamów aby osiągnąć S +``` egzamin pyt44 ZBOP detail +Wyjaśnij: Vendor Managed Inventory (VMI) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ VMI - Dostawca zarządza zapasami klienta │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Tradycyjnie: egzamin pyt44 ZBOP detail +Wyjaśnij: Wskaźniki efektywności | Wskaźnik | Formuła | Cel | +|----------|---------|-----| +| Inventory Turnover | COGS / Avg Inventory | Wyższy = lepszy | +| Days of Inventory | 365 / Turnover | Niższy = lepszy | +| Fill Rate | Zamówienia zrealizowane / Wszystkie | Wyższy | +| Service Level | P(brak stockout) | 95-99% egzamin pyt44 ZBOP detail +Wyjaśnij: Pytanie "Jaki jest cel Pana pracy magisterskiej i dlaczego wybrano akurat temat porównania silników gier?" egzamin pyt45 Ogólne detail +Wyjaśnij: Odpowiedź wzorcowa Praktyczna potrzeba: wybór silnika to kluczowa decyzja wpływająca na cały cykl życia projektu
Brak obiektywnych porównań: większość istniejących materiałów ma charakter subiektywny lub marketingowy
Dominacja rynkowa: Unity i Unreal wspólnie obsługują >70% globalnego rynku gier
Reprezentatywność architektur: silniki reprezentują fundamentalnie różne podejścia (C# z GC vs C++ z ręcznym zarządzaniem pamięcią) egzamin pyt45 Ogólne detail +Wyjaśnij: Wydajność - Szybkość renderowania (FPS) +- Zużycie pamięci RAM +- Obciążenie procesora +- Zużycie pamięci karty graficznej +- Czas ładowania scen egzamin pyt45 Ogólne detail +Wyjaśnij: Funkcjonalność - Wsparcie dla różnych typów renderingu +- Systemy fizyki +- Systemy audio +- Wsparcie dla VR/AR +- Możliwości skryptowania egzamin pyt45 Ogólne detail +Wyjaśnij: Użyteczność Dlaczego te kryteria:: Pokrywają wszystkie aspekty istotne dla deweloperów egzamin pyt45 Ogólne detail diff --git a/pytania/anki_extract_main.txt b/pytania/anki_extract_main.txt new file mode 100644 index 0000000..118fba5 --- /dev/null +++ b/pytania/anki_extract_main.txt @@ -0,0 +1,40 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_extract+main + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (Finite Automaton - FA): Języki regularne (Typ 3)

Automat ze Stosem (Pushdown Automaton - PDA): Języki bezkontekstowe (Typ 2)

Maszyna Turinga (Turing Machine - TM): Języki rekurencyjnie przeliczalne (Typ 0) egzamin pyt01 AISDI main +Omówić i porównać algorytmy najkrótszej ścieżki wskazując ich kluczowe właściwości i logikę budowy: Dijkstry, Belmana-Forda, A*. Wprowadzenie - problem najkrótszej ścieżki: Warianty problemu: egzamin pyt02 AISDI main +Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. Wprowadzenie: Redundancja: = niepożądane powtarzanie danych egzamin pyt03 BD2 main +Omówić główne kategorie elementów biblioteki STL. Jaka jest ich rola i wzajemne powiązania? Odpowiedź uzasadnić na przykładach. Filozofia STL: Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami egzamin pyt05 PROI main +Przedstawić sieciowe modele optymalizacji stosowane w systemach zarządzania. Omówić ich właściwości. Wprowadzenie: Węzły: = punkty decyzyjne, lokalizacje, zdarzenia egzamin pyt12 WSYZ main +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. Architektury agentów: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.

Standardy komunikacji agentów: FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD main +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. Algorytmy negocjacji i aukcji: Manager Contractors

Algorytmy konsensusu: Client ──request──→ Primary

Algorytmy koordynacji: Algorytm Ricarta-Agrawali:

Algorytmy uczenia wieloagentowego: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]

Algorytmy dla aktorów: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main +Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury. Notacje i języki modelowania: Zasada: Zoom in/out między poziomami egzamin pyt15 AIS main +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne. Jak powstają wzorce: Nazwa: identyfikator egzamin pyt16 AIS main +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. Optymalizacja bez ograniczeń: (Gradient zerowy - punkt stacjonarny)

Warunki KKT (Karush-Kuhn-Tucker): Jeśli $x^*$ jest minimum i spełnione są warunki regularności:

Warunki regularności (Constraint Qualification): LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne

Warunki dostateczne II rzędu: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. Programowanie liniowe (LP): Złożoność: O(2^n) worst-case, ale praktycznie bardzo szybki

Programowanie kwadratowe (QP): Gdzie Q jest macierzą symetryczną.

Metody rozwiązywania QP: 1. Zgadnij zbiór aktywnych ograniczeń W

Przypadki szczególne: Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO main +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). Cel parametryzacji mowy: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę

MFCC (Mel-Frequency Cepstral Coefficients): mel(f) = 2595 · log₁₀(1 + f/700)

LPC (Linear Predictive Coding): Dźwięczne:: pobudzenie okresowe (struny głosowe) egzamin pyt19 EASAR main +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. HMM (Hidden Markov Model) - klasyczne podejście: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:

Deep Learning w rozpoznawaniu mowy: Attention-based (Seq2Seq):

Ewolucja wydajności: Rok Model WER egzamin pyt20 EASAR main +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? Agent upostaciowiony (Embodied Agent): Percepcji: poprzez sensory

Formalny model agenta: Specyfikacja żywotności: egzamin pyt21 ERPM main +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. Języki producentów robotów przemysłowych: ! MoveJ = ruch w przestrzeni złączy (Joint)

Języki uniwersalne i frameworki: rospy.init_node('robot_controller') egzamin pyt22 ERPM main +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. Problem czasu w systemach rozproszonych: Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

Zegar Lamporta (Scalar Clock): 1. Przed każdym zdarzeniem lokalnym:

Zegary wektorowe (Vector Clocks): 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. Silne modele spójności: Implementacja: Consensus (Paxos, Raft), single leader

Słabe modele spójności: Implementacja: DNS, Dynamo, Cassandra egzamin pyt24 ERSMS main +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. Definicja MIP (Mixed Integer Programming): Przypadki szczególne:

Branch and Bound (B&B) - metoda dokładna: LP relaxation egzamin pyt25 MOD main +Scharakteryzować informatyczne narzędzia optymalizacji dyskretnej. Jakie są warunki i wymagania, jakie możliwości oraz trudności wiążą się ze stosowaniem gotowych narzędzi. Porównanie wydajności (benchmark): CPLEX ████████████████████████████ 100% egzamin pyt26 MOD main +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. Model konceptualny (Conceptual Data Model): ┌──────────┐ ┌──────────┐

Model logiczny (Logical Data Model): ┌────────────────────────┐ ┌────────────────────────┐

Model fizyczny (Physical Data Model): CREATE INDEX idx_klient_email ON klient(email); egzamin pyt28 MODA main +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? Prawo Amdahla: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$

Wizualizacja ograniczenia: Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.

Co osłabia ograniczenie Amdahla?: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n

Czynniki zmniejszające rzeczywiste przyśpieszenie: ┌─────────────────────────────────────────────────────────────────┐

Efektywność równoległa: Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR main +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych. Typowe problemy w modelowaniu: Przykład - planowanie produkcji:

Techniki modelowania: Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM main +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. Definicje kluczowe: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$

Liniowość vs nieliniowość: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$

Testowanie wypukłości: 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x egzamin pyt31 MOM main +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? Definicje podstawowe: KOMUNIKACJA ASYNCHRONICZNA:

Problem zakleszczenia (Deadlock): // Proces 0: // Proces 1:

Rozwiązania problemu zakleszczenia: MPI_Irecv(from=partner, data_in, &req_recv); // Nieblokujące recv egzamin pyt32 PORR main +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model. Rozwiązania techniczne: channel.queue_bind(exchange='logs', queue=queue_name) egzamin pyt33 PSD main +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. Modele przetwarzania: Processing: ───●───────●──●──●───────→

Platformy Stream Processing: KStream source = builder.stream("input-topic");

Algorytmy strumieniowe: Przykład: Redis PFADD, PFCOUNT egzamin pyt34 PSD main +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. Współpraca agentów w sieci: L = Laplacian grafu komunikacji

Warunki zbieżności consensus: Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU main +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. Funkcje wartości: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$

Algorytmy: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. Metody projekcji: P = B · Bᵀ (dla projekcji na U)

Zastosowanie w grupowaniu dokumentów: Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS main +Scharakteryzować problem segmentacji obrazu. Przedstawić podstawowe strategie i algorytmy segmentacji przy użyciu metod klasycznych oraz sieci neuronowych. Metody klasyczne: Otsu (automatyczny próg): egzamin pyt39 TWM main +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? Metody Deep Learning: ┌─────────────────────────────────────────────────────────────────┐

Non-Maximum Suppression (NMS): Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main +Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. Metoda pewnego ekwiwalentu (Certainty Equivalent): Dla loterii L = (p₁: x₁, p₂: x₂, ...): egzamin pyt41 WDWR main +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? Dominacja stochastyczna pierwszego rzędu (FSD): $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$

Dominacja stochastyczna drugiego rzędu (SSD): $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$

Zastosowanie w modelach wyboru: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main +Jakie cechy zadań szeregowania wykorzystuje się do ich klasyfikacji? Omówić przykładową metodę dla wybranego problemu szeregowania. Pole α - Środowisko maszynowe: MASZYNY RÓWNOLEGŁE (Pm): egzamin pyt43 ZBOP main +Jakie problemy wiążą się z zarządzaniem zapasami w łańcuchu dostaw? Omówić przykładowy model zarządzania zapasami w łańcuchu dostaw. Model EOQ (Economic Order Quantity): Ordering cost = K × (D/Q) (D/Q zamówień rocznie) egzamin pyt44 ZBOP main diff --git a/pytania/anki_filter.txt b/pytania/anki_filter.txt new file mode 100644 index 0000000..79e1b91 --- /dev/null +++ b/pytania/anki_filter.txt @@ -0,0 +1,1217 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_filter + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich?
  • Hierarchia Chomsky'ego - fundament teoretyczny
  • Automat Skończony (Finite Automaton - FA)
  • Automat ze Stosem (Pushdown Automaton - PDA)
  • Maszyna Turinga (Turing Machine - TM)
egzamin pyt01 AISDI main +Wyjaśnij: Hierarchia Chomsky'ego - fundament teoretyczny Noam Chomsky w 1956 roku zaproponował hierarchię czterech klas języków formalnych, gdzie każda kolejna klasa zawiera poprzednią: egzamin pyt01 AISDI detail +Wyjaśnij: Automat Skończony (Finite Automaton - FA) #### Definicja formalna +Automat skończony to piątka: M = (Q, Σ, δ, q₀, F) +- Q - skończony zbiór stanów +- Σ - alfabet wejściowy (skończony zbiór symboli) +- δ - funkcja przejścia: Q × Σ → Q (DFA) lub Q × Σ → P(Q) (NFA) +- q₀ - stan początkowy (q₀ ∈ Q) +- F - zbiór stanów akceptujących (F ⊆ Q) egzamin pyt01 AISDI detail +Wyjaśnij: Automat ze Stosem (Pushdown Automaton - PDA) #### Definicja formalna +Automat ze stosem to siódemka: M = (Q, Σ, Γ, δ, q₀, Z₀, F) +- Q - skończony zbiór stanów +- Σ - alfabet wejściowy +- Γ - alfabet stosowy +- δ - funkcja przejścia: Q × (Σ ∪ {ε}) × Γ → P(Q × Γ*) +- q₀ - stan początkowy +- Z₀ - początkowy symbol na stosie +- F - zbiór stanów akceptujących egzamin pyt01 AISDI detail +Wyjaśnij: Maszyna Turinga (Turing Machine - TM) #### Definicja formalna +Maszyna Turinga to siódemka: M = (Q, Σ, Γ, δ, q₀, qaccept, qreject) +- Q - skończony zbiór stanów +- Σ - alfabet wejściowy (nie zawiera symbolu pustego ␣) +- Γ - alfabet taśmowy (Σ ⊂ Γ, ␣ ∈ Γ) +- δ - funkcja przejścia: Q × Γ → Q × Γ × {L, R} +- q₀ - stan początkowy +- qaccept - stan akceptujący +- qreject - stan odrzucający egzamin pyt01 AISDI detail +Wyjaśnij: "STOS LIFO" - Skończony automat - Stan tylko (bez pamięci) +- Tylko regex - języki regularne +- Ograniczony PDA - Odnosi się do stosu +- Stos = bezkontekstowe egzamin pyt01 AISDI detail +Wyjaśnij: "TuRing = Total Random access" - Taśma nieskończona +- Random access (czytanie i pisanie) +- Total - wszystko może obliczyć (co jest obliczalne) egzamin pyt01 AISDI detail +Wyjaśnij: "3-2-1 START" - 3 = Typ 3 = FA = regex (najsłabszy) +- 2 = Typ 2 = PDA = CFG (parser) +- 1 = Typ 1 = kontekstowe (LBA) +- 0 = Typ 0 = TM = wszystko (START od zera = najpotężniejszy) egzamin pyt01 AISDI detail +Wyjaśnij: Akronim "CHOMSKY" dla hierarchii: - Computable all (Typ 0 - TM) +- Hard context-sensitive (Typ 1) +- OK with stack (Typ 2 - PDA) +- Minimal - regex only (Typ 3 - FA) +- Strict inclusion (każda klasa zawiera niższą) +- Key for compilers (zastosowania) +- Years of theory (od 1956) egzamin pyt01 AISDI detail +Wyjaśnij: Q1: "Udowodnij, że język L = {aⁿbⁿ} nie jest regularny" Odpowiedź: +Stosujemy lemat o pompowaniu. Załóżmy, że L jest regularny z długością pompowania p. egzamin pyt01 AISDI detail +Wyjaśnij: Q3: "Co to jest LBA i gdzie się mieści w hierarchii?" Odpowiedź: +Linear Bounded Automaton (LBA) - maszyna Turinga z ograniczoną taśmą: +- Taśma ograniczona do długości liniowej względem wejścia: O(n) +- Rozpoznaje języki kontekstowe (Typ 1) +- NLBA > DLBA? - otwarty problem! +- Przykład: L = {aⁿbⁿcⁿ} - kontekstowy, ale nie bezkontekstowy egzamin pyt01 AISDI detail +Wyjaśnij: Q5: "Co to jest teza Churcha-Turinga?" Odpowiedź: +Teza Churcha-Turinga (nieformalnie): +> "Każda funkcja, która może być obliczona przez jakikolwiek algorytm, może być obliczona przez maszynę Turinga." egzamin pyt01 AISDI detail +Wyjaśnij: Wprowadzenie - problem najkrótszej ścieżki Problem: Dany jest graf G = (V, E) z funkcją wag w: E → ℝ. Znajdź ścieżkę z wierzchołka źródłowego s do wierzchołka docelowego t o minimalnej sumie wag krawędzi. egzamin pyt02 AISDI detail +Wyjaśnij: Charakterystyka - Autor: Edsger Dijkstra (1956, opublikowany 1959) +- Typ: Zachłanny (greedy) +- Problem: SSSP - najkrótsze ścieżki z jednego źródła do wszystkich wierzchołków +- Ograniczenie: ⚠️ Tylko nieujemne wagi krawędzi (w(e) ≥ 0) egzamin pyt02 AISDI detail +Wyjaśnij: Idea algorytmu (logika budowy) 1. Relaksacja: Stopniowe ulepszanie oszacowań odległości +2. Zachłanność: W każdym kroku wybieramy wierzchołek o najmniejszej znanej odległości +3. Optymalna podstruktura: Najkrótsza ścieżka składa się z najkrótszych podścieżek egzamin pyt02 AISDI detail +Wyjaśnij: Złożoność czasowa | Implementacja kolejki | EXTRACT-MIN | DECREASE-KEY | Całkowita | +|----------------------|-------------|--------------|-----------| +| Lista/tablica | O(V) | O(1) | O(V²) | +| Kopiec binarny | O(log V) | O(log V) | O((V + E) log V) | +| Kopiec Fibonacciego | O(log V) | O(1) | O(V log V + E) | egzamin pyt02 AISDI detail +Wyjaśnij: Dlaczego nie działa dla ujemnych wag? Dijkstra przetwarza wierzchołki w kolejności rosnącej odległości i oznacza je jako "zakończone". Jeśli waga może być ujemna, późniejszy wierzchołek może "poprawić" już zakończony. egzamin pyt02 AISDI detail +Wyjaśnij: Wykrywanie cyklu ujemnego Po |V|-1 iteracjach, wszystkie najkrótsze ścieżki (bez cykli) są znalezione. +Jeśli w iteracji |V| nadal można zrelaksować krawędź → istnieje cykl ujemny. egzamin pyt02 AISDI detail +Wyjaśnij: Przypadki specjalne: - h(n) = 0: A = Dijkstra +- h(n) = h(n): A idzie prosto do celu (idealna heurystyka) +- h(n) > h(n): Może nie znaleźć optymalnej ścieżki! egzamin pyt02 AISDI detail +Wyjaśnij: Dijkstra - Nawigacja GPS (drogi nie mają ujemnych odległości) +- Routing w sieciach (OSPF protocol) +- Mapy Google/Apple (dla małych obszarów) egzamin pyt02 AISDI detail +Wyjaśnij: Bellman-Ford - Routing w sieciach (RIP protocol - prostszy) +- Arbitraż walutowy (szukanie cykli ujemnych = zysk!) +- Systemy z "karami" (ujemne wagi = bonusy) egzamin pyt02 AISDI detail +Wyjaśnij: A* - Gry komputerowe - pathfinding NPC, RTS +- Robotyka - planowanie ruchu +- Puzzle - 8-puzzle, 15-puzzle +- Nawigacja - gdy znamy pozycję celu egzamin pyt02 AISDI detail +Wyjaśnij: "DBF - Dijkstra Bellman Ford" - Dijkstra = Dodatnie wagi tylko +- Bellman-Ford = Bez ograniczeń (ujemne OK) +- Find cycles = wykrywa cykle ujemne egzamin pyt02 AISDI detail +Wyjaśnij: "GREP" dla Dijkstry: - Greedy (zachłanny) +- Relaksacja krawędzi +- Extract-min z kolejki +- Priority queue kluczowa egzamin pyt02 AISDI detail +Wyjaśnij: Wprowadzenie Redundancja (nadmiarowość) i normalizacja to dwa fundamentalne, przeciwstawne pojęcia w projektowaniu relacyjnych baz danych: egzamin pyt03 BD2 detail +Wyjaśnij: Definicja Redundancja występuje, gdy ta sama informacja jest przechowywana w wielu miejscach bazy danych, co prowadzi do: +- Marnowania pamięci +- Niespójności danych (anomalii) +- Trudności w utrzymaniu egzamin pyt03 BD2 detail +Wyjaśnij: Trzy typy anomalii #### 1. Anomalia wstawiania (Insertion Anomaly) +Problem: Nie można dodać danych bez dodania innych, niepotrzebnych danych. egzamin pyt03 BD2 detail +Wyjaśnij: Podstawowe pojęcia #### Zależność funkcyjna (Functional Dependency - FD) +X → Y oznacza: wartość X jednoznacznie określa wartość Y egzamin pyt03 BD2 detail +Wyjaśnij: 1NF - Pierwsza Postać Normalna #### Wymagania: +1. Atomowość wartości - każda komórka zawiera jedną, niepodzielną wartość +2. Brak powtarzających się grup - brak tablic/list w komórkach +3. Istnieje klucz główny egzamin pyt03 BD2 detail +Wyjaśnij: 2NF - Druga Postać Normalna #### Wymagania: +1. Spełnia 1NF +2. Każdy atrybut wtórny jest w pełni funkcyjnie zależny od całego klucza głównego (nie od jego części) egzamin pyt03 BD2 detail +Wyjaśnij: 3NF - Trzecia Postać Normalna #### Wymagania: +1. Spełnia 2NF +2. Brak przechodnich zależności funkcyjnych - atrybuty wtórne nie zależą od innych atrybutów wtórnych egzamin pyt03 BD2 detail +Wyjaśnij: 4NF - Czwarta Postać Normalna #### Wymagania: +1. Spełnia BCNF +2. Brak nietrywialnych zależności wielowartościowych (MVD - Multivalued Dependencies) egzamin pyt03 BD2 detail +Wyjaśnij: 5NF - Piąta Postać Normalna (PJNF) #### Wymagania: +1. Spełnia 4NF +2. Brak zależności połączeniowych (Join Dependencies) +3. Dekompozycja bez strat tylko na podstawie kluczy kandydujących egzamin pyt03 BD2 detail +Wyjaśnij: Algorytm dekompozycji do 3NF 1. Znajdź pokrycie kanoniczne zbioru zależności funkcyjnych +2. Dla każdej FD X → A utwórz relację R(X, A) +3. Jeśli żadna relacja nie zawiera klucza kandydującego, dodaj relację z atrybutami klucza +4. Usuń relacje zawarte w innych relacjach egzamin pyt03 BD2 detail +Wyjaśnij: Własności dobrej dekompozycji #### 1. Bezstratność (Lossless Join) +Po dekompozycji można odtworzyć oryginalną relację przez złączenie naturalne. egzamin pyt03 BD2 detail +Wyjaśnij: Kiedy stosować? - Optymalizacja wydajności - złączenia są kosztowne +- Systemy OLAP/hurtownie danych - dane głównie odczytywane +- Raportowanie - predefiniowane zapytania egzamin pyt03 BD2 detail +Wyjaśnij: Techniki denormalizacji: 1. Dodanie redundantnych kolumn - unikanie złączeń +2. Tabele podsumowujące - agregaty +3. Tabele historyczne - snapshoty +4. Materializowane widoki - cache wyników egzamin pyt03 BD2 detail +Wyjaśnij: "1-2-3-BC" dla postaci normalnych: - 1NF = 1 wartość w komórce (atomowość) +- 2NF = 2 słowa: "pełna zależność" (od całego klucza) +- 3NF = 3 słowa: "brak przechodniości" (A→B→C eliminowane) +- BCNF = Bardzo Cisty (każdy determinant = nadklucz) egzamin pyt03 BD2 detail +Wyjaśnij: "AIU" dla anomalii: - Anomalia wstawiania (Adding) - nie można dodać +- Insercja usuwania (Interrupts) - traci dane przy DELETE +- Update modyfikacji - trzeba zmieniać wiele wierszy egzamin pyt03 BD2 detail +Wyjaśnij: "KAP" dla kluczy: - Klucz główny - wybrany unikalny identyfikator +- Alternatywny (kandydujący) - mógłby być głównym +- Pierwszy atrybut - należy do jakiegoś klucza egzamin pyt03 BD2 detail +Wyjaśnij: Wzór na 3NF: > "Każdy atrybut zależy od klucza, całego klucza i tylko od klucza." +> (The key, the whole key, and nothing but the key - so help me Codd!) egzamin pyt03 BD2 detail +Wyjaśnij: Transakcyjność - gwarancje ACID | Właściwość | Opis | Znaczenie | +|------------|------|-----------| +| Atomicity (Atomowość) | Transakcja wykonuje się w całości lub wcale | Brak częściowych zmian | +| Consistency (Spójność) | Dane przechodzą z jednego spójnego stanu w drugi | Reguły biznesowe zawsze spełnione | +| Isolation (Izolacja) | Równoległe transakcje nie widzą swoich zmian | Brak efektów ubocznych | +| Durabi egzamin pyt04 BD2 detail +Wyjaśnij: Rodzaje niezależności #### 1. Niezależność fizyczna +Zmiana sposobu przechowywania (indeksy, partycjonowanie, kompresja) nie wpływa na aplikacje. egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy kontroli współbieżności | Mechanizm | Opis | Zastosowanie | +|-----------|------|--------------| +| Blokady (Locks) | Pesymistyczne - blokuj przed dostępem | Wysokie konflikty | +| MVCC | Optymistyczne - wersjonowanie | Dużo odczytów | +| Timestamp Ordering | Szeregowanie po czasie | Systemy rozproszone | +| Snapshot Isolation | Izolacja migawkowa | Analityka | egzamin pyt04 BD2 detail +Wyjaśnij: Poziomy izolacji (SQL Standard) | Poziom | Dirty Read | Non-repeatable Read | Phantom Read | +|--------|------------|---------------------|--------------| +| READ UNCOMMITTED | Możliwy | Możliwy | Możliwy | +| READ COMMITTED | Niemożliwy | Możliwy | Możliwy | +| REPEATABLE READ | Niemożliwy | Niemożliwy | Możliwy | +| SERIALIZABLE | Niemożliwy | Niemożliwy | Niemożliwy | egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wymuszania integralności #### 1. Ograniczenia deklaratywne +```sql +CREATE TABLE Zamowienia ( + id INT PRIMARY KEY, -- Klucz główny + klient_id INT NOT NULL, -- NOT NULL + data DATE DEFAULT CURRENT_DATE, -- Wartość domyślna + kwota DECIMAL(10,2) CHECK (kwota > 0), -- Warunek CHECK + FOREIGN KEY (klient_id) REFERENCES Klienci(id) -- Klucz obcy +); +``` egzamin pyt04 BD2 detail +Wyjaśnij: Optymalizator zapytań SZBD automatycznie: +1. Analizuje zapytanie (parsing) +2. Generuje plany wykonania (alternatywy) +3. Szacuje koszty (statystyki) +4. Wybiera najlepszy plan (optymalizacja) egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wydajności | Mechanizm | Funkcja | +|-----------|---------| +| Indeksy | Szybkie wyszukiwanie (B-tree, Hash, GiST) | +| Buforowanie | Cache często używanych danych | +| Partycjonowanie | Podział dużych tabel | +| Materializowane widoki | Prekompilowane złączenia | +| Query cache | Cache wyników zapytań | egzamin pyt04 BD2 detail +Wyjaśnij: Skalowanie poziome (Scale-out) - Replikacja - kopie do odczytu +- Sharding - podział danych między serwery +- Klastry - wysoka dostępność egzamin pyt04 BD2 detail +Wyjaśnij: Wysoka dostępność (HA) | Rozwiązanie | Opis | +|-------------|------| +| Replikacja Master-Slave | Odczyty z replik | +| Replikacja Master-Master | Zapisy na wielu węzłach | +| Failover automatyczny | Przełączanie przy awarii | +| Backup/Recovery | Odtwarzanie po katastrofie | egzamin pyt04 BD2 detail +Wyjaśnij: SQL jako lingua franca - Standardowy język - SQL:2016, SQL:2023 +- Przenośność - kod działa na różnych SZBD +- Narzędzia - uniwersalne IDE, ORM, ETL egzamin pyt04 BD2 detail +Wyjaśnij: Bogaty ekosystem - ORM (Hibernate, Entity Framework, SQLAlchemy) +- Narzędzia migracji (Flyway, Liquibase) +- Monitorowanie (Grafana, Datadog) +- Backup (pg_dump, mysqldump, RMAN) egzamin pyt04 BD2 detail +Wyjaśnij: Jeden fundament, wiele modeli | Model | SZBD | Zastosowanie | +|-------|------|--------------| +| Relacyjny | PostgreSQL, MySQL, Oracle | OLTP, dane strukturalne | +| Dokumentowy | MongoDB, CouchDB | JSON, elastyczne schematy | +| Klucz-wartość | Redis, DynamoDB | Cache, sesje | +| Grafowy | Neo4j, Amazon Neptune | Relacje, sieci społeczne | +| Kolumnowy | Cassandra, ClickHouse | Analityka, time-series | +| **Czas egzamin pyt04 BD2 detail +Wyjaśnij: "ACID" - już sam w sobie mnemonik: - Atomowość - All or nothing +- Consistency - Correct always +- Isolation - Independent transactions +- Durability - Data survives egzamin pyt04 BD2 detail +Wyjaśnij: "BDSM" dla korzyści bazy danych: - Bezpieczeństwo (autoryzacja, audyt) +- Dane niezależne (od aplikacji) +- Skalowalność (replikacja, sharding) +- Mechanizmy integralności (FK, CHECK) egzamin pyt04 BD2 detail +Wyjaśnij: "CIA" dla bezpieczeństwa: - Confidentiality - kto może czytać +- Integrity - kto może zmieniać +- Availability - dostępność usługi egzamin pyt04 BD2 detail +Wyjaśnij: Filozofia STL - Generyczność - szablony (templates) umożliwiają pracę z dowolnymi typami +- Wydajność - zero-overhead abstraction +- Modularność - komponenty są niezależne i wymienne +- Ortogonalność - kontenery i algorytmy są rozdzielone (przez iteratory) egzamin pyt05 PROI detail +Wyjaśnij: Kategorie iteratorów | Kategoria | Operacje | Przykłady kontenerów | +|-----------|----------|---------------------| +| Input | `++`, ``, `==`, `!=` | istream_iterator | +| Output | `++`, `` (zapis) | ostream_iterator | +| Forward | Input + wielokrotne przejście | forward_list, unordered_* | +| Bidirectional | Forward + `--` | list, set, map | +| Random Access | Bidirectional + `+`, `-`, `[]`, `<` | ve egzamin pyt05 PROI detail +Wyjaśnij: "KIAF" dla kategorii STL: - Kontenery - CO przechowujemy +- Iteratory - JAK się poruszamy +- Algorytmy - CO robimy z danymi +- Funktory - JAK parametryzujemy operacje egzamin pyt05 PROI detail +Wyjaśnij: "VLDA" dla kontenerów sekwencyjnych: - Vector - domyślny wybór, tablica dynamiczna +- List - szybkie wstawianie w środku +- Deque - szybki dostęp do obu końców +- Array - stały rozmiar, na stosie egzamin pyt05 PROI detail +Wyjaśnij: "SM-UM" dla asocjacyjnych: - Set/Map - posortowane (drzewo), O(log n) +- Unordered_Map/set - hash, O(1) egzamin pyt05 PROI detail +Wyjaśnij: "SQP" dla adapterów: - Stack - LIFO (stos talerzy) +- Queue - FIFO (kolejka do kasy) +- Priority_queue - VIP (najważniejsi pierwsi) egzamin pyt05 PROI detail +Wyjaśnij: "IOFBRC" dla iteratorów (od najsłabszego): - Input - tylko czytanie, jedno przejście +- Output - tylko pisanie, jedno przejście +- Forward - wielokrotne przejście do przodu +- Bidirectional - do przodu i do tyłu +- Random - skok do dowolnego miejsca +- Contiguous - ciągła pamięć egzamin pyt05 PROI detail +Wyjaśnij: Typy dziedziczenia | Typ | Opis | Języki | +|-----|------|--------| +| Pojedyncze | Jedna klasa bazowa | Java, C# | +| Wielokrotne | Wiele klas bazowych | C++, Python | +| Wielopoziomowe | A → B → C | Wszystkie | +| Hierarchiczne | A → B, A → C | Wszystkie | egzamin pyt06 PROI detail +Wyjaśnij: Zalety i wady dziedziczenia | Zalety | Wady | +|--------|------| +| Naturalne modelowanie hierarchii | Silne wiązanie (tight coupling) | +| Polimorfizm | Problem kruchej klasy bazowej | +| Łatwe rozszerzanie | Problemy z wielodziedziczeniem (diamond) | +| Współdzielenie implementacji | Narusza enkapsulację | egzamin pyt06 PROI detail +Wyjaśnij: Zasada: "Favor composition over inheritance" // DOBRE - kompozycja +class Stack { +private: + std::vector elements; // Stack ZAWIERA wektor + +public: + void push(int x) { elements.push_back(x); } + int pop() { + int top = elements.back(); + elements.pop_back(); + return top; + } + bool empty() const { return elements.empty(); } + // Tylko te metody, które mają sens dla stosu +}; +``` egzamin pyt06 PROI detail +Wyjaśnij: Typy relacji obiektowych | Relacja | Siła | Cykl życia | Przykład | +|---------|------|------------|----------| +| Kompozycja | Silna | Zależny (owns) | Samochód → Silnik | +| Agregacja | Słaba | Niezależny (uses) | Uniwersytet → Student | +| Asocjacja | Luźna | Niezależny | Klient ↔ Zamówienie | egzamin pyt06 PROI detail +Wyjaśnij: Szablony w C++ // Użycie - kompilator generuje wersje dla każdego typu +int m1 = maximum(3, 5); // int +double m2 = maximum(3.14, 2.71); // double +std::string m3 = maximum("abc", "xyz"); // string egzamin pyt06 PROI detail +Wyjaśnij: Generyki w Java/C# // Ograniczenia typów (bounded type parameters) +public > T max(T a, T b) { + return a.compareTo(b) > 0 ? a : b; +} +``` egzamin pyt06 PROI detail +Wyjaśnij: Zalety programowania generycznego | Zaleta | Opis | +|--------|------| +| Type safety | Błędy wykrywane w czasie kompilacji | +| Brak duplikacji | Jeden kod dla wielu typów | +| Wydajność | C++: specjalizacja w kompilacji, brak rzutowania | +| Czytelność | Jawne wymagania typów | egzamin pyt06 PROI detail +Wyjaśnij: Interfejsy vs Klasy abstrakcyjne | Cecha | Interfejs | Klasa abstrakcyjna | +|-------|-----------|-------------------| +| Wielodziedziczenie | TAK | NIE (Java/C#) | +| Pola | NIE (do Java 8) | TAK | +| Konstruktor | NIE | TAK | +| Implementacja metod | default (Java 8+) | TAK | +| Cel | Definiuje kontrakt | Współdzieli implementację | egzamin pyt06 PROI detail +Wyjaśnij: Wzorzec strategii (Strategy Pattern) class QuickSort : public SortStrategy { +public: + void sort(std::vector& data) override { / quicksort / } +}; egzamin pyt06 PROI detail +Wyjaśnij: Wzorce wspierające reużywalność | Wzorzec | Typ | Cel | +|---------|-----|-----| +| Factory Method | Kreacyjny | Delegacja tworzenia obiektów | +| Abstract Factory | Kreacyjny | Rodziny powiązanych obiektów | +| Prototype | Kreacyjny | Klonowanie obiektów | +| Adapter | Strukturalny | Dopasowanie interfejsów | +| Decorator | Strukturalny | Dynamiczne rozszerzanie | +| Strategy | Behawioralny | Wymienne algorytmy egzamin pyt06 PROI detail +Wyjaśnij: "SOLID" - zasady dobrego OOP: - Single Responsibility - jedna odpowiedzialność +- Open/Closed - otwarte na rozszerzenia, zamknięte na modyfikacje +- Liskov Substitution - podtyp zastępuje typ bazowy +- Interface Segregation - wiele małych interfejsów > jeden duży +- Dependency Inversion - zależność od abstrakcji, nie konkretu egzamin pyt06 PROI detail +Wyjaśnij: "HAS-A przed IS-A": - HAS-A = kompozycja (Samochód HAS-A Silnik) +- IS-A = dziedziczenie (Samochód IS-A Pojazd) +- Preferuj HAS-A! egzamin pyt06 PROI detail +Wyjaśnij: "DRIED" dla reużywalności: - Don't Repeat - nie powtarzaj kodu +- Interfaces - definiuj kontrakty +- Encapsulate - ukrywaj szczegóły +- Delegate - przekazuj odpowiedzialność egzamin pyt06 PROI detail +Wyjaśnij: "GIT" dla generyków: - Generic - niezależne od typu +- Invariant - sprawdzane w kompilacji +- Type-safe - bezpieczne typowanie egzamin pyt06 PROI detail +Wyjaśnij: Wprowadzenie do DNS DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin pyt07 SKM detail +Wyjaśnij: 1 Serwery autorytatywne (Authoritative) Definicja: Przechowują oryginalne rekordy DNS dla danej domeny. Są "źródłem prawdy". egzamin pyt07 SKM detail +Wyjaśnij: 2 Serwery rekursywne (Recursive Resolvers) Definicja: Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne. egzamin pyt07 SKM detail +Wyjaśnij: 3 Stub Resolvers (Resolwery klienckie) Definicja: Prosty klient DNS w systemie operacyjnym. Wysyła zapytanie do rekursywnego resolvera i czeka na odpowiedź. egzamin pyt07 SKM detail +Wyjaśnij: 4 Forwarding Servers (Przekazujące) Definicja: Przyjmują zapytania i przekazują je do innego resolvera zamiast samodzielnie rozwiązywać. egzamin pyt07 SKM detail +Wyjaśnij: Zapytanie rekursywne vs iteracyjne ZAPYTANIE ITERACYJNE (resolver → authoritative): +"Co wiesz o www.example.com?" +→ Serwer zwraca odpowiedź lub odesłanie (referral) +``` egzamin pyt07 SKM detail +Wyjaśnij: Jak działa caching? 1. Resolver otrzymuje odpowiedź z serwera autorytatywnego +2. Zapisuje w cache wraz z TTL (Time To Live) +3. Przy kolejnym zapytaniu o tę samą nazwę - zwraca z cache +4. Po wygaśnięciu TTL - pyta ponownie serwer autorytatywny egzamin pyt07 SKM detail +Wyjaśnij: TTL (Time To Live) | Typowe TTL | Zastosowanie | +|------------|--------------| +| 60-300 s | Dynamiczne usługi, failover | +| 3600 s (1h) | Standardowe strony | +| 86400 s (24h) | Stabilne serwisy | +| 604800 s (7d) | Rzadko zmieniane | egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego root servers zyskują najwięcej? Z CACHINGIEM: +┌────────────────────────────────────────────────────────────────┐ +│ Resolver pyta root server RAZ o serwery .com │ +│ Cache przechowuje referral przez długi czas (np. 48h) │ +│ Kolejne tysiące zapytań o .com → z cache, bez root │ +└────────────────────────────────────────────────────────────────┘ +``` egzamin pyt07 SKM detail +Wyjaśnij: Analiza ilościowa | Poziom | Liczba domen | Zapytania bez cache | Z cache | +|--------|--------------|---------------------|---------| +| Root | 1 (.) | ~100% zapytań | ~0.01% | +| TLD | ~1500 | ~100% zapytań | ~0.1% | +| Authoritative | Miliony | Proporcjonalnie | Zależne od TTL | egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego ROOT i TLD zyskują więcej niż authoritative? 1. Mniejsza liczba = więcej zapytań na serwer: + - 13 root servers vs miliony domen + - Każde zapytanie o DOWOLNĄ domenę musi przejść przez root i TLD egzamin pyt07 SKM detail +Wyjaśnij: Podsumowanie zysków z cachingu Root Servers: ████████████████████████████░░ ~99.9% redukcja +TLD Servers: ██████████████████████████░░░░ ~99% redukcja +Authoritative: ████████████░░░░░░░░░░░░░░░░░░ ~50-90% redukcja* egzamin pyt07 SKM detail +Wyjaśnij: "RATS" dla hierarchii DNS: - Root - korzeń drzewa +- Authoritative TLD - .com, .pl... +- Target NS - ns1.example.com +- Stub resolver - klient egzamin pyt07 SKM detail +Wyjaśnij: "ROOT COOL" dla zysków z cache: - ROOT = Cache Offers Overwhelming Load reduction +- Root servers byłyby przeciążone bez cache w resolverach egzamin pyt07 SKM detail +Wyjaśnij: "TRIP" dla procesu rozwiązywania: - Translate - tłumaczenie nazwy na IP +- Recursive - resolver robi pracę +- Iterative - serwery autorytatywne odpowiadają lub odsyłają +- Persist - cache przechowuje wynik egzamin pyt07 SKM detail +Wyjaśnij: Wprowadzenie do TCP TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: +- Niezawodne dostarczanie danych +- Kontrolę przepływu +- Kontrolę przeciążenia +- Połączeniowość (connection-oriented) egzamin pyt08 SKM detail +Wyjaśnij: Cele uzgadniania trójetapowego 1. Nawiązanie połączenia - obie strony zgadzają się na komunikację +2. Synchronizacja numerów sekwencyjnych - ISN (Initial Sequence Number) +3. Uzgodnienie parametrów - MSS, Window Scale, SACK, Timestamps +4. Weryfikacja dostępności - obie strony są aktywne i gotowe egzamin pyt08 SKM detail +Wyjaśnij: Szczegółowy opis kroków #### Krok 1: SYN (Synchronize) +``` +Klient → Serwer: +┌────────────────────────────────────────┐ +│ Flaga: SYN = 1 │ +│ Sequence Number: x (ISN klienta) │ +│ Acknowledgment Number: 0 (nieistotny) │ +│ Opcje: MSS, Window Scale, SACK, etc. │ +└────────────────────────────────────────┘ +``` +- Klient inicjuje połączenie +- Wysyła swój ISN (Initial Sequence Number) +- Stan klient egzamin pyt08 SKM detail +Wyjaśnij: Funkcje numerów sekwencyjnych | Funkcja | Opis | +|---------|------| +| Kolejność | Odbiorca składa segmenty we właściwej kolejności | +| Wykrywanie duplikatów | Ten sam SEQ = duplikat | +| Wykrywanie braków | Luka w SEQ = brakujący segment | +| Potwierdzanie | ACK wskazuje oczekiwany następny SEQ | egzamin pyt08 SKM detail +Wyjaśnij: Dlaczego ISN nie zaczyna od 0? 1. Bezpieczeństwo - przewidywalny ISN umożliwia ataki (TCP hijacking) +2. Unikanie kolizji - stare segmenty z poprzednich połączeń nie będą mylone z nowymi egzamin pyt08 SKM detail +Wyjaśnij: Generowanie ISN #### Historycznie (RFC 793): +``` +ISN = (4 mikrosekundy timer) mod 2^32 +``` +Zwiększany o 1 co 4μs → pełny cykl co ~4.55 godziny egzamin pyt08 SKM detail +Wyjaśnij: Właściwości dobrego ISN | Właściwość | Powód | +|------------|-------| +| Losowy | Utrudnia ataki typu sequence prediction | +| Unikalny | Różny dla każdego połączenia | +| Monotonicznie rosnący | Unikanie kolizji z poprzednimi połączeniami | egzamin pyt08 SKM detail +Wyjaśnij: "SYN-SYN/ACK-ACK" - trzy kroki: - SYN - "Chcę rozmawiać" (klient) +- SYN/ACK - "OK, ja też" (serwer) +- ACK - "Super, zaczynamy" (klient) egzamin pyt08 SKM detail +Wyjaśnij: "ISN = Initial Secret Number": - Initial - początkowy +- Secret - losowy dla bezpieczeństwa +- Number - 32-bitowa liczba egzamin pyt08 SKM detail +Wyjaśnij: TCB (Thread Control Block) | Pole | Opis | +|------|------| +| TID | Identyfikator wątku | +| Stan | Running, Ready, Blocked | +| Rejestry | PC, SP, rejestry ogólne | +| Stos | Wskaźnik do prywatnego stosu | +| Priorytet | Szeregowanie | +| Wskaźnik do PCB | Proces macierzysty | egzamin pyt09 SOI detail +Wyjaśnij: Tabela porównawcza | Cecha | Proces | Wątek | +|-------|--------|-------| +| Przestrzeń adresowa | Własna, izolowana | Współdzielona z procesem | +| Tworzenie | Wolne (~ms) | Szybkie (~μs) | +| Przełączanie kontekstu | Wolne (TLB flush) | Szybkie (tylko rejestry) | +| Komunikacja | IPC (pipe, socket, shm) | Bezpośrednia (współdzielona pamięć) | +| Izolacja | Pełna | Brak (awaria = awaria procesu) | +| * egzamin pyt09 SOI detail +Wyjaśnij: Koszty czasowe (typowe) | Operacja | Czas | +|----------|------| +| Tworzenie procesu | 1-10 ms | +| Tworzenie wątku | 10-100 μs | +| Przełączanie procesu | 1-10 μs | +| Przełączanie wątku | 0.1-1 μs | +| Komunikacja IPC | 1-100 μs | +| Współdzielona pamięć | 10-100 ns | egzamin pyt09 SOI detail +Wyjaśnij: Wątki użytkownika (User-level Threads) Zalety: Szybkie przełączanie, przenośność +Wady: Blokujące wywołanie blokuje wszystkie wątki, brak prawdziwej równoległości egzamin pyt09 SOI detail +Wyjaśnij: Wątki jądra (Kernel-level Threads) Zalety: Prawdziwa równoległość, blokada jednego nie blokuje innych +Wady: Wolniejsze operacje (wywołanie systemowe) egzamin pyt09 SOI detail +Wyjaśnij: Modele mapowania | Model | Opis | Przykłady | +|-------|------|-----------| +| 1:1 | 1 wątek user = 1 wątek kernel | Linux, Windows | +| N:1 | N wątków user = 1 wątek kernel | Green threads | +| M:N | M wątków user = N wątków kernel | Solaris, Go goroutines | egzamin pyt09 SOI detail +Wyjaśnij: Kiedy procesy? - Izolacja - awaria jednego nie wpływa na inne +- Bezpieczeństwo - różne uprawnienia +- Różne języki/technologie - mikrousługi +- Niezawodność - restart bez wpływu na system egzamin pyt09 SOI detail +Wyjaśnij: Kiedy wątki? - Współdzielenie danych - bez kopiowania +- Responsywność - UI thread + worker threads +- Równoległość CPU - obliczenia na wielu rdzeniach +- I/O asynchroniczne - czekanie nie blokuje wszystkiego egzamin pyt09 SOI detail +Wyjaśnij: "PEST" dla różnic Proces-wątek: - Pamięć - proces ma własną, wątek współdzieli +- Efektywność - wątek szybszy +- Synchronizacja - wątki wymagają więcej +- Tworzenie - proces wolniejsze egzamin pyt09 SOI detail +Wyjaśnij: "COFFMAN" dla warunków deadlocka: - Circular wait - cykliczne oczekiwanie +- Only one - mutual exclusion +- Forever hold - hold and wait +- Forced release - no preemption (brak) egzamin pyt09 SOI detail +Wyjaśnij: "PV" dla semafora: - P = Proberen (testuj) = wait = down = dekrementuj +- V = Verhogen (zwiększ) = signal = up = inkrementuj egzamin pyt09 SOI detail +Wyjaśnij: 2 Ochrona pamięci - Proces A nie może czytać/pisać pamięci procesu B +- Jądro chronione przed aplikacjami użytkownika +- Mechanizmy: rejestry bazowy/graniczny, bity ochrony, ringi egzamin pyt10 SOI detail +Wyjaśnij: 3 Relokacja Problem: Program kompilowany z założeniem konkretnych adresów musi działać pod różnymi adresami. egzamin pyt10 SOI detail +Wyjaśnij: Idea Dzielimy pamięć na równe bloki (strony/ramki): +- Strona (Page) - blok pamięci wirtualnej (4KB typowo) +- Ramka (Frame) - blok pamięci fizycznej (ten sam rozmiar) egzamin pyt10 SOI detail +Wyjaśnij: Wielopoziomowe tablice stron Problem: Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = 4MB per proces! egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady stronicowania | Zalety | Wady | +|--------|------| +| Brak fragmentacji zewnętrznej | Fragmentacja wewnętrzna (ostatnia strona) | +| Prosta alokacja (bitmapa ramek) | Narzut tablicy stron | +| Łatwe współdzielenie (COW) | TLB miss kosztowny | +| Pamięć wirtualna naturalna | Nie odpowiada strukturze programu | egzamin pyt10 SOI detail +Wyjaśnij: Ochrona w segmentacji Każdy segment ma prawa dostępu: +- R (Read) - odczyt dozwolony +- W (Write) - zapis dozwolony +- X (Execute) - wykonanie dozwolone egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady segmentacji | Zalety | Wady | +|--------|------| +| Odpowiada strukturze programu | Fragmentacja zewnętrzna | +| Naturalna ochrona (per segment) | Segmenty o zmiennej wielkości | +| Łatwe współdzielenie (cały segment) | Kompaktowanie potrzebne | +| Dynamiczny wzrost segmentów | Skomplikowana alokacja | egzamin pyt10 SOI detail +Wyjaśnij: Zalety hybrydowego podejścia 1. Ochrona z segmentacji (kod vs dane vs stos) +2. Brak fragmentacji zewnętrznej ze stronicowania +3. Pamięć wirtualna ze stronicowania egzamin pyt10 SOI detail +Wyjaśnij: Algorytmy zastępowania stron | Algorytm | Opis | Właściwości | +|----------|------|-------------| +| FIFO | Najstarsza strona | Prosty, anomalia Bélády'ego | +| LRU | Najdawniej używana | Optymalny offline, kosztowny | +| LRU Approximation | Clock, Second Chance | Praktyczny kompromis | +| LFU | Najrzadziej używana | Dobre dla hot data | +| OPT | Najdalej używana | Teoretycznie optymalny, niemożliwy | egzamin pyt10 SOI detail +Wyjaśnij: Elementy Activity Diagrams ┌─────────────────────────────────────────────────────────────────┐ +│ WĘZŁY STERUJĄCE │ +│ │ +│ ● Initial Node (początek) │ +│ ◉ Activity Final (koniec całości) │ +│ ⊗ Flow Final (koniec przepływu) egzamin pyt11 WSYZ detail +Wyjaśnij: Porównanie BPMN vs UML Activity | Cecha | BPMN | UML Activity | +|-------|------|--------------| +| Cel | Procesy biznesowe | Logika oprogramowania | +| Odbiorcy | Analitycy, biznes | Programiści, architekci | +| Swimlanes | Pool/Lane | Partition | +| Zdarzenia | Bogate (timer, message...) | Ograniczone | +| Automatyzacja | BPEL, silniki BPM | Generowanie kodu | egzamin pyt11 WSYZ detail +Wyjaśnij: Reguły EPC 1. Start i koniec: Zdarzenie +2. Naprzemienność: Zdarzenie → Funkcja → Zdarzenie +3. Łączniki: Między zdarzeniami a funkcjami egzamin pyt11 WSYZ detail +Wyjaśnij: Rodzina IDEF | Standard | Nazwa | Zastosowanie | +|----------|-------|--------------| +| IDEF0 | Function Modeling | Hierarchia funkcji | +| IDEF1 | Information Modeling | Struktura danych | +| IDEF1X | Data Modeling | Bazy danych (ERD) | +| IDEF3 | Process Description | Przepływ procesów | +| IDEF4 | Object-Oriented Design | Projektowanie OO | +| IDEF5 | Ontology Description | Ontologie | egzamin pyt11 WSYZ detail +Wyjaśnij: Flowcharts (Schematy blokowe) Zalety: Proste, uniwersalne, znane +Wady: Brak standaryzacji, niewystarczające dla złożonych procesów egzamin pyt11 WSYZ detail +Wyjaśnij: Przegląd narzędzi | Narzędzie | Standardy | Typ | Cena | +|-----------|-----------|-----|------| +| Bizagi Modeler | BPMN | Dedykowane | Free/Paid | +| Camunda Modeler | BPMN, DMN | Open Source | Free | +| Signavio | BPMN, EPC | Cloud | Paid | +| ARIS | EPC, BPMN | Enterprise | Paid | +| Enterprise Architect | UML, BPMN | Uniwersalne | Paid | +| Lucidchart | Wszystkie | Cloud | Free/Paid | +| **draw egzamin pyt11 WSYZ detail +Wyjaśnij: Funkcjonalności narzędzi | Funkcja | Podstawowe | Zaawansowane | +|---------|------------|--------------| +| Modelowanie graficzne | ✓ | ✓ | +| Walidacja modelu | ✗ | ✓ | +| Symulacja | ✗ | ✓ | +| Wykonywanie (engine) | ✗ | ✓ | +| Eksport (XML, PDF) | ✓ | ✓ | +| Współpraca | ✗/Cloud | ✓ | +| Integracja z IT | ✗ | ✓ | egzamin pyt11 WSYZ detail +Wyjaśnij: "BPMN = Business Process Modeling Notation": - Biznesowe procesy +- Pule i tory (swimlanes) +- Modele graficzne + XML +- Notacja standardowa (OMG) egzamin pyt11 WSYZ detail +Wyjaśnij: "ICOM" dla IDEF0: - Input - co wchodzi +- Control - co kontroluje +- Output - co wychodzi +- Mechanism - kto/co wykonuje egzamin pyt11 WSYZ detail +Wyjaśnij: "Bramki BPMN - X AND OR": - X (XOR) - wyłącznie jedna ścieżka +- AND (+) - wszystkie ścieżki +- OR (○) - jedna lub więcej egzamin pyt11 WSYZ detail +Wyjaśnij: Algorytmy | Algorytm | Złożoność | Wagi ujemne | Zastosowanie | +|----------|-----------|-------------|--------------| +| Dijkstra | O(V² lub E log V) | ❌ | GPS, routing | +| Bellman-Ford | O(VE) | ✅ | Finanse, arbitraż | +| A* | O(E) średnio | ❌ | Gry, nawigacja | egzamin pyt12 WSYZ detail +Wyjaśnij: Zastosowania - Transport towarów (minimalizacja kosztów) +- Przydział zadań pracownikom +- Optymalizacja łańcucha dostaw egzamin pyt12 WSYZ detail +Wyjaśnij: Właściwości - NP-trudny - brak algorytmu wielomianowego +- Dokładne: Branch & Bound, programowanie dynamiczne +- Heurystyki: Nearest Neighbor, 2-opt, symulowane wyżarzanie egzamin pyt12 WSYZ detail +Wyjaśnij: "SPAM-CT" - modele sieciowe: - Shortest Path +- Przepływ (Max Flow) +- Assignment +- MST +- CPM/PERT +- TSP egzamin pyt12 WSYZ detail +Wyjaśnij: Q1: "Jaka jest różnica między CPM a PERT?" Odpowiedź: CPM używa deterministycznych czasów (znanych), PERT używa trzech estymacji (optymistyczna, najbardziej prawdopodobna, pesymistyczna) i rozkładu beta. CPM dla projektów powtarzalnych, PERT dla R&D z niepewnością. egzamin pyt12 WSYZ detail +Wyjaśnij: Q2: "Kiedy stosować heurystyki zamiast algorytmów dokładnych?" Odpowiedź: Gdy problem jest NP-trudny (TSP) lub dane wejściowe bardzo duże. Heurystyki dają "dość dobre" rozwiązanie w rozsądnym czasie. Przykład: 2-opt dla TSP daje rozwiązanie ~5% od optimum w O(n²). egzamin pyt12 WSYZ detail +Wyjaśnij: Q3: "Co to jest slack/float w CPM?" Odpowiedź: Zapas czasu zadania = najpóźniejszy start − najwcześniejszy start. Zadania na ścieżce krytycznej mają slack=0 (opóźnienie opóźni cały projekt). egzamin pyt12 WSYZ detail +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora.
  • Definicje fundamentalne
  • Agent vs Aktor
  • Architektury agentów
  • Standardy komunikacji agentów
  • Narzędzia i frameworki
  • Protokoły interakcji
egzamin pyt13 AASD main +Wyjaśnij: Definicje fundamentalne #### Agent (wg Wooldridge & Jennings) +Agent = system komputerowy umieszczony w środowisku, zdolny do autonomicznego działania w celu realizacji celów. egzamin pyt13 AASD detail +Wyjaśnij: Agent vs Aktor | Cecha | Agent | Aktor | +|-------|-------|-------| +| Cel | Inteligentne zachowanie | Współbieżność | +| Stan | Beliefs, Goals, Intentions | Prywatny, izolowany | +| Komunikacja | ACL (semantyka) | Wiadomości (asynchroniczne) | +| Autonomia | Wysoka (decyzje) | Średnia (reaktywność) | +| Pochodzenie | AI, systemy rozproszone | Teoria obliczeń | egzamin pyt13 AASD detail +Wyjaśnij: "BDI = Believe, Desire, Intend": - Beliefs = co wiem o świecie +- Desires = czego chcę +- Intentions = co zamierzam zrobić egzamin pyt13 AASD detail +Wyjaśnij: Q1: "Czym różni się JADE od Akka?" Odpowiedź: JADE to framework agentowy (FIPA, ACL, inteligentne zachowania), Akka to framework aktorowy (współbieżność, fault-tolerance, reactive streams). JADE dla AI/MAS, Akka dla systemów rozproszonych. egzamin pyt13 AASD detail +Wyjaśnij: Q2: "Co to jest Yellow Pages w systemach agentowych?" Odpowiedź: Usługa katalogowa (Directory Facilitator w FIPA) gdzie agenty rejestrują swoje usługi. Inne agenty mogą wyszukiwać agenty oferujące konkretne usługi. Analogia do książki telefonicznej. egzamin pyt13 AASD detail +Wyjaśnij: Q3: "Jak Akka zapewnia fault-tolerance?" Odpowiedź: Supervision trees - każdy aktor ma supervisora, który decyduje o reakcji na błąd (restart, stop, eskaluj). "Let it crash" philosophy - izolacja błędów. egzamin pyt13 AASD detail +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych.
  • Algorytmy negocjacji i aukcji
  • Algorytmy konsensusu
  • Algorytmy koordynacji
  • Algorytmy uczenia wieloagentowego
  • Algorytmy dla aktorów
  • Algorytmy planowania (BDI)
egzamin pyt14 AASD main +Wyjaśnij: Q1: "Dlaczego aukcja Vickreya jest truthful?" Odpowiedź: Płacisz drugą najwyższą cenę, nie swoją. Licytowanie poniżej wartości = ryzyko przegranej. Licytowanie powyżej = ryzyko przepłacenia. Optymalna strategia = licytuj prawdziwą wartość. egzamin pyt14 AASD detail +Wyjaśnij: Q2: "Jak Raft radzi sobie z partycją sieci?" Odpowiedź: Tylko partycja z większością węzłów może wybrać lidera i commitować. Mniejszość jest zablokowana (read-only lub niedostępna). Po naprawie partycji - synchronizacja logów. egzamin pyt14 AASD detail +Wyjaśnij: Q3: "Czym różni się One-for-One od All-for-One supervision?" Odpowiedź: One-for-One: restart tylko wadliwego aktora (izolacja błędu). All-for-One: restart wszystkich dzieci (gdy stan jest współdzielony/zależny). Wybór zależy od zależności między aktorami. egzamin pyt14 AASD detail +Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury.
  • Cele modelowania architektury
  • Frameworki architektoniczne
  • Notacje i języki modelowania
  • ADR (Architecture Decision Records)
egzamin pyt15 AIS main +Wyjaśnij: Cele modelowania architektury | Cel | Opis | +|-----|------| +| Komunikacja | Wspólny język dla stakeholderów | +| Dokumentacja | Zapis decyzji architektonicznych | +| Analiza | Weryfikacja atrybutów jakościowych | +| Planowanie | Roadmapa rozwoju systemu | +| Zarządzanie złożonością | Abstrakcja, dekompozycja | egzamin pyt15 AIS detail +Wyjaśnij: Q1: "Jaka jest różnica między TOGAF a Zachman?" Odpowiedź: TOGAF to metodyka (proces ADM), Zachman to taksonomia (klasyfikacja artefaktów). TOGAF mówi JAK tworzyć architekturę, Zachman CO dokumentować. egzamin pyt15 AIS detail +Wyjaśnij: Q2: "Kiedy używać C4 vs ArchiMate?" Odpowiedź: C4 dla programistów (proste, 4 poziomy), ArchiMate dla enterprise architects (formalne, warstwy biznes-aplikacja-technologia). egzamin pyt15 AIS detail +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne.
  • Cel wzorców architektonicznych
  • Jak powstają wzorce
  • Katalogowanie wzorców
  • Przykładowe wzorce architektoniczne
  • Porównanie wzorców
egzamin pyt16 AIS main +Wyjaśnij: Cel wzorców architektonicznych | Cel | Opis | +|-----|------| +| Reużywalność | Sprawdzone rozwiązania typowych problemów | +| Komunikacja | Wspólne słownictwo ("używamy MVC") | +| Dokumentacja | Zapis wiedzy architektonicznej | +| Jakość | Adresowanie atrybutów jakościowych | +| Edukacja | Nauka z doświadczeń innych | egzamin pyt16 AIS detail +Wyjaśnij: Jak powstają wzorce Format opisu wzorca: +- Nazwa - identyfikator +- Kontekst - kiedy stosować +- Problem - co rozwiązuje +- Rozwiązanie - struktura i zachowanie +- Konsekwencje - trade-offs +- Znane zastosowania - przykłady egzamin pyt16 AIS detail +Wyjaśnij: Katalogowanie wzorców | Katalog | Zakres | Przykłady | +|---------|--------|-----------| +| POSA (Pattern-Oriented Software Architecture) | Architektura | Layers, Pipes&Filters | +| GoF (Gang of Four) | Projektowe | Factory, Observer | +| EIP (Enterprise Integration Patterns) | Integracja | Message Router, Aggregator | +| PoEAA (Fowler) | Enterprise | Repository, Unit of Work | +| Cloud Patterns | Chmura egzamin pyt16 AIS detail +Wyjaśnij: Porównanie wzorców | Wzorzec | Skalowalność | Złożoność | Use Case | +|---------|--------------|-----------|----------| +| Monolith | Niska | Niska | MVP, małe zespoły | +| Layered | Średnia | Niska | Enterprise CRUD | +| Microservices | Wysoka | Wysoka | Duże systemy | +| Event-Driven | Wysoka | Średnia | Real-time, IoT | +| CQRS | Wysoka | Wysoka | Read-heavy systems | egzamin pyt16 AIS detail +Wyjaśnij: Q1: "Kiedy wybrać monolith zamiast microservices?" Odpowiedź: Mały zespół (<10), MVP, niejasne granice domen, brak DevOps maturity. "Monolith first" - rozdzielaj gdy wiesz gdzie granice. egzamin pyt16 AIS detail +Wyjaśnij: Q2: "Jak CQRS współpracuje z Event Sourcing?" Odpowiedź: Event Sourcing zapisuje zdarzenia (nie stan), CQRS buduje read model z eventów. Razem: audit trail, time-travel, ale złożoność. egzamin pyt16 AIS detail +Wyjaśnij: Q3: "Co to jest Strangler Fig Pattern?" Odpowiedź: Migracja z monolitu do microservices. Nowe funkcje jako mikroserwisy, stare stopniowo zastępowane. Routing przez facade. Nazwa od figi dusiciela. egzamin pyt16 AIS detail +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej.
  • Optymalizacja bez ograniczeń
  • Optymalizacja z ograniczeniami
  • Warunki KKT (Karush-Kuhn-Tucker)
  • Warunki regularności (Constraint Qualification)
  • Warunki dostateczne II rzędu
  • Metody optymalizacji nieliniowej
egzamin pyt17 AMO main +Wyjaśnij: Optymalizacja z ograniczeniami #### Problem ogólny +$$\min_{x} f(x)$$ +$$\text{s.t. } g_i(x) \leq 0, \quad i = 1, \ldots, m$$ +$$\quad\quad h_j(x) = 0, \quad j = 1, \ldots, p$$ egzamin pyt17 AMO detail +Wyjaśnij: Warunki dostateczne II rzędu Jeśli spełnione KKT i dla hesjanu Lagrangianu: +$$d^T \nabla_{xx}^2 L(x^, \lambda^, \mu^*) d > 0$$ egzamin pyt17 AMO detail +Wyjaśnij: Porównanie metod | Metoda | Ograniczenia | Złożoność iter. | Zbieżność | +|--------|--------------|-----------------|-----------| +| Gradient | Bez | O(n) | Liniowa | +| Newton | Bez | O(n³) | Kwadratowa | +| BFGS | Bez | O(n²) | Superlinearna | +| SQP | Z | O(n³) per QP | Superlinearna | +| Interior Point | Z | O(n³) | Polinomialna | egzamin pyt17 AMO detail +Wyjaśnij: "KKT = Keep Killing Troubles": - Kondycja stacjonarności (∇L = 0) +- Konieczność dopuszczalności (g ≤ 0, h = 0, λ ≥ 0) +- Trick komplementarności (λg = 0) egzamin pyt17 AMO detail +Wyjaśnij: Q1: "Co oznacza warunek komplementarności λᵢgᵢ = 0?" Odpowiedź: Albo ograniczenie nieaktywne ($g_i < 0$, wtedy $\lambda_i = 0$), albo aktywne ($g_i = 0$, wtedy $\lambda_i \geq 0$). Mnożnik niezerowy tylko dla "ciasnych" ograniczeń. egzamin pyt17 AMO detail +Wyjaśnij: Q2: "Kiedy KKT są warunkami dostatecznymi?" Odpowiedź: Dla problemów wypukłych (f wypukła, g wypukłe, h liniowe). Wtedy każdy punkt KKT jest globalnym minimum. egzamin pyt17 AMO detail +Wyjaśnij: Q3: "Jaka jest przewaga BFGS nad Newtonem?" Odpowiedź: BFGS nie wymaga obliczania hesjanu (tylko gradienty), przybliża hesjan iteracyjnie. O(n²) zamiast O(n³) per iteracja. Bardziej odporny na nieścisłości. egzamin pyt17 AMO detail +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji.
  • Programowanie liniowe (LP)
  • Programowanie kwadratowe (QP)
  • Metody rozwiązywania QP
  • Przypadki szczególne
  • Narzędzia
egzamin pyt18 AMO main +Wyjaśnij: Przypadki szczególne #### Least Squares (najmniejsze kwadraty) +$$\min \|Ax - b\|_2^2 = \min x^T A^T A x - 2b^T A x + b^T b$$ egzamin pyt18 AMO detail +Wyjaśnij: Narzędzia | Narzędzie | Typ | Metody | +|-----------|-----|--------| +| CPLEX | Komercyjny | Simplex, Barrier, QP | +| Gurobi | Komercyjny | Simplex, Barrier, QP | +| GLPK | Open source | Simplex | +| OSQP | Open source | ADMM dla QP | +| CVXPY | Python | Interfejs do solverów | egzamin pyt18 AMO detail +Wyjaśnij: Q1: "Kiedy Simplex jest lepszy od Interior Point?" Odpowiedź: Małe/średnie problemy, warm start (sekwencja podobnych LP), potrzeba rozwiązania bazowego. Interior Point lepszy dla bardzo dużych, rzadkich problemów. egzamin pyt18 AMO detail +Wyjaśnij: Q2: "Co to jest dualność w LP?" Odpowiedź: Każdy LP (primal) ma dual. Silna dualność: opt(primal) = opt(dual). Mnożniki Lagrange'a = zmienne dualne. Complementary slackness: x_i > 0 ⟹ ograniczenie dualne aktywne. egzamin pyt18 AMO detail +Wyjaśnij: Q3: "Jak rozwiązać niewypukły QP?" Odpowiedź: NP-trudny, metody: Branch & Bound, SDP relaxation, lokalne metody (wiele startów). Brak gwarancji globalnego optimum w czasie wielomianowym. egzamin pyt18 AMO detail +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji).
  • Cel parametryzacji mowy
  • MFCC (Mel-Frequency Cepstral Coefficients)
  • LPC (Linear Predictive Coding)
  • Porównanie MFCC vs LPC
  • Rozszerzenia
egzamin pyt19 EASAR main +Wyjaśnij: Cel parametryzacji mowy - Redukcja wymiarowości: 16kHz × 16bit → ~13-40 cech/ramkę +- Ekstrakcja informacji fonetycznej +- Usunięcie informacji mówcy (częściowo) +- Reprezentacja kompaktowa dla modeli (HMM, DNN) egzamin pyt19 EASAR detail +Wyjaśnij: Porównanie MFCC vs LPC | Cecha | MFCC | LPC | +|-------|------|-----| +| Podstawa | Percepcja słuchowa | Model produkcji mowy | +| Filtracja | Bank filtrów Mel | Model all-pole | +| Wymiarowość | 12-13 + delty | 10-20 | +| Zastosowanie | Rozpoznawanie mowy | Kodowanie, synteza | +| Korelacja | Niska (DCT dekoreluje) | Wysoka | +| Interpolacja | Trudna | Łatwa (LSF) | egzamin pyt19 EASAR detail +Wyjaśnij: Rozszerzenia #### PLP (Perceptual Linear Prediction) +Łączy LPC z percepcją słuchową: +- Filtracja w skali Bark +- Krzywa równej głośności +- Kompresja intensity-loudness egzamin pyt19 EASAR detail +Wyjaśnij: Q1: "Dlaczego używamy skali Mel?" Odpowiedź: Percepcja częstotliwości przez człowieka jest logarytmiczna. Różnica 100-200Hz jest bardziej słyszalna niż 4000-4100Hz. Mel modeluje tę nieliniowość. egzamin pyt19 EASAR detail +Wyjaśnij: Q2: "Co to jest cepstrum?" Odpowiedź: "Widmo widma" - IFFT(log(|FFT(x)|)). Rozdziela pobudzenie (pitch) od filtra (formantów). MFCC używa DCT zamiast IFFT dla lepszych właściwości. egzamin pyt19 EASAR detail +Wyjaśnij: Q3: "Dlaczego LPC jest używane w kodowaniu mowy (CELP)?" Odpowiedź: Kompaktowa reprezentacja (~10 współczynników). Łatwa interpolacja (LSF). Efektywna synteza (filtr IIR). Standard w GSM, VoIP. egzamin pyt19 EASAR detail +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych.
  • System rozpoznawania mowy - architektura
  • HMM (Hidden Markov Model) - klasyczne podejście
  • Deep Learning w rozpoznawaniu mowy
  • Porównanie HMM vs DNN
  • Ewolucja wydajności
egzamin pyt20 EASAR main +Wyjaśnij: Porównanie HMM vs DNN | Aspekt | GMM-HMM | DNN-HMM | End-to-End | +|--------|---------|---------|------------| +| Model akustyczny | GMM | DNN | DNN | +| Model czasowy | HMM | HMM | CTC/Attention | +| Wyrównanie | Viterbi | Viterbi | Uczone/CTC | +| Trening | EM (Baum-Welch) | Backprop | Backprop | +| Interpretowalność | Wysoka | Średnia | Niska | +| Dane treningowe | Małe | Średnie | Duże | +| **WER (W egzamin pyt20 EASAR detail +Wyjaśnij: Ewolucja wydajności Rok Model WER +2010 GMM-HMM ~18% +2012 DNN-HMM ~12% +2015 LSTM-HMM ~8% +2017 LAS (Seq2Seq) ~6% +2020 Conformer ~4% +2023 Whisper Large ~3% + Poziom ludzki ~4% +``` egzamin pyt20 EASAR detail +Wyjaśnij: Q1: "Co to jest forced alignment?" Odpowiedź: Viterbi z ograniczeniem do znanej transkrypcji. Wyznacza granice czasowe fonemów/słów. Używane do tworzenia danych treningowych i TTS. egzamin pyt20 EASAR detail +Wyjaśnij: Q2: "Dlaczego DNN jest lepszy od GMM?" Odpowiedź: DNN może modelować złożone, nieliniowe zależności. GMM zakłada mieszaninę Gaussianów (często niewystarczające). DNN korzysta z kontekstu (wiele ramek na wejściu). egzamin pyt20 EASAR detail +Wyjaśnij: Q3: "Co to jest language model fusion?" Odpowiedź: Łączenie modelu akustycznego z językowym: P(W|O) ∝ P(O|W)·P(W)^α. Shallow fusion (podczas dekodowania) lub deep fusion (wspólny trening). egzamin pyt20 EASAR detail +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów?
  • Agent upostaciowiony (Embodied Agent)
  • Specyfikacja sterownika robota
  • Formalny model agenta
  • Zastosowanie w ROS (Robot Operating System)
  • Hybrydowa architektura 3T
  • Korzyści podejścia agentowego
egzamin pyt21 ERPM main +Wyjaśnij: Korzyści podejścia agentowego | Korzyść | Opis | +|---------|------| +| Modularność | Rozdzielenie percepcji, decyzji, akcji | +| Abstrakcja | Ukrycie szczegółów sprzętu | +| Autonomia | Robot sam decyduje o działaniach | +| Reużywalność | Zachowania przenośne między platformami | +| Weryfikowalność | Formalna specyfikacja → model checking | egzamin pyt21 ERPM detail +Wyjaśnij: Q1: "Czym różni się agent reaktywny od deliberatywnego?" Odpowiedź: Reaktywny: bezpośrednia reakcja sensor→akcja (np. unikanie kolizji), bez planowania. Deliberatywny: model świata, planowanie, cel. Hybryda łączy oba. egzamin pyt21 ERPM detail +Wyjaśnij: Q2: "Co to jest subsumption architecture?" Odpowiedź: Architektura Brooksa - warstwy zachowań, wyższe mogą "nadpisać" niższe. Bez centralnego modelu świata. Skuteczna dla prostych robotów mobilnych. egzamin pyt21 ERPM detail +Wyjaśnij: Q3: "Jak weryfikować poprawność sterownika agentowego?" Odpowiedź: Model checking (SPIN, NuSMV), symulacja (Gazebo), formalna specyfikacja (LTL, CTL), testy jednostkowe zachowań, testy integracyjne w symulacji przed wdrożeniem na sprzęt. egzamin pyt21 ERPM detail +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację.
  • Klasyfikacja języków programowania robotów
  • Klasyfikacja wg metody programowania
  • Języki producentów robotów przemysłowych
  • Porównanie języków producentów
  • Języki uniwersalne i frameworki
  • Języki graficzne
egzamin pyt22 ERPM main +Wyjaśnij: Klasyfikacja wg metody programowania | Metoda | Opis | Przykłady | +|--------|------|-----------| +| Online (Teach-in) | Programowanie przez demonstrację | Pendant, prowadzenie ręczne | +| Offline | Programowanie bez robota | Symulacja, CAD/CAM | +| Tekstowe | Kod źródłowy | RAPID, KRL, Karel | +| Graficzne | Bloki, flowcharty | Blockly, ROBOGUIDE | egzamin pyt22 ERPM detail +Wyjaśnij: Porównanie języków producentów | Cecha | RAPID (ABB) | KRL (KUKA) | Karel (FANUC) | +|-------|-------------|------------|---------------| +| Paradygmat | Proceduralny | Proceduralny | Proceduralny | +| Typy ruchów | MoveJ, MoveL, MoveC | PTP, LIN, CIRC | MOVE TO | +| Zmienne | VAR, PERS, CONST | DECL | VAR | +| I/O | SetDO, WaitDI | $OUT[], $IN[] | DOUT[], DIN[] | +| Wielozadaniowość | Tak (TASK) | Tak (SUBMIT) | egzamin pyt22 ERPM detail +Wyjaśnij: Języki graficzne | Narzędzie | Producent | Opis | +|-----------|-----------|------| +| RobotStudio | ABB | RAPID + symulacja 3D | +| KUKA.Sim | KUKA | KRL + symulacja | +| ROBOGUIDE | FANUC | Karel + symulacja | +| Blockly | Google | Programowanie wizualne (edukacja) | +| Scratch for Robots | MIT | Edukacja, LEGO, mBot | egzamin pyt22 ERPM detail +Wyjaśnij: Q1: "Czym różni się ruch PTP od LIN?" Odpowiedź: PTP (Point-to-Point) = ruch w przestrzeni złączy, najszybszy ale trajektoria TCP nieprzewidywalna. LIN (Linear) = ruch liniowy TCP, wolniejszy ale precyzyjna ścieżka. LIN wymaga rozwiązania kinematyki odwrotnej w każdym punkcie. egzamin pyt22 ERPM detail +Wyjaśnij: Q2: "Dlaczego każdy producent ma własny język?" Odpowiedź: Historyczne (lata 80-90), integracja ze sterownikiem, optymalizacja dla konkretnego sprzętu, vendor lock-in. ROS próbuje to ujednolicić, ale nie dla real-time. egzamin pyt22 ERPM detail +Wyjaśnij: Q3: "Co to jest Teach Pendant?" Odpowiedź: Przenośny panel do programowania online. Przyciski ruchu (jog), zapis punktów, edycja programu. Tryb manualny (bezpieczny) vs automatyczny. egzamin pyt22 ERPM detail +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych.
  • Problem czasu w systemach rozproszonych
  • Relacja "happened-before" (Lamport)
  • Zegar Lamporta (Scalar Clock)
  • Zegary wektorowe (Vector Clocks)
  • Porównanie
  • Zastosowania
egzamin pyt23 ERSMS main +Wyjaśnij: Problem czasu w systemach rozproszonych Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji. egzamin pyt23 ERSMS detail +Wyjaśnij: Porównanie | Cecha | Lamport | Vector Clock | +|-------|---------|--------------| +| Rozmiar | O(1) | O(N) | +| a → b ⟹ C(a) < C(b) | ✅ | ✅ | +| C(a) < C(b) ⟹ a → b | ❌ | ✅ | +| Wykrycie współbieżności | ❌ | ✅ | +| Zastosowanie | Uporządkowanie | Wykrywanie konfliktów | egzamin pyt23 ERSMS detail +Wyjaśnij: Warianty i rozszerzenia | Wariant | Opis | +|---------|------| +| Interval Tree Clocks | Dynamiczna liczba procesów | +| Bloom Clocks | Probabilistyczne, kompaktowe | +| Hybrid Logical Clocks | Lamport + czas fizyczny | +| Matrix Clocks | Wiedza o wiedzy innych | egzamin pyt23 ERSMS detail +Wyjaśnij: Q1: "Dlaczego nie używać NTP zamiast zegarów logicznych?" Odpowiedź: NTP ma błąd ~ms (LAN) do ~100ms (WAN). Dla zdarzeń szybszych niż błąd synchronizacji, kolejność fizyczna jest nieznana. Zegary logiczne dają gwarancje przyczynowe bez względu na drift. egzamin pyt23 ERSMS detail +Wyjaśnij: Q2: "Co to jest causal consistency?" Odpowiedź: Model spójności gdzie zapisy przyczynowo zależne są widziane w tej samej kolejności przez wszystkich. Wymaga vector clocks. Słabszy niż sequential consistency, silniejszy niż eventual. egzamin pyt23 ERSMS detail +Wyjaśnij: Q3: "Problem skalowalności vector clocks?" Odpowiedź: O(N) rozmiar dla N procesów. Rozwiązania: przycinanie (Dynamo), Interval Tree Clocks (dynamiczne ID), Bloom clocks (probabilistyczne). egzamin pyt23 ERSMS detail +Omówić silne i słabe modele spójności danych w środowisku rozproszonym.
  • Problem spójności w systemach rozproszonych
  • Spektrum modeli spójności
  • Silne modele spójności
  • Słabe modele spójności
  • CAP Theorem
  • Porównanie modeli
egzamin pyt24 ERSMS main +Wyjaśnij: Porównanie modeli | Model | Gwarancje | Wydajność | Przykłady | +|-------|-----------|-----------|-----------| +| Linearizable | Najsilniejsze | Niska | Spanner, CockroachDB | +| Sequential | Silne | Średnia | Zookeeper | +| Causal | Przyczynowe | Dobra | COPS, MongoDB | +| Session | Per-sesja | Dobra | Dynamo sessions | +| Eventual | Najsłabsze | Najwyższa | DNS, Cassandra | egzamin pyt24 ERSMS detail +Wyjaśnij: Strategie rozwiązywania konfliktów #### Last-Writer-Wins (LWW) +``` +Konflikt: write(x=1) || write(x=2) +Rozwiązanie: Większy timestamp wygrywa +Problem: Utrata danych! +``` egzamin pyt24 ERSMS detail +Wyjaśnij: Q1: "Czym różni się linearizability od serializability?" Odpowiedź: Linearizability = dla pojedynczych operacji, real-time ordering. Serializability = dla transakcji, jakiś serial order. Strict serializability = oba razem. egzamin pyt24 ERSMS detail +Wyjaśnij: Q2: "Kiedy wybrać eventual consistency?" Odpowiedź: Wysoka dostępność ważniejsza niż spójność, tolerancja na stale reads, możliwość rozwiązania konfliktów (shopping cart, likes counter, DNS). egzamin pyt24 ERSMS detail +Wyjaśnij: Q3: "Co to jest Quorum?" Odpowiedź: W = write quorum, R = read quorum, N = repliki. W + R > N gwarantuje odczyt najnowszej wartości. Dynamo: N=3, W=2, R=2. egzamin pyt24 ERSMS detail +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność.
  • Definicja MIP (Mixed Integer Programming)
  • Zastosowania
  • Przykład: Problem plecakowy (Knapsack)
  • Metody rozwiązywania
  • Branch and Bound (B&B) - metoda dokładna
  • Czynniki wpływające na efektywność B&B
egzamin pyt25 MOD main +Wyjaśnij: Definicja MIP (Mixed Integer Programming) min c^T x +s.t. Ax ≤ b + x_i ∈ Z dla i ∈ I (zmienne całkowite) + x_j ∈ R dla j ∈ J (zmienne ciągłe) + x ≥ 0 egzamin pyt25 MOD detail +Wyjaśnij: Metody rozwiązywania | Metoda | Typ | Gwarancja optimum | +|--------|-----|-------------------| +| Branch and Bound | Dokładna | ✅ | +| Branch and Cut | Dokładna | ✅ | +| Branch and Price | Dokładna | ✅ | +| Cutting Planes | Dokładna | ✅ | +| Heurystyki | Przybliżona | ❌ | +| Metaheurystyki | Przybliżona | ❌ | egzamin pyt25 MOD detail +Wyjaśnij: Czynniki wpływające na efektywność B&B | Czynnik | Wpływ | Strategie | +|---------|-------|-----------| +| Jakość relaksacji | Lepsza → mniej węzłów | Silne formulacje, cutting planes | +| Wybór zmiennej do branch | Balans drzewa | Most fractional, strong branching | +| Wybór węzła | DFS vs BFS | Best-first (best bound) | +| Przerywanie | Jakość incumbent | Heurystyki, warm start | +| Symetria | Wiele równoważnych rozw. | egzamin pyt25 MOD detail +Wyjaśnij: Ulepszenia: Branch and Cut W każdym węźle: +1. Rozwiąż LP relaksację +2. Jeśli rozwiązanie niecałkowite: + - Generuj cięcia (Gomory, Cover, Clique...) + - Dodaj cięcia do LP + - Powtórz do limitu +3. Jeśli nadal niecałkowite → branch egzamin pyt25 MOD detail +Wyjaśnij: Q1: "Co to jest integrality gap?" Odpowiedź: Różnica między optimum LP (relaksacja) a optimum IP. Mała luka = silna formulacja = szybki B&B. Gap = (LP_opt - IP_opt) / IP_opt. egzamin pyt25 MOD detail +Wyjaśnij: Q2: "Kiedy B&B jest nieefektywny?" Odpowiedź: Słaba relaksacja (duży gap), dużo symetrii, wiele prawie równoważnych rozwiązań. Wtedy: miliony węzłów, długi czas. Rozwiązanie: silniejsze formulacje, symmetry breaking, heurystyki. egzamin pyt25 MOD detail +Wyjaśnij: Q3: "Co to jest cięcie Gomory'ego?" Odpowiedź: Automatycznie generowane cięcie z tablicy simplex. Odcina aktualne rozwiązanie LP bez odcinania punktów całkowitych. Słabe dla dużych problemów, lepsze: cover cuts, clique cuts dla konkretnych struktur. egzamin pyt25 MOD detail +Scharakteryzować informatyczne narzędzia optymalizacji dyskretnej. Jakie są warunki i wymagania, jakie możliwości oraz trudności wiążą się ze stosowaniem gotowych narzędzi.
  • Kategorie narzędzi
  • Solvery MIP
  • Porównanie wydajności (benchmark)
  • Solvery Constraint Programming
  • Kiedy CP vs MIP?
  • Języki modelowania
egzamin pyt26 MOD main +Wyjaśnij: Solvery MIP | Solver | Licencja | Cechy | +|--------|----------|-------| +| CPLEX | Komercyjny (IBM) | Najszybszy dla dużych MIP | +| Gurobi | Komercyjny (academic free) | Bardzo szybki, dobry API | +| SCIP | Open source (ZIB) | Framework extensible | +| CBC | Open source (COIN-OR) | Dobry darmowy solver | +| HiGHS | Open source | Nowoczesny, szybki LP/MIP | +| GLPK | Open source | Prosty, po egzamin pyt26 MOD detail +Wyjaśnij: Porównanie wydajności (benchmark) CPLEX ████████████████████████████ 100% +Gurobi ███████████████████████████ 98% +SCIP ████████████████ 60% +CBC ████████████ 45% +GLPK ████████ 30% +``` egzamin pyt26 MOD detail +Wyjaśnij: Solvery Constraint Programming | Solver | Język | Cechy | +|--------|-------|-------| +| CP-SAT | Python/C++ | Google, bardzo szybki | +| Gecode | C++ | Akademicki, elastyczny | +| Chuffed | MiniZinc | Lazy clause generation | +| OR-Tools | Multi | Google, CP + routing + MIP | egzamin pyt26 MOD detail +Wyjaśnij: Kiedy CP vs MIP? | Aspekt | MIP | CP | +|--------|-----|-----| +| Ograniczenia globalne | Słabo | Świetnie (alldiff, cumulative) | +| Relaksacja | LP (silna) | Słabsza | +| Scheduling | Średnio | Świetnie | +| Kombinatoryczne | Dobrze | Bardzo dobrze | egzamin pyt26 MOD detail +Wyjaśnij: Warunki i wymagania | Wymaganie | Opis | +|-----------|------| +| Licencja | Komercyjne (CPLEX, Gurobi) vs Open source | +| API/Język | Python, C++, Java, Julia | +| Format modelu | MPS, LP, AMPL, własny | +| Pamięć | Duże modele = duże wymagania RAM | +| Wielowątkowość | Parallel B&B, concurrent LP | egzamin pyt26 MOD detail +Wyjaśnij: Możliwości | Możliwość | Opis | +|-----------|------| +| Gwarancja optimum | Metody dokładne (B&B, B&C) | +| Gap tracking | Śledzenie jakości rozwiązania | +| Callbacks | Własne cięcia, heurystyki, lazy constraints | +| Warm start | Start od znanego rozwiązania | +| Tuning | Automatyczne dostrajanie parametrów | +| Solution pool | Wiele rozwiązań (k-best) | egzamin pyt26 MOD detail +Wyjaśnij: Trudności | Trudność | Opis | Rozwiązanie | +|----------|------|-------------| +| Czas obliczeń | NP-trudność | Heurystyki, time limit | +| Słaba formulacja | Duży integrality gap | Silniejsze modele, cięcia | +| Symetria | Wiele równoważnych rozw. | Symmetry breaking | +| Numeryka | Błędy zaokrągleń | Tolerancje, scaling | +| Pamięć | Duże drzewa B&B | Limity węzłów, DFS | +| Debugowanie | egzamin pyt26 MOD detail +Wyjaśnij: Q1: "Kiedy używać metaheurystyk zamiast solverów?" Odpowiedź: Bardzo duże instancje (miliony zmiennych), brak dobrej formulacji MIP, potrzeba szybkiego "dobrego" rozwiązania bez gwarancji, problemy z wieloma celami, problemy dynamiczne. egzamin pyt26 MOD detail +Wyjaśnij: Q2: "Co to jest callback w solverze MIP?" Odpowiedź: Funkcja wywoływana przez solver w trakcie B&B. Typy: lazy constraints (dodaj ograniczenie gdy naruszone), user cuts (wzmocnij relaksację), heuristic (znajdź rozwiązanie), branching (własna strategia). egzamin pyt26 MOD detail +Wyjaśnij: Q3: "Jak poprawić słabą formulację?" Odpowiedź: Dodaj valid inequalities (cięcia), zastąp big-M przez indicator constraints, wprowadź dodatkowe zmienne (extended formulation), użyj disaggregation. egzamin pyt26 MOD detail +Dlaczego jakość modelu danych jest krytycznie ważnym czynnikiem jakości projektu informatycznego?
  • Model danych jako fundament systemu
  • Konsekwencje złego modelu danych
  • Przykład: Anomalie przy braku normalizacji
  • Wpływ na różne aspekty projektu
  • Koszty naprawy złego modelu
  • Cechy dobrego modelu danych
egzamin pyt27 MODA main +Wyjaśnij: Konsekwencje złego modelu danych | Problem | Konsekwencje | +|---------|--------------| +| Redundancja | Anomalie (insert, update, delete), niespójność | +| Brak normalizacji | Duplikacja, trudna aktualizacja | +| Nadmierna normalizacja | Wolne zapytania (wiele JOIN) | +| Złe typy danych | Błędy konwersji, utrata precyzji | +| Brak ograniczeń | Nieprawidłowe dane w bazie | +| Słaba dokumentacja | Niezrozumiały sc egzamin pyt27 MODA detail +Wyjaśnij: Koszty naprawy złego modelu Koszt + ↑ + │ ████ + │ ████████████ + │ ████████████████████ + │ ████████████████████████████ + │ ████████████████████████████████████ + │ ████████████████████████████████████████████ + │████████████████████████████████████████████████████ + └───────────────────────────────────── egzamin pyt27 MODA detail +Wyjaśnij: Cechy dobrego modelu danych | Cecha | Opis | +|-------|------| +| Poprawność | Odzwierciedla dziedzinę biznesową | +| Kompletność | Wszystkie wymagane dane | +| Spójność | Brak sprzeczności, integralność | +| Minimalizm | Brak zbędnej redundancji | +| Elastyczność | Możliwość rozszerzenia | +| Wydajność | Odpowiednia denormalizacja gdzie potrzeba | +| Dokumentacja | ERD, słownik danych | egzamin pyt27 MODA detail +Wyjaśnij: Wpływ na jakość danych (GIGO) ┌──────────────────┐ +│ Złe dane wejść. │ → Zły model → Złe decyzje biznesowe +│ (brak walidacji) │ +└──────────────────┘ egzamin pyt27 MODA detail +Wyjaśnij: Q1: "Jak mierzyć jakość modelu danych?" Odpowiedź: Metryki: liczba anomalii, poziom normalizacji, pokrycie constraints, liczba orphan records, czas wykonania typowych zapytań, coupling między tabelami, dokumentacja coverage. egzamin pyt27 MODA detail +Wyjaśnij: Q2: "Kiedy denormalizacja jest uzasadniona?" Odpowiedź: Read-heavy systemy (raportowanie), krytyczne zapytania wymagające wielu JOIN, cache/materialized views, data warehouse (star schema), gdy koszt UPDATE < koszt JOIN. egzamin pyt27 MODA detail +Wyjaśnij: Q3: "Jak ewoluować model w produkcji?" Odpowiedź: Migracje (Flyway, Liquibase), blue-green deployment, feature flags, backward compatible changes (add column, nie remove), expand-contract pattern. egzamin pyt27 MODA detail +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz.
  • Przegląd faz ewolucji
  • Model konceptualny (Conceptual Data Model)
  • Model logiczny (Logical Data Model)
  • Model fizyczny (Physical Data Model)
  • Porównanie faz
  • Transformacje między fazami
egzamin pyt28 MODA main +Wyjaśnij: Model konceptualny (Conceptual Data Model) #### Cel +- Zrozumienie dziedziny biznesowej +- Komunikacja z interesariuszami (nietechnicznymi) +- Identyfikacja głównych encji i relacji egzamin pyt28 MODA detail +Wyjaśnij: Model logiczny (Logical Data Model) #### Cel +- Szczegółowa struktura danych +- Normalizacja +- Definicja atrybutów i kluczy +- Niezależność od DBMS egzamin pyt28 MODA detail +Wyjaśnij: Model fizyczny (Physical Data Model) #### Cel +- Implementacja w konkretnym DBMS +- Optymalizacja wydajności +- Definicja indeksów, partycji, storage egzamin pyt28 MODA detail +Wyjaśnij: Porównanie faz | Aspekt | Konceptualny | Logiczny | Fizyczny | +|--------|--------------|----------|----------| +| Odbiorcy | Biznes | Analitycy, projektanci | DBA, developerzy | +| Abstrakcja | Wysoka | Średnia | Niska | +| DBMS | Niezależny | Niezależny | Specyficzny | +| Typy danych | Brak | Logiczne | Natywne DBMS | +| Indeksy | Brak | Brak | Tak | +| Normalizacja | Nie | Tak (3NF+) | Może b egzamin pyt28 MODA detail +Wyjaśnij: Q1: "Kiedy pominąć fazę konceptualną?" Odpowiedź: Małe projekty, proste dziedziny, doświadczony zespół znający domenę. Ale ryzyko: brak wspólnego zrozumienia z biznesem, pominięte wymagania. egzamin pyt28 MODA detail +Wyjaśnij: Q2: "Jak dokumentować model danych?" Odpowiedź: ERD (draw.io, Lucidchart, dbdiagram.io), słownik danych (Data Dictionary), komentarze w DDL, wiki z opisem biznesowym, generowana dokumentacja (SchemaSpy). egzamin pyt28 MODA detail +Wyjaśnij: Q3: "Co to jest reverse engineering modelu?" Odpowiedź: Generowanie modelu logicznego/konceptualnego z istniejącej bazy (fizycznej). Narzędzia: ERwin, PowerDesigner, DBeaver. Przydatne dla legacy systems. egzamin pyt28 MODA detail +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie?
  • Prawo Amdahla
  • Wizualizacja ograniczenia
  • Co osłabia ograniczenie Amdahla?
  • Czynniki zmniejszające rzeczywiste przyśpieszenie
  • Efektywność równoległa
  • Rozszerzone prawo Amdahla (z overhead)
egzamin pyt29 PORR main +Wyjaśnij: Czynniki zmniejszające rzeczywiste przyśpieszenie ┌─────────────────────────────────────────────────────────────────┐ +│ 1. OVERHEAD SYNCHRONIZACJI │ +│ - Mutex, semaphore contention │ +│ - Barrier wait time │ +│ - Lock granularity (coarse vs fine) │ +├───────────────────────────────────────────────────────────── egzamin pyt29 PORR detail +Wyjaśnij: Q1: "Kiedy Gustafson jest lepszy od Amdahla?" Odpowiedź: Gdy problem można skalować (więcej danych, iteracji). Symulacje fizyczne, rendering, ML training. Amdahl zakłada stały problem - pesymistyczny dla HPC. egzamin pyt29 PORR detail +Wyjaśnij: Q2: "Jak zmierzyć rzeczywiste p?" Odpowiedź: Profilowanie (perf, VTune). Zmierz czas sekwencyjny vs równoległy. p ≈ 1 - T_seq/T_total. Uwaga: p może zależeć od danych wejściowych. egzamin pyt29 PORR detail +Wyjaśnij: Q3: "Co to jest strong vs weak scaling?" Odpowiedź: Strong: stały problem, więcej proc. (Amdahl). Weak: problem rośnie proporcjonalnie do proc. (Gustafson). Weak scaling łatwiejsze do osiągnięcia. egzamin pyt29 PORR detail +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych.
  • Struktura modelu matematycznego
  • Metody modelowania
  • Typowe problemy w modelowaniu
  • Techniki modelowania
  • Wielokryterialne podejmowanie decyzji
  • Analiza wrażliwości
egzamin pyt30 MOM main +Wyjaśnij: Częste błędy | Błąd | Konsekwencja | Rozwiązanie | +|------|--------------|-------------| +| Brak bounds | Unbounded lub słaba relaxation | Zawsze definiuj LB, UB | +| Za duże M | Numerical issues, wolne | Tight big-M | +| Redundantne ograniczenia | Wolniejsze, confusion | Minimalizuj | +| Zła skala | Numerical instability | Scaling, rescaling | +| Over-modeling | Za złożone, wolne | Simplify, ag egzamin pyt30 MOM detail +Wyjaśnij: Q1: "Jak sprawdzić czy model jest poprawny?" Odpowiedź: Testy na znanych instancjach, extreme cases, dimensional analysis, sprawdzenie czy relaksacja LP daje sensowne wyniki, analiza IIS dla infeasible. egzamin pyt30 MOM detail +Wyjaśnij: Q2: "Kiedy linearyzować a kiedy użyć NLP?" Odpowiedź: Linearyzuj gdy: nieliniowość jest "miękka", solver MIP szybszy niż NLP, potrzebujesz gwarancji optimum. NLP gdy: silna nieliniowość, ciągłe zmienne, akceptowalny local optimum. egzamin pyt30 MOM detail +Wyjaśnij: Q3: "Jak obsłużyć niepewność w modelu?" Odpowiedź: Stochastic programming (scenariusze), robust optimization (worst-case), chance constraints, sensitivity analysis. Wybór zależy od charakteru niepewności. egzamin pyt30 MOM detail +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości.
  • Klasyfikacja problemów optymalizacyjnych
  • Definicje kluczowe
  • Znaczenie wypukłości
  • Liniowość vs nieliniowość
  • Testowanie wypukłości
  • Problemy niewypukłe
egzamin pyt31 MOM main +Wyjaśnij: Q1: "Jak rozpoznać czy problem jest wypukły?" Odpowiedź: Sprawdź: (1) czy f celu ma Hesjan ≥ 0, (2) czy ograniczenia nierównościowe g_i są wypukłe, (3) czy ograniczenia równościowe h_j są liniowe. Jeśli wszystkie TAK → wypukły. egzamin pyt31 MOM detail +Wyjaśnij: Q2: "Co zrobić gdy problem jest niewypukły?" Odpowiedź: Multi-start, global solvers (BARON), convex relaxation, reformulation (np. SDP relaxation dla QCQP), metaheurystyki, decomposition methods. egzamin pyt31 MOM detail +Wyjaśnij: Q3: "Czy MILP jest wypukły?" Odpowiedź: Nie w klasycznym sensie (zmienne dyskretne). Ale LP relaxation jest wypukła. Branch & Bound wykorzystuje wypukłość relaksacji do pruning. egzamin pyt31 MOM detail +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego?
  • Definicje podstawowe
  • Kombinacje w MPI
  • Problem zakleszczenia (Deadlock)
  • Rozwiązania problemu zakleszczenia
  • Porównanie rozwiązań
  • Algorytm Jacobiego - pełny przykład
egzamin pyt32 PORR main +Wyjaśnij: Kombinacje w MPI | Funkcja MPI | Blokująca? | Synchroniczna? | Opis | +|-------------|------------|----------------|------| +| `MPI_Send` | Blokująca | Zależne od impl. | Standard send | +| `MPI_Ssend` | Blokująca | Synchroniczna | Czeka na recv | +| `MPI_Bsend` | Blokująca | Asynchroniczna | Buforowana | +| `MPI_Rsend` | Blokująca | - | Ready (recv musi czekać) | +| `MPI_Isend` | Nieblokująca | Asynchroniczna | Immedia egzamin pyt32 PORR detail +Wyjaśnij: Porównanie rozwiązań | Rozwiązanie | Zalety | Wady | +|-------------|--------|------| +| Zmiana kolejności | Proste, brak overhead | Wymaga asymetrii kodu | +| Isend/Irecv | Elastyczne, overlap | Złożoność kodu | +| Sendrecv | Proste, bezpieczne | Mniej elastyczne | +| Bsend | Podobne do standardowego | Wymaga bufora, memory | egzamin pyt32 PORR detail +Wyjaśnij: Algorytm Jacobiego - pełny przykład for (int iter = 0; iter < MAX_ITER; iter++) { + // Wymiana granic z sąsiadami + + // Bezpieczna wymiana z lewym sąsiadem + if (rank > 0) { + MPI_Sendrecv( + &u[1], 1, MPI_DOUBLE, rank-1, 0, // wyślij lewą granicę + &u[0], 1, MPI_DOUBLE, rank-1, 0, // odbierz od lewego + MPI_COMM_WORLD, &status + ); + } + + // Bezpieczna wymiana z egzamin pyt32 PORR detail +Wyjaśnij: "S-B Matrix": | | Sync | Async | +|---|---|---| +| Block | Ssend | Send/Bsend | +| Non-block | - | Isend | egzamin pyt32 PORR detail +Wyjaśnij: Q1: "Czy MPI_Send jest synchroniczne?" Odpowiedź: Zależy od implementacji i rozmiaru! Małe wiadomości często buforowane (async), duże mogą być sync. MPI_Ssend zawsze sync, MPI_Bsend zawsze async (buforowane). egzamin pyt32 PORR detail +Wyjaśnij: Q2: "Jak wykryć potencjalny deadlock?" Odpowiedź: Analiza statyczna grafu zależności send/recv. Narzędzia: MUST, Marmot. Runtime: timeouty, watchdog. Zasada: unikaj cykli w grafie oczekiwań. egzamin pyt32 PORR detail +Wyjaśnij: Q3: "Co to jest eager vs rendezvous protocol?" Odpowiedź: Eager: małe msg kopiowane do bufora natychmiast (async). Rendezvous: duże msg - handshake send/recv przed transferem (sync). Threshold zależy od implementacji MPI. egzamin pyt32 PORR detail +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model.
  • Definicja modelu Pub/Sub
  • Typy subskrypcji
  • Wildcardy (MQTT)
  • Gwarancje dostarczenia
  • Rozwiązania techniczne
  • Porównanie rozwiązań
egzamin pyt33 PSD main +Wyjaśnij: Typy subskrypcji | Typ | Opis | Przykład | +|-----|------|----------| +| Topic-based | Subskrypcja na nazwany temat | `subscribe("orders")` | +| Content-based | Filtrowanie po zawartości | `price > 100 AND category = "electronics"` | +| Type-based | Na podstawie typu wiadomości | `subscribe(OrderEvent.class)` | +| Hierarchical | Tematy zagnieżdżone | `sport/football/+` (wildcard) | egzamin pyt33 PSD detail +Wyjaśnij: Wildcardy (MQTT) Subskrypcje: + home/living-room/# → wszystko z living-room + home/+/temperature → temperatura ze wszystkich pomieszczeń + home/# → wszystko z home +``` egzamin pyt33 PSD detail +Wyjaśnij: Wzorce użycia 2. CQRS (Command Query Responsibility Segregation): + [Write Model] ─events─→ [Event Bus] ─→ [Read Model] + Oddzielne modele do zapisu i odczytu egzamin pyt33 PSD detail +Wyjaśnij: Q1: "Kiedy Kafka a kiedy RabbitMQ?" Odpowiedź: Kafka: event streaming, log retention, replay, high throughput, analytics. RabbitMQ: task queues, complex routing, request-reply, legacy AMQP integration. egzamin pyt33 PSD detail +Wyjaśnij: Q2: "Co to jest consumer group w Kafce?" Odpowiedź: Grupa consumerów gdzie każda partycja jest przypisana do jednego consumera w grupie. Umożliwia parallel processing i load balancing. Różne grupy otrzymują wszystkie wiadomości niezależnie. egzamin pyt33 PSD detail +Wyjaśnij: Q3: "Jak zapewnić ordering w pub/sub?" Odpowiedź: Kafka: ordering per partition (użyj tego samego klucza). RabbitMQ: single queue, single consumer. MQTT: QoS 2 dla pojedynczego topicu. Globalny ordering wymaga single partition/queue. egzamin pyt33 PSD detail +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym.
  • Charakterystyka danych strumieniowych
  • Modele przetwarzania
  • Platformy Stream Processing
  • Porównanie platform
  • Algorytmy strumieniowe
  • Obsługa opóźnień i Out-of-Order
egzamin pyt34 PSD main +Wyjaśnij: Porównanie platform | Cecha | Kafka Streams | Flink | Spark Streaming | +|-------|---------------|-------|-----------------| +| Model | True streaming | True streaming | Micro-batch | +| Deployment | Library | Cluster | Cluster | +| Latency | Niska | Bardzo niska | Średnia (~100ms) | +| State | RocksDB | RocksDB/heap | In-memory/external | +| Exactly-once | Tak | Tak | Tak | +| SQL | KSQL | Flink SQL egzamin pyt34 PSD detail +Wyjaśnij: Use Cases | Use Case | Technologia | Opis | +|----------|-------------|------| +| Fraud detection | Flink CEP | Pattern matching w czasie rzeczywistym | +| IoT analytics | Kafka Streams | Agregacja danych z sensorów | +| Real-time dashboards | Spark + Druid | Metryki biznesowe | +| Log analysis | ELK + Kafka | Centralizacja logów | +| Recommendations | Flink | Real-time personalizacja | egzamin pyt34 PSD detail +Wyjaśnij: Q1: "Kiedy micro-batch a kiedy true streaming?" Odpowiedź: True streaming (Flink): ultra-low latency, CEP, event-time critical. Micro-batch (Spark): wyższa przepustowość, łatwiejsza integracja z batch, mniej wrażliwe na anomalie. egzamin pyt34 PSD detail +Wyjaśnij: Q2: "Jak obsłużyć skoki danych (spikes)?" Odpowiedź: Backpressure (Flink automatycznie), buffering, auto-scaling (Kubernetes), rate limiting na źródle, spillage to disk. egzamin pyt34 PSD detail +Wyjaśnij: Q3: "Co to jest checkpointing?" Odpowiedź: Periodic snapshots stanu (Flink). Przy failure - restart od ostatniego checkpoointu. Barrier synchronizuje snapshot między operatorami. Incremental checkpoints dla dużych stanów. egzamin pyt34 PSD detail +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu.
  • Definicja układów cyber-fizycznych (CPS)
  • Specyfika modelowania CPS
  • Współpraca agentów w sieci
  • Problemy w osiąganiu pożądanego zachowania
  • Warunki zbieżności consensus
  • Przykłady zastosowań
egzamin pyt35 SIU main +Wyjaśnij: Q1: "Jak modelować opóźnienia w komunikacji?" Odpowiedź: Delay differential equations (DDE): ẋ(t) = f(x(t), x(t-τ)). Analiza stabilności: metody Lyapunova-Krasovskiego, analiza wartości własnych z delay. Kompensacja: predyktory Smitha, robust control. egzamin pyt35 SIU detail +Wyjaśnij: Q2: "Co to jest algebraic connectivity?" Odpowiedź: Druga najmniejsza wartość własna Laplacianu grafu (λ₂). Mierzy jak dobrze graf jest połączony. λ₂ > 0 ⟺ graf spójny. Większe λ₂ = szybsza zbieżność consensus. egzamin pyt35 SIU detail +Wyjaśnij: Q3: "Jak zapewnić odporność na złośliwe agenty?" Odpowiedź: Byzantine fault tolerance: F-local / F-total model, W-MSR algorithm (Weighted Mean-Subsequence-Reduced), redundancja informacji, reputation systems. egzamin pyt35 SIU detail +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem.
  • Model uczenia ze wzmocnieniem
  • Elementy składowe
  • Markov Decision Process (MDP)
  • Funkcje wartości
  • Algorytmy
  • Klasyfikacja algorytmów
egzamin pyt36 SIU main +Wyjaśnij: Elementy składowe | Element | Symbol | Opis | +|---------|--------|------| +| State | s ∈ S | Obserwacja środowiska | +| Action | a ∈ A | Decyzja agenta | +| Reward | r ∈ ℝ | Sygnał zwrotny | +| Policy | π(a\|s) | Strategia wyboru akcji | +| Value function | V(s), Q(s,a) | Oczekiwana nagroda | +| Discount factor | γ ∈ [0,1] | Ważność przyszłych nagród | +| Transition | P(s'\|s,a) | Dynamika środ egzamin pyt36 SIU detail +Wyjaśnij: Markov Decision Process (MDP) S: Zbiór stanów +A: Zbiór akcji +P: P(s'|s,a) - prawdopodobieństwa przejść +R: R(s,a,s') - funkcja nagrody +γ: Współczynnik dyskontowania egzamin pyt36 SIU detail +Wyjaśnij: Exploration vs Exploitation | Strategia | Opis | +|-----------|------| +| ε-greedy | Z prawdop. ε losowa akcja | +| Softmax/Boltzmann | P(a) ∝ exp(Q(s,a)/τ) | +| UCB | a = argmax[Q(s,a) + c√(ln N / n(a))] | +| Thompson Sampling | Próbkowanie z posterior | +| Curiosity-driven | Bonus za nowość | egzamin pyt36 SIU detail +Wyjaśnij: Q1: "Jaka jest różnica między Q-learning a SARSA?" Odpowiedź: Q-learning (off-policy): używa max Q(s',a') - optymistyczne. SARSA (on-policy): używa Q(s',a') gdzie a' to rzeczywista następna akcja - bardziej ostrożne, uwzględnia policy exploration. egzamin pyt36 SIU detail +Wyjaśnij: Q2: "Po co Experience Replay w DQN?" Odpowiedź: Łamie korelację między kolejnymi próbkami (iid requirement), efektywniejsze wykorzystanie danych (wielokrotne uczenie z jednej próbki), stabilizuje trening. egzamin pyt36 SIU detail +Wyjaśnij: Q3: "Kiedy model-based jest lepszy?" Odpowiedź: Gdy środowisko jest przewidywalne, samples są drogie (robotyka), potrzebne planowanie. Model-free lepszy gdy środowisko złożone, trudne do modelowania, dużo samples dostępnych. egzamin pyt36 SIU detail +Porównać podstawowe modele sieci złożonych. Jak odpowiadają one własnościom rzeczywistych sieci?
  • Właściwości rzeczywistych sieci
  • Model Erdős-Rényi (Random Graph)
  • Porównanie z rzeczywistością
  • Model Watts-Strogatz (Small-World)
  • Właściwości
  • Porównanie z rzeczywistością
egzamin pyt37 TASS main +Wyjaśnij: Porównanie z rzeczywistością | Cecha | ER Model | Rzeczywiste sieci | +|-------|----------|-------------------| +| Clustering | C = p (niski) | C >> p (wysoki) ❌ | +| Średnia ścieżka | L ~ log(n) ✓ | L ~ log(n) ✓ | +| Rozkład stopni | Poisson | Power-law ❌ | +| Huby | Brak | Istnieją ❌ | egzamin pyt37 TASS detail +Wyjaśnij: Porównanie zbiorcze Rzeczywiste sieci (WWW, social, biological): +• Wysoki clustering → WS lepszy +• Power-law → BA lepszy +• Short paths → wszystkie OK egzamin pyt37 TASS detail +Wyjaśnij: Q1: "Dlaczego BA ma niski clustering?" Odpowiedź: Preferential attachment łączy nowe węzły głównie z hubami, nie tworząc trójkątów między sąsiadami. Rozwiązanie: Holme-Kim model dodaje krok "triad formation". egzamin pyt37 TASS detail +Wyjaśnij: Q2: "Co to jest robustness vs vulnerability?" Odpowiedź: Scale-free sieci są odporne na losowe awarie (większość węzłów ma mały stopień), ale wrażliwe na celowane ataki na huby. ER sieci są bardziej jednolite w obu przypadkach. egzamin pyt37 TASS detail +Wyjaśnij: Q3: "Jak mierzyć small-world property?" Odpowiedź: Współczynnik σ = (C/C_random) / (L/L_random). Jeśli σ >> 1 → small-world. C wysoki jak w kratce, L niski jak w random graph. egzamin pyt37 TASS detail +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych.
  • Grafy dwudzielne (Bipartite Graphs)
  • Projekcja grafu dwudzielnego
  • Metody projekcji
  • Porównanie metod
  • Zastosowanie w grupowaniu dokumentów
  • Algorytmy grupowania na projekcji
egzamin pyt38 TASS main +Wyjaśnij: Problemy i rozwiązania | Problem | Opis | Rozwiązanie | +|---------|------|-------------| +| Gęstość | Projekcja tworzy gęste grafy | Threshold na wagi | +| Huby | Popularne słowa łączą wszystko | TF-IDF, filtering | +| Skalowalność | O(n²) krawędzi | Sparse representation, LSH | +| Utrata info | Projekcja traci strukturę | Zachowaj oryginalny graf | egzamin pyt38 TASS detail +Wyjaśnij: Q1: "Dlaczego projekcja binarna jest problematyczna?" Odpowiedź: Traci informację o sile powiązania. Dokument z 1 wspólnym słowem ma taką samą krawędź jak z 100 wspólnymi. Popularne słowa (stop words) tworzą fałszywe powiązania. egzamin pyt38 TASS detail +Wyjaśnij: Q2: "Jak skalować dla dużych zbiorów?" Odpowiedź: MinHash/LSH dla approximate similarity, sparse matrix operations, sampling, dimension reduction (LSA/SVD), distributed computing (Spark GraphX). egzamin pyt38 TASS detail +Wyjaśnij: Q3: "Alternatywy dla projekcji?" Odpowiedź: Bezpośrednie algorytmy na grafach dwudzielnych (bipartite community detection), tensor decomposition, embedding methods (node2vec), GNN na grafach heterogenicznych. egzamin pyt38 TASS detail +Scharakteryzować problem segmentacji obrazu. Przedstawić podstawowe strategie i algorytmy segmentacji przy użyciu metod klasycznych oraz sieci neuronowych.
  • Definicja problemu segmentacji
  • Metody klasyczne
  • Porównanie metod klasycznych
  • Metody deep learning
  • Porównanie architektur DL
  • Loss functions
egzamin pyt39 TWM main +Wyjaśnij: Porównanie metod klasycznych | Metoda | Zalety | Wady | +|--------|--------|------| +| Thresholding | Szybki, prosty | Tylko 2 klasy, wrażliwy na oświetlenie | +| Region Growing | Intuicyjny | Wymaga seedów, over-segmentation | +| Watershed | Dobre krawędzie | Over-segmentation | +| Mean Shift | Brak k | Wolny, parametr bandwidth | +| Graph Cut | Globalnie optymalne | O(n³), wymaga unary terms | egzamin pyt39 TWM detail +Wyjaśnij: Porównanie architektur DL | Architektura | mIoU (ADE20K) | Parametry | Cechy | +|--------------|---------------|-----------|-------| +| FCN | ~30% | ~135M | Pierwsze DL dla segmentacji | +| U-Net | - | ~31M | Medical, skip connections | +| DeepLabv3+ | ~45% | ~60M | ASPP, dilated conv | +| SegFormer-B5 | ~51% | ~85M | Transformer, efficient | +| Mask2Former | ~57% | ~200M | Universal, SOTA | egzamin pyt39 TWM detail +Wyjaśnij: Metryki | Metryka | Formuła | Opis | +|---------|---------|------| +| Pixel Accuracy | TP / (TP+FP+FN+TN) | % poprawnych pikseli | +| IoU (Jaccard) | TP / (TP+FP+FN) | Intersection over Union | +| mIoU | mean IoU per class | Standard dla segmentacji | +| Dice | 2TP / (2TP+FP+FN) | F1 dla segmentacji | egzamin pyt39 TWM detail +Wyjaśnij: Q1: "Jak radzić sobie z class imbalance?" Odpowiedź: Weighted cross-entropy, Focal Loss, oversampling małych klas, Dice Loss (ignoruje dominację dużych klas), OHEM (Online Hard Example Mining). egzamin pyt39 TWM detail +Wyjaśnij: Q2: "U-Net vs DeepLab?" Odpowiedź: U-Net: encoder-decoder z concat skip, dobre dla małych datasetów (medical). DeepLab: dilated conv zachowuje resolution, ASPP dla multi-scale, lepsze dla dużych datasetów. egzamin pyt39 TWM detail +Wyjaśnij: Q3: "Co to jest panoptic segmentation?" Odpowiedź: Unified semantic + instance. Dzieli na "stuff" (nieczęściowe: sky, road) i "things" (policzalne: person, car). Każdy piksel ma class ID + instance ID. egzamin pyt39 TWM detail +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów?
  • Definicja problemu detekcji
  • Metody klasyczne
  • Metody Deep Learning
  • Konstrukcja detektora z klasyfikatora
  • Non-Maximum Suppression (NMS)
  • Metryki
egzamin pyt40 TWM main +Wyjaśnij: Q1: "YOLO vs Faster R-CNN?" Odpowiedź: YOLO: szybszy (real-time), gorszy dla małych obiektów. Faster R-CNN: dokładniejszy, wolniejszy, two-stage (RPN + detection). Trade-off speed vs accuracy. egzamin pyt40 TWM detail +Wyjaśnij: Q2: "Co to są anchor boxes?" Odpowiedź: Predefiniowane boxy o różnych rozmiarach i aspect ratios. Sieć predykuje offset od anchora, nie absolutne koordynaty. Ułatwia uczenie (mniejsza przestrzeń wyjściowa). egzamin pyt40 TWM detail +Wyjaśnij: Q3: "Jak działają anchor-free detektory?" Odpowiedź: Predykują bezpośrednio: punkt centralny + rozmiar (FCOS, CenterNet) lub keypoints (CornerNet). Prostsze, mniej hiperparametrów, konkurencyjne wyniki. egzamin pyt40 TWM detail +Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka.
  • Decyzje w warunkach ryzyka
  • Metody interaktywne - przegląd
  • Metoda loterii (Lottery Method)
  • Metoda pewnego ekwiwalentu (Certainty Equivalent)
  • Metoda AHP (Analytic Hierarchy Process)
  • Metoda PROMETHEE
egzamin pyt41 WDWR main +Wyjaśnij: Q1: "Jak wykryć niespójność odpowiedzi decydenta?" Odpowiedź: AHP: Consistency Ratio (CR < 0.1). Utility: sprawdzenie monotoniczności, przechodniości preferencji. Cross-validation różnymi metodami elicytacji. egzamin pyt41 WDWR detail +Wyjaśnij: Q2: "Co to jest awersja do ryzyka?" Odpowiedź: Risk averse: U''(x) < 0 (funkcja wklęsła), CE < E[X], preferuje pewność nad loterię o tej samej wartości oczekiwanej. Miernik: Arrow-Pratt coefficient r(x) = -U''(x)/U'(x). egzamin pyt41 WDWR detail +Wyjaśnij: Q3: "AHP vs PROMETHEE?" Odpowiedź: AHP: hierarchiczna dekompozycja, porównania parami, pełna kompensacja. PROMETHEE: outranking, progi preferencji, częściowa kompensacja, lepsze dla nieporównywalnych kryteriów. egzamin pyt41 WDWR detail +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka?
  • Idea dominacji stochastycznej
  • Dominacja stochastyczna pierwszego rzędu (FSD)
  • Dominacja stochastyczna drugiego rzędu (SSD)
  • Porównanie FSD i SSD
  • Zastosowanie w modelach wyboru
  • Testowanie dominacji
egzamin pyt42 WDWR main +Wyjaśnij: Porównanie FSD i SSD | Cecha | FSD | SSD | +|-------|-----|-----| +| Warunek | F_A(x) ≤ F_B(x) ∀x | ∫F_A ≤ ∫F_B ∀x | +| Na U | U' ≥ 0 | U' ≥ 0, U'' ≤ 0 | +| Decydenci | Wszyscy racjonalni | Risk-averse | +| Implikacja | FSD ⟹ SSD | SSD ⇏ FSD | +| Praktyka | Rzadka | Częstsza | egzamin pyt42 WDWR detail +Wyjaśnij: Ograniczenia | Ograniczenie | Opis | +|--------------|------| +| Częściowe uporządkowanie | Nie wszystkie pary porównywalne | +| Konserwatywność | Wiele par bez dominacji | +| Wymóg pełnego rozkładu | Potrzebna cała dystrybuanta | +| Brak dominacji ≠ obojętność | Brak dominacji nie znaczy równoważność | egzamin pyt42 WDWR detail +Wyjaśnij: Q1: "Kiedy FSD a kiedy SSD?" Odpowiedź: FSD: gdy jeden rozkład jest jednoznacznie lepszy (przesunięty w prawo). SSD: gdy różnica w ryzyku (rozproszeniu) kompensuje różnicę w średniej dla risk-averse. egzamin pyt42 WDWR detail +Wyjaśnij: Q2: "Co jeśli ani FSD ani SSD?" Odpowiedź: Rozkłady są nieporównywalne w sensie SD. Potrzebna dokładniejsza specyfikacja preferencji (konkretna funkcja użyteczności) lub TSD (trzeci rząd). egzamin pyt42 WDWR detail +Wyjaśnij: Q3: "Związek SD z mean-variance?" Odpowiedź: Mean-variance (Markowitz) to przybliżenie. SSD jest bardziej ogólne - nie wymaga założenia normalności rozkładu. Dla rozkładów normalnych: SSD ≈ dominacja mean-variance. egzamin pyt42 WDWR detail +Jakie cechy zadań szeregowania wykorzystuje się do ich klasyfikacji? Omówić przykładową metodę dla wybranego problemu szeregowania.
  • Notacja Graham'a (α|β|γ)
  • Pole α - Środowisko maszynowe
  • Pole β - Charakterystyki zadań
  • Pole γ - Kryteria optymalizacji
  • Złożoność obliczeniowa
  • Przykładowa metoda: Problem 1 || ΣCⱼ
egzamin pyt43 ZBOP main +Wyjaśnij: Pole α - Środowisko maszynowe | Symbol | Opis | +|--------|------| +| 1 | Jedna maszyna | +| P | Maszyny równoległe identyczne | +| Pm | m maszyn równoległych identycznych | +| Q | Maszyny równoległe o różnych prędkościach | +| R | Maszyny niezwiązane (unrelated) | +| F | Flow shop (linia produkcyjna) | +| Fm | Flow shop z m maszynami | +| J | Job shop | +| Jm | Job shop z m maszynami | +| O | Open egzamin pyt43 ZBOP detail +Wyjaśnij: Pole β - Charakterystyki zadań | Symbol | Opis | +|--------|------| +| rⱼ | Release dates (terminy dostępności) | +| dⱼ | Due dates (terminy wymagane) | +| d̄ⱼ | Deadlines (nieprzekraczalne terminy) | +| prec | Precedence constraints (kolejność) | +| pmtn | Preemption allowed (przerwanie dozwolone) | +| pⱼ=1 | Unit processing times | +| sᵢⱼ | Setup times (czasy przezbrojeń) | +| brkdwn | Machine breakdown egzamin pyt43 ZBOP detail +Wyjaśnij: Pole γ - Kryteria optymalizacji | Symbol | Nazwa | Formuła | +|--------|-------|---------| +| Cmax | Makespan | max Cⱼ | +| ΣCⱼ | Total completion time | Σ Cⱼ | +| Σwⱼ Cⱼ | Weighted completion | Σ wⱼ Cⱼ | +| Lmax | Max lateness | max(Cⱼ - dⱼ) | +| Tmax | Max tardiness | max(0, Cⱼ - dⱼ) | +| ΣTⱼ | Total tardiness | Σ max(0, Cⱼ - dⱼ) | +| ΣUⱼ | Number of tardy jobs | Σ 𝟙(Cⱼ > dⱼ) | egzamin pyt43 ZBOP detail +Wyjaśnij: Inne klasyczne reguły | Reguła | Problem | Opis | +|--------|---------|------| +| SPT | 1 \|\| ΣCⱼ | Shortest Processing Time | +| WSPT | 1 \|\| ΣwⱼCⱼ | Weighted SPT (wⱼ/pⱼ malejąco) | +| EDD | 1 \|\| Lmax | Earliest Due Date | +| LPT | Pm \|\| Cmax | Longest Processing Time (heur.) | +| Moore | 1 \|\| ΣUⱼ | Minimalizacja spóźnionych | +| Johnson | F2 \|\| Cmax | 2-machine flow shop | egzamin pyt43 ZBOP detail +Wyjaśnij: Q1: "Kiedy stosować heurystyki a kiedy optymalne?" Odpowiedź: Optymalne (SPT, EDD, Johnson) gdy problem wielomianowy. Heurystyki (LPT, dispatching rules) dla NP-trudnych lub gdy wymagana szybkość. Metaheurystyki (GA, SA) dla trudnych instancji. egzamin pyt43 ZBOP detail +Wyjaśnij: Q2: "Co to jest preemption?" Odpowiedź: Możliwość przerwania zadania i kontynuacji później. pmtn w notacji. Upraszcza niektóre problemy (1|pmtn,rⱼ|Lmax jest P, bez pmtn jest NP-hard). egzamin pyt43 ZBOP detail +Wyjaśnij: Q3: "Job shop vs Flow shop?" Odpowiedź: Flow shop: wszystkie zadania ta sama trasa (M1→M2→...→Mm). Job shop: każde zadanie własna trasa. Job shop jest ogólniejszy i trudniejszy (silnie NP-hard nawet dla 3 maszyn). egzamin pyt43 ZBOP detail +Jakie problemy wiążą się z zarządzaniem zapasami w łańcuchu dostaw? Omówić przykładowy model zarządzania zapasami w łańcuchu dostaw.
  • Łańcuch dostaw - struktura
  • Problemy zarządzania zapasami
  • Koszty zapasów
  • Model EOQ (Economic Order Quantity)
  • Model z punktem zamawiania (ROP)
  • Model (s, S) / (R, Q)
egzamin pyt44 ZBOP main +Wyjaśnij: Model (s, S) / (R, Q) | Model | Opis | +|-------|------| +| (s, Q) | Zamów Q gdy poziom spadnie do s | +| (s, S) | Zamów do poziomu S gdy spadnie do s | +| (R, S) | Co R okresów uzupełnij do S | +| (R, s, S) | Co R okresów: jeśli ≤ s, uzupełnij do S | egzamin pyt44 ZBOP detail +Wyjaśnij: Wskaźniki efektywności | Wskaźnik | Formuła | Cel | +|----------|---------|-----| +| Inventory Turnover | COGS / Avg Inventory | Wyższy = lepszy | +| Days of Inventory | 365 / Turnover | Niższy = lepszy | +| Fill Rate | Zamówienia zrealizowane / Wszystkie | Wyższy | +| Service Level | P(brak stockout) | 95-99% | +| GMROI | Gross Margin / Avg Inventory | Wyższy | egzamin pyt44 ZBOP detail +Wyjaśnij: Q1: "Jak zredukować bullwhip effect?" Odpowiedź: Współdzielenie informacji (POS data), VMI, CPFR (Collaborative Planning), redukcja lead times, stabilne ceny (EDLP), mniejsze partie (smaller batches), centralizacja decyzji. egzamin pyt44 ZBOP detail +Wyjaśnij: Q2: "EOQ vs JIT?" Odpowiedź: EOQ: optymalizuje koszty przy danych K, h. JIT (Just-In-Time): redukuje K (częste małe dostawy), redukuje zapasy (Q→0). JIT wymaga: niskich setup costs, niezawodnych dostawców, stabilnego popytu. egzamin pyt44 ZBOP detail +Wyjaśnij: Q3: "Jak ustalić poziom zapasu bezpieczeństwa?" Odpowiedź: SS = z × σ_L, gdzie z zależy od wymaganego service level (z=1.65 dla 95%, z=2.33 dla 99%). σ_L = σ_d × √L dla niezależnego popytu. Trade-off: wyższy SS = mniej stockouts, ale wyższe koszty. egzamin pyt44 ZBOP detail +Wyjaśnij: Pytanie "Jaki jest cel Pana pracy magisterskiej i dlaczego wybrano akurat temat porównania silników gier?" egzamin pyt45 Ogólne detail +Wyjaśnij: Odpowiedź wzorcowa Celem pracy jest kompleksowe porównanie wydajności i możliwości współczesnych silników gier (Unity i Unreal Engine), ze szczególnym uwzględnieniem ich wpływu na proces tworzenia gier oraz końcową jakość produktu. egzamin pyt45 Ogólne detail +Wyjaśnij: Wydajność - Szybkość renderowania (FPS) +- Zużycie pamięci RAM +- Obciążenie procesora +- Zużycie pamięci karty graficznej +- Czas ładowania scen egzamin pyt45 Ogólne detail +Wyjaśnij: Funkcjonalność - Wsparcie dla różnych typów renderingu +- Systemy fizyki +- Systemy audio +- Wsparcie dla VR/AR +- Możliwości skryptowania egzamin pyt45 Ogólne detail +Wyjaśnij: Użyteczność - Intuicyjność interfejsu +- Jakość dokumentacji +- Dostępność tutoriali +- Wsparcie społeczności +- Czas potrzebny na naukę (krzywa uczenia) egzamin pyt45 Ogólne detail diff --git a/pytania/anki_filter_extract.txt b/pytania/anki_filter_extract.txt new file mode 100644 index 0000000..e285849 --- /dev/null +++ b/pytania/anki_filter_extract.txt @@ -0,0 +1,1883 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_filter+extract + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Definicja: Automat skończony to piątka: M = (Q, Σ, δ, q₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (skończony zbiór symboli)
• δ: funkcja przejścia: Q × Σ → Q (DFA) lub Q × Σ → P(Q) (NFA)
• q₀: stan początkowy (q₀ ∈ Q)
• F: zbiór stanów akceptujących (F ⊆ Q) egzamin pyt01 AISDI main +Wyjaśnij: Hierarchia Chomsky'ego - fundament teoretyczny Noam Chomsky w 1956 roku zaproponował hierarchię czterech klas języków formalnych, gdzie każda kolejna klasa zawiera poprzednią: egzamin pyt01 AISDI detail +Wyjaśnij: Automat Skończony (Finite Automaton - FA) Definicja: Automat skończony to piątka: M = (Q, Σ, δ, q₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (skończony zbiór symboli)
• δ: funkcja przejścia: Q × Σ → Q (DFA) lub Q × Σ → P(Q) (NFA)
• q₀: stan początkowy (q₀ ∈ Q)
• F: zbiór stanów akceptujących (F ⊆ Q) egzamin pyt01 AISDI detail +Wyjaśnij: Automat ze Stosem (Pushdown Automaton - PDA) Definicja: Automat ze stosem to siódemka: M = (Q, Σ, Γ, δ, q₀, Z₀, F)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy
• Γ: alfabet stosowy
• δ: funkcja przejścia: Q × (Σ ∪ {ε}) × Γ → P(Q × Γ*)
• q₀: stan początkowy egzamin pyt01 AISDI detail +Wyjaśnij: Maszyna Turinga (Turing Machine - TM) Definicja: Maszyna Turinga to siódemka: M = (Q, Σ, Γ, δ, q₀, qaccept, qreject)
• Q: skończony zbiór stanów
• Σ: alfabet wejściowy (nie zawiera symbolu pustego ␣)
• Γ: alfabet taśmowy (Σ ⊂ Γ, ␣ ∈ Γ)
• δ: funkcja przejścia: Q × Γ → Q × Γ × {L, R}
• q₀: stan początkowy egzamin pyt01 AISDI detail +Omówić i porównać algorytmy najkrótszej ścieżki wskazując ich kluczowe właściwości i logikę budowy: Dijkstry, Belmana-Forda, A*. Single-Source Shortest Path (SSSP): z jednego źródła do wszystkich wierzchołków
Single-Pair Shortest Path: z s do konkretnego t
All-Pairs Shortest Path (APSP): między wszystkimi parami (Floyd-Warshall) egzamin pyt02 AISDI main +Wyjaśnij: Wprowadzenie - problem najkrótszej ścieżki Single-Source Shortest Path (SSSP): z jednego źródła do wszystkich wierzchołków
Single-Pair Shortest Path: z s do konkretnego t
All-Pairs Shortest Path (APSP): między wszystkimi parami (Floyd-Warshall) egzamin pyt02 AISDI detail +Wyjaśnij: Charakterystyka • Autor:: Edsger Dijkstra (1956, opublikowany 1959)
• Typ:: Zachłanny (greedy)
• Problem:: SSSP - najkrótsze ścieżki z jednego źródła do wszystkich wierzchołków
• Ograniczenie:: ⚠️ Tylko nieujemne wagi krawędzi (w(e) ≥ 0) egzamin pyt02 AISDI detail +Wyjaśnij: Idea algorytmu (logika budowy) 1. Relaksacja: Stopniowe ulepszanie oszacowań odległości +2. Zachłanność: W każdym kroku wybieramy wierzchołek o najmniejszej znanej odległości +3. Optymalna podstruktura: Najkrótsza ścieżka składa się z najkrótszych podścieżek egzamin pyt02 AISDI detail +Wyjaśnij: Pseudokod ``` +DIJKSTRA(G, w, s): + // Inicjalizacja + for each v ∈ V: + d[v] ← ∞ + π[v] ← NIL + d[s] ← 0 + + Q ← priority_queue(V) // min-heap według d[v] + S ← ∅ // zbiór przetworzonych + + while Q ≠ ∅: + u ← EXTRACT-MIN(Q) + S ← S ∪ {u} egzamin pyt02 AISDI detail +Wyjaśnij: Złożoność czasowa | Implementacja kolejki | EXTRACT-MIN | DECREASE-KEY | Całkowita | +|----------------------|-------------|--------------|-----------| +| Lista/tablica | O(V) | O(1) | O(V²) | +| Kopiec binarny | O(log V) | O(log V) | O((V + E) log V) | +| Kopiec Fibonacciego | O(log V) | O(1) | **O(V log V + E egzamin pyt02 AISDI detail +Wyjaśnij: Dlaczego nie działa dla ujemnych wag? ``` + A ---(-5)--- B + | | + (1) (1) + | | + S -----------C + (2) +```
Dijkstra przetwarza wierzchołki w kolejności rosnącej odległości i oznacza je jako "zakończone". Jeśli waga może być ujemna, późniejszy wierzchołek może "poprawić" już zakończony. egzamin pyt02 AISDI detail +Wyjaśnij: Wykrywanie cyklu ujemnego Po |V|-1 iteracjach, wszystkie najkrótsze ścieżki (bez cykli) są znalezione. +Jeśli w iteracji |V| nadal można zrelaksować krawędź → istnieje cykl ujemny. egzamin pyt02 AISDI detail +Wyjaśnij: Heurystyka - kluczowy element 1. Dopuszczalność (Admissibility): + h(n) ≤ h(n) dla każdego n + + gdzie h(n) = rzeczywisty koszt n → cel + + → Gwarantuje optymalność rozwiązania
2. Spójność/Monotoniczność (Consistency): + h(n) ≤ w(n, m) + h(m) dla każdej krawędzi (n, m) + + → Gwarantuje, że węzeł nie musi być ponownie otwarty + → Spójność implikuje dopuszczalność egzamin pyt02 AISDI detail +Wyjaśnij: Dijkstra • Nawigacja GPS: (drogi nie mają ujemnych odległości)
• Routing w sieciach: (OSPF protocol)
• Mapy Google/Apple: (dla małych obszarów) egzamin pyt02 AISDI detail +Wyjaśnij: Bellman-Ford • Routing w sieciach: (RIP protocol - prostszy)
• Arbitraż walutowy: (szukanie cykli ujemnych = zysk!)
• Systemy z "karami": (ujemne wagi = bonusy) egzamin pyt02 AISDI detail +Wyjaśnij: A* • Gry komputerowe: pathfinding NPC, RTS
• Robotyka: planowanie ruchu
• Puzzle: 8-puzzle, 15-puzzle
• Nawigacja: gdy znamy pozycję celu
• Dijkstra:: Relaksuje krawędzie wychodzące z wierzchołka o minimalnym d[v] egzamin pyt02 AISDI detail +Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. • Redundancja: = niepożądane powtarzanie danych
• Normalizacja: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin pyt03 BD2 main +Wyjaśnij: Wprowadzenie • Redundancja: = niepożądane powtarzanie danych
• Normalizacja: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin pyt03 BD2 detail +Wyjaśnij: Definicja Redundancja występuje, gdy ta sama informacja jest przechowywana w wielu miejscach bazy danych, co prowadzi do: +- Marnowania pamięci +- Niespójności danych (anomalii) +- Trudności w utrzymaniu egzamin pyt03 BD2 detail +Wyjaśnij: Trzy typy anomalii #### 1. Anomalia wstawiania (Insertion Anomaly) +Problem: Nie można dodać danych bez dodania innych, niepotrzebnych danych.
Przykład: Nie możemy dodać nowego kursu "Sieci komputerowe" bez przypisania do niego studenta. egzamin pyt03 BD2 detail +Wyjaśnij: Podstawowe pojęcia #### Zależność funkcyjna (Functional Dependency - FD) +X → Y oznacza: wartość X jednoznacznie określa wartość Y
Przykład: StudentID → (Imię, Nazwisko) +- Znając StudentID, możemy jednoznacznie określić imię i nazwisko egzamin pyt03 BD2 detail +Wyjaśnij: 1NF - Pierwsza Postać Normalna Atomowość wartości: każda komórka zawiera jedną, niepodzielną wartość
Brak powtarzających się grup: brak tablic/list w komórkach egzamin pyt03 BD2 detail +Wyjaśnij: 2NF - Druga Postać Normalna #### Wymagania: +1. Spełnia 1NF +2. Każdy atrybut wtórny jest w pełni funkcyjnie zależny od całego klucza głównego (nie od jego części)
Dotyczy tylko tabel z kluczem złożonym (wielokolumnowym). egzamin pyt03 BD2 detail +Wyjaśnij: 3NF - Trzecia Postać Normalna Brak przechodnich zależności funkcyjnych: atrybuty wtórne nie zależą od innych atrybutów wtórnych egzamin pyt03 BD2 detail +Wyjaśnij: BCNF - Postać Normalna Boyce'a-Codda #### Wymagania: +1. Spełnia 3NF +2. Dla każdej nietrywialnej FD X → Y, X jest nadkluczem
BCNF jest silniejsza niż 3NF - eliminuje przypadki, gdy atrybut pierwszy zależy od atrybutu niebędącego nadkluczem. egzamin pyt03 BD2 detail +Wyjaśnij: 4NF - Czwarta Postać Normalna #### Wymagania: +1. Spełnia BCNF +2. Brak nietrywialnych zależności wielowartościowych (MVD - Multivalued Dependencies)
Zależność wielowartościowa X ↠ Y: Dla danego X istnieje zbiór wartości Y niezależny od innych atrybutów. egzamin pyt03 BD2 detail +Wyjaśnij: 5NF - Piąta Postać Normalna (PJNF) #### Wymagania: +1. Spełnia 4NF +2. Brak zależności połączeniowych (Join Dependencies) +3. Dekompozycja bez strat tylko na podstawie kluczy kandydujących
5NF eliminuje redundancję wynikającą z niemożliwości odtworzenia oryginalnej relacji przez złączenie jej projekcji. egzamin pyt03 BD2 detail +Wyjaśnij: Algorytm dekompozycji do 3NF 1. Znajdź pokrycie kanoniczne zbioru zależności funkcyjnych +2. Dla każdej FD X → A utwórz relację R(X, A) +3. Jeśli żadna relacja nie zawiera klucza kandydującego, dodaj relację z atrybutami klucza +4. Usuń relacje zawarte w innych relacjach egzamin pyt03 BD2 detail +Wyjaśnij: Własności dobrej dekompozycji #### 1. Bezstratność (Lossless Join) +Po dekompozycji można odtworzyć oryginalną relację przez złączenie naturalne.
Twierdzenie: Dekompozycja R na R₁ i R₂ jest bezstratna wtw gdy: +- R₁ ∩ R₂ → R₁, lub +- R₁ ∩ R₂ → R₂ egzamin pyt03 BD2 detail +Wyjaśnij: Kiedy stosować? • Optymalizacja wydajności: złączenia są kosztowne
• Systemy OLAP/hurtownie danych: dane głównie odczytywane
• Raportowanie: predefiniowane zapytania egzamin pyt03 BD2 detail +Wyjaśnij: Techniki denormalizacji: Dodanie redundantnych kolumn: unikanie złączeń
Tabele historyczne: snapshoty
Materializowane widoki: cache wyników egzamin pyt03 BD2 detail +Wyjaśnij: Wzór na 3NF: > "Każdy atrybut zależy od klucza, całego klucza i tylko od klucza." +> (The key, the whole key, and nothing but the key - so help me Codd!)
## ❓ Możliwe pytania dodatkowe (follow-up) egzamin pyt03 BD2 detail +Dlaczego baza danych stanowi dobry fundament do budowy wielu systemów informatycznych? Baza danych to centralny komponent większości systemów informatycznych, ponieważ zapewnia: +- Trwałe przechowywanie danych +- Współbieżny dostęp +- Integralność i spójność +- Niezależność danych od aplikacji egzamin pyt04 BD2 main +Wyjaśnij: Transakcyjność - gwarancje ACID | Właściwość | Opis | Znaczenie | +|------------|------|-----------| +| Atomicity (Atomowość) | Transakcja wykonuje się w całości lub wcale | Brak częściowych zmian | +| Consistency (Spójność) | Dane przechodzą z jednego spójnego stanu w drugi | Reguły biznesowe zawsze spełnione | +| Isolati egzamin pyt04 BD2 detail +Wyjaśnij: Trójpoziomowa architektura ANSI/SPARC ``` +┌─────────────────────────────────────────┐ +│ Poziom zewnętrzny (widoki) │ ← Aplikacje widzą różne "okna" +├─────────────────────────────────────────┤ +│ Poziom konceptualny (logiczny) │ ← Struktura logiczna danych +├─────────────────────────────────────────┤ +│ Poziom we egzamin pyt04 BD2 detail +Wyjaśnij: Rodzaje niezależności #### 1. Niezależność fizyczna +Zmiana sposobu przechowywania (indeksy, partycjonowanie, kompresja) nie wpływa na aplikacje.
Przykład: Dodanie indeksu przyspiesza zapytania bez zmiany kodu aplikacji. egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy kontroli współbieżności | Mechanizm | Opis | Zastosowanie | +|-----------|------|--------------| +| Blokady (Locks) | Pesymistyczne - blokuj przed dostępem | Wysokie konflikty | +| MVCC | Optymistyczne - wersjonowanie | Dużo odczytów | +| Timestamp Ordering | Szeregowanie po czasie | Systemy rozproszone | +| **Snaps egzamin pyt04 BD2 detail +Wyjaśnij: Poziomy izolacji (SQL Standard) | Poziom | Dirty Read | Non-repeatable Read | Phantom Read | +|--------|------------|---------------------|--------------| +| READ UNCOMMITTED | Możliwy | Możliwy | Możliwy | +| READ COMMITTED | Niemożliwy | Możliwy | Możliwy | +| REPEATABLE READ | Niemożliwy | Niemożliwy | Możliwy | +| SERIALIZABLE | Ni egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wymuszania integralności #### 1. Ograniczenia deklaratywne +```sql +CREATE TABLE Zamowienia ( + id INT PRIMARY KEY, -- Klucz główny + klient_id INT NOT NULL, -- NOT NULL + data DATE DEFAULT CURRENT_DATE, -- Wartość domyślna + kwota DECIMAL(10,2) CHECK (kwota >
#### 2. Wyzwalacze (Triggers) +```sql +CREATE TRIGGER sprawdz_saldo +BEFORE UPDATE ON Konta +FOR EACH ROW +BEGIN + IF NEW.saldo < 0 THEN + SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Brak środków'; + END IF; +END; +``` egzamin pyt04 BD2 detail +Wyjaśnij: Optymalizator zapytań SZBD automatycznie: +1. Analizuje zapytanie (parsing) +2. Generuje plany wykonania (alternatywy) +3. Szacuje koszty (statystyki) +4. Wybiera najlepszy plan (optymalizacja) egzamin pyt04 BD2 detail +Wyjaśnij: Mechanizmy wydajności | Mechanizm | Funkcja | +|-----------|---------| +| Indeksy | Szybkie wyszukiwanie (B-tree, Hash, GiST) | +| Buforowanie | Cache często używanych danych | +| Partycjonowanie | Podział dużych tabel | +| Materializowane widoki | Prekompilowane złączenia | +| Query cache | Cache wyników z egzamin pyt04 BD2 detail +Wyjaśnij: Wielopoziomowe zabezpieczenia ``` +┌─────────────────────────────────────────┐ +│ Autoryzacja (GRANT/REVOKE) │ +├─────────────────────────────────────────┤ +│ Autentykacja (użytkownicy, role) │ +├─────────────────────────────────────────┤ +│ Szyfrowanie (TDE, SSL/TLS) │ +├─────────────────────────────── egzamin pyt04 BD2 detail +Wyjaśnij: Kontrola dostępu -- Przypisanie użytkownika +GRANT analityk TO jan_kowalski;
-- Widok ograniczający dane +CREATE VIEW MojeZamowienia AS + SELECT * FROM Zamowienia WHERE sprzedawca = CURRENT_USER; +``` egzamin pyt04 BD2 detail +Wyjaśnij: Skalowanie poziome (Scale-out) • Replikacja: kopie do odczytu
• Sharding: podział danych między serwery
• Klastry: wysoka dostępność egzamin pyt04 BD2 detail +Wyjaśnij: Wysoka dostępność (HA) | Rozwiązanie | Opis | +|-------------|------| +| Replikacja Master-Slave | Odczyty z replik | +| Replikacja Master-Master | Zapisy na wielu węzłach | +| Failover automatyczny | Przełączanie przy awarii | +| Backup/Recovery | Odtwarzanie po katastrofie |
## 8. Standaryzacja i ekosystem egzamin pyt04 BD2 detail +Wyjaśnij: SQL jako lingua franca • Standardowy język: SQL:2016, SQL:2023
• Przenośność: kod działa na różnych SZBD
• Narzędzia: uniwersalne IDE, ORM, ETL egzamin pyt04 BD2 detail +Wyjaśnij: Bogaty ekosystem • ORM: (Hibernate, Entity Framework, SQLAlchemy)
• Narzędzia migracji: (Flyway, Liquibase)
• Monitorowanie: (Grafana, Datadog)
• Backup: (pg_dump, mysqldump, RMAN) egzamin pyt04 BD2 detail +Wyjaśnij: Jeden fundament, wiele modeli | Model | SZBD | Zastosowanie | +|-------|------|--------------| +| Relacyjny | PostgreSQL, MySQL, Oracle | OLTP, dane strukturalne | +| Dokumentowy | MongoDB, CouchDB | JSON, elastyczne schematy | +| Klucz-wartość | Redis, DynamoDB | Cache, sesje | +| Grafowy | Neo4j, Amazon Neptune | Re egzamin pyt04 BD2 detail +Omówić główne kategorie elementów biblioteki STL. Jaka jest ich rola i wzajemne powiązania? Odpowiedź uzasadnić na przykładach. • Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami
• Wydajność: zero-overhead abstraction
• Modularność: komponenty są niezależne i wymienne
• Ortogonalność: kontenery i algorytmy są rozdzielone (przez iteratory) egzamin pyt05 PROI main +Wyjaśnij: Filozofia STL • Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami
• Wydajność: zero-overhead abstraction
• Modularność: komponenty są niezależne i wymienne
• Ortogonalność: kontenery i algorytmy są rozdzielone (przez iteratory) egzamin pyt05 PROI detail +Wyjaśnij: Kategorie kontenerów #### 1.1 Kontenery sekwencyjne (Sequence Containers)
Przechowują elementy w określonej kolejności. egzamin pyt05 PROI detail +Wyjaśnij: Hierarchia iteratorów ``` + Input Iterator Output Iterator + ↓ ↓ + Forward Iterator ←────────┘ + ↓ + Bidirectional Iterator + ↓ + Random Access Iterator egzamin pyt05 PROI detail +Wyjaśnij: Kategorie iteratorów | Kategoria | Operacje | Przykłady kontenerów | +|-----------|----------|---------------------| +| Input | `++`, ``, `==`, `!=` | istream_iterator | +| Output | `++`, `` (zapis) | ostream_iterator | +| Forward | Input + wielokrotne przejście | forward_list, unordered_* | +| **Bidirectional*
std::vector vec = {1, 2, 3, 4, 5}; egzamin pyt05 PROI detail +Wyjaśnij: Iteratory specjalne ```cpp +#include +#include +#include
std::vector vec = {1, 2, 3}; egzamin pyt05 PROI detail +Wyjaśnij: Kluczowa zasada: Ortogonalność M kontenerów × N algorytmów = M + N implementacji (nie M × N!)
Dzięki iteratorom: +- Algorytm `sort` działa z `vector`, `deque`, `array` +- Każdy nowy kontener automatycznie współpracuje z istniejącymi algorytmami +- Każdy nowy algorytm automatycznie współpracuje z istniejącymi kontenerami egzamin pyt05 PROI detail +Omówić metody reużywalności kodu i struktur danych w obiektowych językach programowania. Reużywalność kodu (code reuse) to fundamentalna zasada inżynierii oprogramowania - "nie wynajduj koła na nowo". W programowaniu obiektowym mamy kilka mechanizmów umożliwiających wielokrotne wykorzystanie kodu.
### Główne metody reużywalności egzamin pyt06 PROI main +Wyjaśnij: Główne metody reużywalności ``` +┌─────────────────────────────────────────────────────────────────┐ +│ METODY REUŻYWALNOŚCI │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ DZIEDZICZENIE │ KOMPOZYCJA │ PROGRAMOWANIE │ +│ (Inheritance) │ (C
## 1. Dziedziczenie (Inheritance) egzamin pyt06 PROI detail +Wyjaśnij: Typy dziedziczenia | Typ | Opis | Języki | +|-----|------|--------| +| Pojedyncze | Jedna klasa bazowa | Java, C# | +| Wielokrotne | Wiele klas bazowych | C++, Python | +| Wielopoziomowe | A → B → C | Wszystkie | +| Hierarchiczne | A → B, A → C | Wszystkie | egzamin pyt06 PROI detail +Wyjaśnij: Zalety i wady dziedziczenia | Zalety | Wady | +|--------|------| +| Naturalne modelowanie hierarchii | Silne wiązanie (tight coupling) | +| Polimorfizm | Problem kruchej klasy bazowej | +| Łatwe rozszerzanie | Problemy z wielodziedziczeniem (diamond) | +| Współdzielenie implementacji | Narusza enkapsulację | egzamin pyt06 PROI detail +Wyjaśnij: Problem diamentu (Diamond Problem) ``` + A + / \ + B C + \ / + D +```
D d; +// d.metoda(); // BŁĄD: niejednoznaczne! +d.B::metoda(); // OK - jawne wskazanie +``` egzamin pyt06 PROI detail +Wyjaśnij: Typy relacji obiektowych | Relacja | Siła | Cykl życia | Przykład | +|---------|------|------------|----------| +| Kompozycja | Silna | Zależny (owns) | Samochód → Silnik | +| Agregacja | Słaba | Niezależny (uses) | Uniwersytet → Student | +| Asocjacja | Luźna | Niezależny | Klient ↔ Zamówienie |
// Agregacja - student istnieje niezależnie od uniwersytetu +class Uniwersytet { +private: + std::vector> studenci; // Wskaźniki/referencje +public: + void dodajStudenta(Student s) { studenci.push_back(s); } + // ~Uniwersytet() NIE niszczy studentów +}; +``` egzamin pyt06 PROI detail +Wyjaśnij: Szablony w C++ ```cpp +// Szablon funkcji +template +T maximum(T a, T b) { + return (a > b) ? a : b; +}
// Użycie - kompilator generuje wersje dla każdego typu +int m1 = maximum(3, 5); // int +double m2 = maximum(3.14, 2.71); // double +std::string m3 = maximum("abc", "xyz"); // string egzamin pyt06 PROI detail +Wyjaśnij: Generyki w Java/C# ```java +// Java +public class Box { + private T value; + + public void set(T value) { this.value = value; } + public T get() { return value; } +}
// Ograniczenia typów (bounded type parameters) +public > T max(T a, T b) { + return a.compareTo(b) > 0 ? a : b; +} +``` egzamin pyt06 PROI detail +Wyjaśnij: Zalety programowania generycznego | Zaleta | Opis | +|--------|------| +| Type safety | Błędy wykrywane w czasie kompilacji | +| Brak duplikacji | Jeden kod dla wielu typów | +| Wydajność | C++: specjalizacja w kompilacji, brak rzutowania | +| Czytelność | Jawne wymagania typów | egzamin pyt06 PROI detail +Wyjaśnij: Interfejsy vs Klasy abstrakcyjne | Cecha | Interfejs | Klasa abstrakcyjna | +|-------|-----------|-------------------| +| Wielodziedziczenie | TAK | NIE (Java/C#) | +| Pola | NIE (do Java 8) | TAK | +| Konstruktor | NIE | TAK | +| Implementacja metod | default (Java 8+) | TAK | +| Cel | Definiuje kontrakt | Współdzieli implementację | egzamin pyt06 PROI detail +Wyjaśnij: Wzorzec strategii (Strategy Pattern) ```cpp +// Interfejs strategii +class SortStrategy { +public: + virtual void sort(std::vector& data) = 0; + virtual ~SortStrategy() = default; +};
class QuickSort : public SortStrategy { +public: + void sort(std::vector& data) override { / quicksort / } +}; egzamin pyt06 PROI detail +Wyjaśnij: Mixiny (Mixins) Klasy dostarczające funkcjonalność do "wmieszania" do innych klas.
class XMLSerializableMixin: + def to_xml(self): + # implementacja... + pass egzamin pyt06 PROI detail +Wyjaśnij: Traity (Traits) ```rust +// Rust - traits +trait Drawable { + fn draw(&self); +}
trait Movable { + fn move_to(&mut self, x: i32, y: i32); +} egzamin pyt06 PROI detail +Wyjaśnij: Poziomy reużywalności ``` +┌─────────────────────────────────────────────────────┐ +│ FRAMEWORK │ +│ (IoC, definiuje architekturę aplikacji) │ +├─────────────────────────────────────────────────────┤ +│ BIBLIOTEKA │ +│ (kolekcja egzamin pyt06 PROI detail +Wyjaśnij: Wzorce wspierające reużywalność | Wzorzec | Typ | Cel | +|---------|-----|-----| +| Factory Method | Kreacyjny | Delegacja tworzenia obiektów | +| Abstract Factory | Kreacyjny | Rodziny powiązanych obiektów | +| Prototype | Kreacyjny | Klonowanie obiektów | +| Adapter | Strukturalny | Dopasowanie interfejsów | +| **Decor egzamin pyt06 PROI detail +Które serwery DNS najwięcej zyskują dzięki buforowaniu zapytań (caching) w serwerach rekursywnych? Jakie znasz rodzaje serwerów DNS? DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin pyt07 SKM main +Wyjaśnij: Wprowadzenie do DNS DNS (Domain Name System) to hierarchiczny, rozproszony system tłumaczenia nazw domenowych na adresy IP (i odwrotnie). egzamin pyt07 SKM detail +Wyjaśnij: 1 Serwery autorytatywne (Authoritative) • 13 logicznych serwerów:: a.root-servers.net do m.root-servers.net
• Fizycznie:: Setki serwerów (anycast)
• Funkcja:: Wskazują serwery TLD
• gTLD:: .com, .org, .net (generic)
• ccTLD:: .pl, .de, .uk (country code) egzamin pyt07 SKM detail +Wyjaśnij: 2 Serwery rekursywne (Recursive Resolvers) Definicja: Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne. egzamin pyt07 SKM detail +Wyjaśnij: 3 Stub Resolvers (Resolwery klienckie) Definicja: Prosty klient DNS w systemie operacyjnym. Wysyła zapytanie do rekursywnego resolvera i czeka na odpowiedź.
- Windows: usługa DNS Client +- Linux: libc resolver (nsswitch.conf, resolv.conf) +- Nie wykonuje rekurencji sam egzamin pyt07 SKM detail +Wyjaśnij: 4 Forwarding Servers (Przekazujące) Definicja: Przyjmują zapytania i przekazują je do innego resolvera zamiast samodzielnie rozwiązywać.
## 2. Proces rozwiązywania DNS (Resolution) egzamin pyt07 SKM detail +Wyjaśnij: Zapytanie rekursywne vs iteracyjne ``` +ZAPYTANIE REKURSYWNE (klient → resolver): +"Daj mi odpowiedź na www.example.com" +→ Resolver musi zwrócić ostateczną odpowiedź lub błąd
ZAPYTANIE ITERACYJNE (resolver → authoritative): +"Co wiesz o www.example.com?" +→ Serwer zwraca odpowiedź lub odesłanie (referral) +``` egzamin pyt07 SKM detail +Wyjaśnij: Pełny proces rozwiązywania ``` +Klient Recursive Root .com TLD example.com + │ Resolver │ │ │ + │──(1) www.example.com?──→│ │ │ │ + │ │──(2) query?───→│ │ │
## 3. Buforowanie (Caching) w DNS egzamin pyt07 SKM detail +Wyjaśnij: TTL (Time To Live) ``` +; Fragment strefy DNS +www.example.com. 300 IN A 93.184.216.34 + ↑ + TTL = 300 sekund (5 minut) +```
## 4. Które serwery zyskują najwięcej na cachingu? egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego root servers zyskują najwięcej? ``` +BEZ CACHINGU: +┌────────────────────────────────────────────────────────────────┐ +│ Każde zapytanie DNS → najpierw pytanie do root server │ +│ Miliardy zapytań dziennie → root servers byłyby przeciążone! │ +└────────────────────────────────────────────────────────────────┘
Z CACHINGIEM: +┌────────────────────────────────────────────────────────────────┐ +│ Resolver pyta root server RAZ o serwery .com │ +│ Cache przechowuje referral przez długi czas (np. 48h) │ +│ Kolejne tysiące zapytań o .com → z cache, bez root │ +└──────────────────── egzamin pyt07 SKM detail +Wyjaśnij: Analiza ilościowa | Poziom | Liczba domen | Zapytania bez cache | Z cache | +|--------|--------------|---------------------|---------| +| Root | 1 (.) | ~100% zapytań | ~0.01% | +| TLD | ~1500 | ~100% zapytań | ~0.1% | +| Authoritative | Miliony | Proporcjonalnie | Zależne od TTL | egzamin pyt07 SKM detail +Wyjaśnij: Dlaczego ROOT i TLD zyskują więcej niż authoritative? Mniejsza liczba = więcej zapytań na serwer:: 13 root servers vs miliony domen
Długie TTL referrali:: Root NS referrals: TTL 48h - 7 dni egzamin pyt07 SKM detail +Wyjaśnij: Podsumowanie zysków z cachingu ``` +REDUKCJA RUCHU DZIĘKI CACHINGOWI:
Root Servers: ████████████████████████████░░ ~99.9% redukcja +TLD Servers: ██████████████████████████░░░░ ~99% redukcja +Authoritative: ████████████░░░░░░░░░░░░░░░░░░ ~50-90% redukcja* egzamin pyt07 SKM detail +Jaki jest cel uzgadniania trójetapowego (three way handshake) w protokole TCP? Jaka jest interpretacja numerów sekwencyjnych i potwierdzenia? Jaka jest wartość początkowa numeru sekwencyjnego? TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: +- Niezawodne dostarczanie danych +- Kontrolę przepływu +- Kontrolę przeciążenia +- Połączeniowość (connection-oriented) egzamin pyt08 SKM main +Wyjaśnij: Wprowadzenie do TCP TCP (Transmission Control Protocol) to protokół warstwy transportowej zapewniający: +- Niezawodne dostarczanie danych +- Kontrolę przepływu +- Kontrolę przeciążenia +- Połączeniowość (connection-oriented)
## 1. Three-Way Handshake - cel i przebieg egzamin pyt08 SKM detail +Wyjaśnij: Cele uzgadniania trójetapowego Nawiązanie połączenia: obie strony zgadzają się na komunikację
Synchronizacja numerów sekwencyjnych: ISN (Initial Sequence Number)
Uzgodnienie parametrów: MSS, Window Scale, SACK, Timestamps
Weryfikacja dostępności: obie strony są aktywne i gotowe egzamin pyt08 SKM detail +Wyjaśnij: Przebieg (diagram) ``` + Klient Serwer + │ │ + │ (1) SYN, seq=x │ + │──────────────────────────────────────────→│ + │ │ + │ (2) SYN+ACK, seq=y, ack= egzamin pyt08 SKM detail +Wyjaśnij: Szczegółowy opis kroków #### Krok 1: SYN (Synchronize) +``` +Klient → Serwer: +┌────────────────────────────────────────┐ +│ Flaga: SYN = 1 │ +│ Sequence Number: x (ISN klienta) │ +│ Acknowledgment Number: 0 (nieistotny) │ +│ Opcje: MSS, Window Scale, SACK, etc. │ +└────────────────────────────────
#### Krok 2: SYN-ACK (Synchronize-Acknowledge) +``` +Serwer → Klient: +┌────────────────────────────────────────┐ +│ Flagi: SYN = 1, ACK = 1 │ +│ Sequence Number: y (ISN serwera) │ +│ Acknowledgment Number: x + 1 │ +│ Opcje: MSS, Window Scale, etc. │ +└──────────────── egzamin pyt08 SKM detail +Wyjaśnij: Interpretacja Sequence Number (SEQ) = numer pierwszego bajtu danych w segmencie
Segment 1: SEQ=0, dane = bajty 0-4 (5 bajtów) +Segment 2: SEQ=5, dane = bajty 5-9 (5 bajtów) +Segment 3: SEQ=10, dane = bajty 10-12 (3 bajty) +``` egzamin pyt08 SKM detail +Wyjaśnij: Funkcje numerów sekwencyjnych | Funkcja | Opis | +|---------|------| +| Kolejność | Odbiorca składa segmenty we właściwej kolejności | +| Wykrywanie duplikatów | Ten sam SEQ = duplikat | +| Wykrywanie braków | Luka w SEQ = brakujący segment | +| Potwierdzanie | ACK wskazuje oczekiwany następny SEQ | egzamin pyt08 SKM detail +Wyjaśnij: Selective ACK (SACK) Opcja TCP pozwalająca potwierdzać niesąsiednie bloki:
## 4. Wartość początkowa numeru sekwencyjnego (ISN) egzamin pyt08 SKM detail +Wyjaśnij: Dlaczego ISN nie zaczyna od 0? Bezpieczeństwo: przewidywalny ISN umożliwia ataki (TCP hijacking)
Unikanie kolizji: stare segmenty z poprzednich połączeń nie będą mylone z nowymi egzamin pyt08 SKM detail +Wyjaśnij: Generowanie ISN • M: = timer (jak wyżej)
• F: = funkcja kryptograficzna (MD5/SHA)
• secretkey: = tajny klucz serwera egzamin pyt08 SKM detail +Wyjaśnij: Właściwości dobrego ISN | Właściwość | Powód | +|------------|-------| +| Losowy | Utrudnia ataki typu sequence prediction | +| Unikalny | Różny dla każdego połączenia | +| Monotonicznie rosnący | Unikanie kolizji z poprzednimi połączeniami | egzamin pyt08 SKM detail +Wyjaśnij: Zakres numerów sekwencyjnych ``` +SEQ: 32 bity → zakres 0 do 4,294,967,295 (2^32 - 1)
Przy szybkości 1 Gbps: +- 125 MB/s danych +- Przepełnienie (wrap-around) co ~34 sekundy! egzamin pyt08 SKM detail +Procesy i wątki w systemie operacyjnym. Omówić budowę, szybkość działania i zakres zastosowania. Przedstawić problemy i możliwości komunikacji i synchronizacji. Proces i wątek to podstawowe jednostki wykonania w systemach operacyjnych. Różnią się poziomem izolacji i kosztami przełączania. egzamin pyt09 SOI main +Wyjaśnij: Budowa procesu ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PRZESTRZEŃ ADRESOWA PROCESU │ +├─────────────────────────────────────────────────────────────────┤ +│ ┌─────────────────┐ │ +│ │ STOS │ egzamin pyt09 SOI detail +Wyjaśnij: Stany procesu ``` + ┌──────────────────┐ + (utworzenie) │ │ (zakończenie) + ↓ │ │ ↓ + ┌─────────┐ │ ┌──────────┐ │ ┌──────────┐ + │ NEW │───┼──→│ READY │←──┼──│TERMINATED│ + └─────────┘ │ └──────────┘ │ egzamin pyt09 SOI detail +Wyjaśnij: Budowa wątku ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROCES │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ WSPÓŁDZIELONE: egzamin pyt09 SOI detail +Wyjaśnij: TCB (Thread Control Block) | Pole | Opis | +|------|------| +| TID | Identyfikator wątku | +| Stan | Running, Ready, Blocked | +| Rejestry | PC, SP, rejestry ogólne | +| Stos | Wskaźnik do prywatnego stosu | +| Priorytet | Szeregowanie | +| Wskaźnik do PCB | Proces macierzysty |
## 3. Porównanie: Proces vs Wątek egzamin pyt09 SOI detail +Wyjaśnij: Tabela porównawcza | Cecha | Proces | Wątek | +|-------|--------|-------| +| Przestrzeń adresowa | Własna, izolowana | Współdzielona z procesem | +| Tworzenie | Wolne (~ms) | Szybkie (~μs) | +| Przełączanie kontekstu | Wolne (TLB flush) | Szybkie (tylko rejestry) | +| Komunikacja | IPC (pipe, socket, shm) | egzamin pyt09 SOI detail +Wyjaśnij: Koszty czasowe (typowe) | Operacja | Czas | +|----------|------| +| Tworzenie procesu | 1-10 ms | +| Tworzenie wątku | 10-100 μs | +| Przełączanie procesu | 1-10 μs | +| Przełączanie wątku | 0.1-1 μs | +| Komunikacja IPC | 1-100 μs | +| Współdzielona pamięć | 10-100 ns | egzamin pyt09 SOI detail +Wyjaśnij: Wątki użytkownika (User-level Threads) ``` +┌─────────────────────────────────────────┐ +│ PRZESTRZEŃ UŻYTKOWNIKA │ +│ ┌─────────────────────────────────┐ │ +│ │ Biblioteka wątków (pthread) │ │ +│ │ ┌─────┐ ┌─────┐ ┌─────┐ │ │ +│ │ │ W1 │ │ W2 │ │ W3 │ │ │ +│ │ └─────┘ └─────┘ └─────┘
Zalety: Szybkie przełączanie, przenośność +Wady: Blokujące wywołanie blokuje wszystkie wątki, brak prawdziwej równoległości egzamin pyt09 SOI detail +Wyjaśnij: Wątki jądra (Kernel-level Threads) ``` +┌─────────────────────────────────────────┐ +│ PRZESTRZEŃ UŻYTKOWNIKA │ +│ ┌─────┐ ┌─────┐ ┌─────┐ │ +│ │ W1 │ │ W2 │ │ W3 │ │ +│ └──┬──┘ └──┬──┘ └──┬──┘ │ +├─────────┼───────┼───────┼───────────────┤ +│ ↓ ↓ ↓
Zalety: Prawdziwa równoległość, blokada jednego nie blokuje innych +Wady: Wolniejsze operacje (wywołanie systemowe) egzamin pyt09 SOI detail +Wyjaśnij: Modele mapowania | Model | Opis | Przykłady | +|-------|------|-----------| +| 1:1 | 1 wątek user = 1 wątek kernel | Linux, Windows | +| N:1 | N wątków user = 1 wątek kernel | Green threads | +| M:N | M wątków user = N wątków kernel | Solaris, Go goroutines |
## 5. Komunikacja między procesami (IPC) egzamin pyt09 SOI detail +Wyjaśnij: Mechanizmy IPC ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MECHANIZMY IPC │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ SYGNAŁY │ POTOKI │ PAMIĘĆ WSPÓŁDZIELONA │ +│ (Signals) │ egzamin pyt09 SOI detail +Wyjaśnij: Szczegóły mechanizmów // Potok nazwany (FIFO) +mkfifo("/tmp/myfifo", 0666); +```
Cechy: Jednokierunkowe, FIFO, między powiązanymi procesami (anonimowe) egzamin pyt09 SOI detail +Wyjaśnij: Problemy współbieżności Mutual exclusion: zasób może mieć tylko jeden właściciel
Hold and wait: trzymaj i czekaj na więcej
No preemption: nie można odebrać zasobu
Circular wait: cykliczne oczekiwanie egzamin pyt09 SOI detail +Wyjaśnij: Mechanizmy synchronizacji • Binarny: (0/1) - jak mutex
• Licznikowy: ogranicza liczbę wątków (np. pula połączeń) egzamin pyt09 SOI detail +Wyjaśnij: Kiedy procesy? • Izolacja: awaria jednego nie wpływa na inne
• Bezpieczeństwo: różne uprawnienia
• Różne języki/technologie: mikrousługi
• Niezawodność: restart bez wpływu na system egzamin pyt09 SOI detail +Wyjaśnij: Kiedy wątki? • Współdzielenie danych: bez kopiowania
• Responsywność: UI thread + worker threads
• Równoległość CPU: obliczenia na wielu rdzeniach
• I/O asynchroniczne: czekanie nie blokuje wszystkiego egzamin pyt09 SOI detail +Scharakteryzować problemy i mechanizmy zarządzania pamięcią. Porównać cechy i przeznaczenie mechanizmów stronicowania i segmentacji. Zarządzanie pamięcią to jeden z kluczowych zadań systemu operacyjnego: +- Przydzielanie pamięci procesom +- Ochrona pamięci między procesami +- Efektywne wykorzystanie ograniczonego zasobu +- Abstrakcja (programista nie musi znać fizycznych adresów) egzamin pyt10 SOI main +Wyjaśnij: 1 Fragmentacja #### Fragmentacja zewnętrzna (External Fragmentation)
Problem: Wolna pamięć jest rozproszona w małych, nieciągłych blokach. egzamin pyt10 SOI detail +Wyjaśnij: 2 Ochrona pamięci - Proces A nie może czytać/pisać pamięci procesu B +- Jądro chronione przed aplikacjami użytkownika +- Mechanizmy: rejestry bazowy/graniczny, bity ochrony, ringi egzamin pyt10 SOI detail +Wyjaśnij: 5 Ograniczona pamięć fizyczna - Więcej procesów niż RAM +- Rozwiązanie: pamięć wirtualna + swap
## 2. Mechanizmy zarządzania pamięcią egzamin pyt10 SOI detail +Wyjaśnij: 1 Partycjonowanie stałe (Fixed Partitioning) ``` +┌────────────────────────────────────────────────────────────────┐ +│ Pamięć podzielona na stałe partycje: │ +│ ┌──────────┬──────────┬──────────┬──────────┐ │ +│ │ Partycja │ Partycja │ Partycja │ Partycja │ │ +│ │ 1MB │ 2MB │ egzamin pyt10 SOI detail +Wyjaśnij: 2 Partycjonowanie dynamiczne (Dynamic Partitioning) ``` +┌────────────────────────────────────────────────────────────────┐ +│ Partycje tworzone według potrzeb: │ +│ ┌─────┬───────────┬────────┬─────────────────────────────┐ │ +│ │ P1 │ P2 │ P3 │ WOLNA │ │ +│ │ 3MB │ 5MB │ 2MB egzamin pyt10 SOI detail +Wyjaśnij: Idea • Strona (Page): blok pamięci wirtualnej (4KB typowo)
• Ramka (Frame): blok pamięci fizycznej (ten sam rozmiar) egzamin pyt10 SOI detail +Wyjaśnij: Translacja adresu ``` +Adres wirtualny (32-bit, strony 4KB): +┌────────────────────────┬──────────────┐ +│ Numer strony (20b) │ Offset (12b) │ +└────────────────────────┴──────────────┘ + │ │ + ↓ │ + Tablica stron │ + │ egzamin pyt10 SOI detail +Wyjaśnij: Wielopoziomowe tablice stron Problem: Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = 4MB per proces!
Rozwiązanie: Hierarchiczna tablica stron egzamin pyt10 SOI detail +Wyjaśnij: TLB (Translation Lookaside Buffer) Problem: Każdy dostęp do pamięci wymaga 2+ odczytów (tablica + dane).
Rozwiązanie: Cache translacji adresów egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady stronicowania | Zalety | Wady | +|--------|------| +| Brak fragmentacji zewnętrznej | Fragmentacja wewnętrzna (ostatnia strona) | +| Prosta alokacja (bitmapa ramek) | Narzut tablicy stron | +| Łatwe współdzielenie (COW) | TLB miss kosztowny | +| Pamięć wirtualna naturalna | Nie odpowiada strukturze programu |
## 4. Segmentacja (Segmentation) egzamin pyt10 SOI detail +Wyjaśnij: Ochrona w segmentacji • R: (Read) - odczyt dozwolony
• W: (Write) - zapis dozwolony
• X: (Execute) - wykonanie dozwolone egzamin pyt10 SOI detail +Wyjaśnij: Zalety i wady segmentacji | Zalety | Wady | +|--------|------| +| Odpowiada strukturze programu | Fragmentacja zewnętrzna | +| Naturalna ochrona (per segment) | Segmenty o zmiennej wielkości | +| Łatwe współdzielenie (cały segment) | Kompaktowanie potrzebne | +| Dynamiczny wzrost segmentów | Skomplikowana alokacja |
## 5. Porównanie: Stronicowanie vs Segmentacja egzamin pyt10 SOI detail +Wyjaśnij: Intel x86 (tryb chroniony) flat memory model: wszystkie segmenty pokrywają całą przestrzeń adresową, efektywnie wyłączając segmentację. egzamin pyt10 SOI detail +Wyjaśnij: Zalety hybrydowego podejścia 1. Ochrona z segmentacji (kod vs dane vs stos) +2. Brak fragmentacji zewnętrznej ze stronicowania +3. Pamięć wirtualna ze stronicowania
## 7. Pamięć wirtualna (Virtual Memory) egzamin pyt10 SOI detail +Wyjaśnij: Algorytmy zastępowania stron | Algorytm | Opis | Właściwości | +|----------|------|-------------| +| FIFO | Najstarsza strona | Prosty, anomalia Bélády'ego | +| LRU | Najdawniej używana | Optymalny offline, kosztowny | +| LRU Approximation | Clock, Second Chance | Praktyczny kompromis | +| LFU | Najrzadziej używana | egzamin pyt10 SOI detail +Wyjaśnij: Algorytm Clock (Second Chance) ``` + ┌───┐ + ┌──→│ 1 │──┐ Bit referencji: + │ └───┘ │ 1 = używana ostatnio + │ ↓ 0 = kandydat do usunięcia +┌───┐ ┌───┐ +│ 0 │ │ 1 │ Wskazówka zegara: +└───┘ └───┘ - Jeśli bit=1: zeruj, idź dalej + ↑ │ - Jeśli bit=0: zastąp egzamin pyt10 SOI detail +Scharakteryzować standardy i narzędzia do modelowania procesów biznesowych. Modelowanie procesów biznesowych to graficzne przedstawienie przepływu pracy, działań i decyzji w organizacji. Służy do: +- Dokumentowania procesów +- Analizy i optymalizacji +- Automatyzacji (workflow, BPM) +- Komunikacji między działami egzamin pyt11 WSYZ main +Wyjaśnij: Przegląd standardów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ STANDARDY MODELOWANIA PROCESÓW │ +├─────────────────┬─────────────────┬─────────────────────────────┤ +│ BPMN │ UML │ EPC │ +│ Business │ Act
## 2. BPMN (Business Process Model and Notation) egzamin pyt11 WSYZ detail +Wyjaśnij: Podstawowe elementy BPMN #### Flow Objects (Obiekty przepływu)
┌─────────────────────────────────────────────────────────────────┐ +│ CZYNNOŚCI (Activities) │ +│ │ +│ ┌─────────┐ │ +│ │ │ Zadanie ( egzamin pyt11 WSYZ detail +Wyjaśnij: Elementy Activity Diagrams ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WĘZŁY AKCJI │ +│ │ +│ ╭─────────╮ │ +│ │ Akcja │ Actio
┌─────────────────────────────────────────────────────────────────┐ +│ WĘZŁY STERUJĄCE │ +│ │ +│ ● Initial Node (początek) │ +│ ◉ Activity Final (kon egzamin pyt11 WSYZ detail +Wyjaśnij: Porównanie BPMN vs UML Activity | Cecha | BPMN | UML Activity | +|-------|------|--------------| +| Cel | Procesy biznesowe | Logika oprogramowania | +| Odbiorcy | Analitycy, biznes | Programiści, architekci | +| Swimlanes | Pool/Lane | Partition | +| Zdarzenia | Bogate (timer, message...) | Ograniczone | +| **Automatyza
## 4. EPC (Event-driven Process Chain) egzamin pyt11 WSYZ detail +Wyjaśnij: Elementy EPC ``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ ⬡ Zdarzenie (Event) - pasywne, opisuje stan │ +│ np. "Zamówienie otrzymane" │ +│ egzamin pyt11 WSYZ detail +Wyjaśnij: Reguły EPC 1. Start i koniec: Zdarzenie +2. Naprzemienność: Zdarzenie → Funkcja → Zdarzenie +3. Łączniki: Między zdarzeniami a funkcjami
⬡ Zamówienie otrzymane + │ + ↓ + ▭ Sprawdź dostępność + │ + ↓ + XOR + / \ + ↓ ↓ +⬡ Produkt ⬡ Produkt + dostępny niedostępny + │ │ + ↓ ↓ +▭ Przygotuj ▭ Złóż + wysyłkę zamówienie + │ u dostawcy + ↓ egzamin pyt11 WSYZ detail +Wyjaśnij: Rodzina IDEF | Standard | Nazwa | Zastosowanie | +|----------|-------|--------------| +| IDEF0 | Function Modeling | Hierarchia funkcji | +| IDEF1 | Information Modeling | Struktura danych | +| IDEF1X | Data Modeling | Bazy danych (ERD) | +| IDEF3 | Process Description | Przepływ procesów | +| **IDEF4* egzamin pyt11 WSYZ detail +Wyjaśnij: IDEF0 - Modelowanie funkcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ KONTROLA (C) │ +│ │ │ +│ ↓ │ +│ WEJŚCIE (I) ────→ ┌ egzamin pyt11 WSYZ detail +Wyjaśnij: Dekompozycja IDEF0 ``` +Poziom 0: A0 - Całość procesu + │ + ├── A1 - Podfunkcja 1 + │ ├── A11 + │ ├── A12 + │ └── A13 + │ + ├── A2 - Podfunkcja 2 + │ + └── A3 - Podfunkcja 3 +``` egzamin pyt11 WSYZ detail +Wyjaśnij: Flowcharts (Schematy blokowe) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Symbole: │ +│ │ +│ ⬭ Terminal (Start/End) │ +│ ▭ Process (Operac
Zalety: Proste, uniwersalne, znane +Wady: Brak standaryzacji, niewystarczające dla złożonych procesów egzamin pyt11 WSYZ detail +Wyjaśnij: Value Stream Map (VSM) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Lean Manufacturing │ +│ │ +│ Supplier ──→ [Magazyn] ──→ [Produkcja] ──→ [QC] ──→ Customer │ +│ Inv: 5d egzamin pyt11 WSYZ detail +Wyjaśnij: Petri Nets (Sieci Petriego) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Formalizm matematyczny dla współbieżności │ +│ │ +│ ○ Place (Miejsce) - stan │ +│ ▭ Transition (Prz egzamin pyt11 WSYZ detail +Wyjaśnij: Przegląd narzędzi | Narzędzie | Standardy | Typ | Cena | +|-----------|-----------|-----|------| +| Bizagi Modeler | BPMN | Dedykowane | Free/Paid | +| Camunda Modeler | BPMN, DMN | Open Source | Free | +| Signavio | BPMN, EPC | Cloud | Paid | +| ARIS | EPC, BPMN | Enterprise | Paid | +| **Enterprise Archit egzamin pyt11 WSYZ detail +Wyjaśnij: Funkcjonalności narzędzi | Funkcja | Podstawowe | Zaawansowane | +|---------|------------|--------------| +| Modelowanie graficzne | ✓ | ✓ | +| Walidacja modelu | ✗ | ✓ | +| Symulacja | ✗ | ✓ | +| Wykonywanie (engine) | ✗ | ✓ | +| Eksport (XML, PDF) | ✓ | ✓ | +| Współpraca | ✗/Cloud | ✓ | +| Integracja z IT | ✗ | ✓ | egzamin pyt11 WSYZ detail +Przedstawić sieciowe modele optymalizacji stosowane w systemach zarządzania. Omówić ich właściwości. • Węzły: = punkty decyzyjne, lokalizacje, zdarzenia
• Krawędzie: = połączenia, przepływy, zależności
• Wagi: = koszty, czasy, przepustowości egzamin pyt12 WSYZ main +Wyjaśnij: Zastosowania w zarządzaniu - Optymalizacja tras dostaw +- Planowanie logistyki +- Routing w sieciach telekomunikacyjnych
## 2. Problem maksymalnego przepływu (Max Flow) egzamin pyt12 WSYZ detail +Wyjaśnij: Zastosowania - Planowanie produkcji (przepustowość linii) +- Zarządzanie siecią dystrybucji +- Przydział zasobów
## 3. Problem minimalnego kosztu przepływu (Min Cost Flow) egzamin pyt12 WSYZ detail +Wyjaśnij: CPM (Critical Path Method) ``` + ┌──B(3)──┐ + ╱ ╲ +A(2)──┤ ├──E(2)──F(1) + ╲ ╱ + └──C(4)──D(1)
Ścieżka krytyczna: A→C→D→E→F (czas: 2+4+1+2+1=10) +``` egzamin pyt12 WSYZ detail +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. prywatny stan: Komunikuje się wyłącznie przez
wiadomości: Może tworzyć nowych aktorów egzamin pyt13 AASD main +Wyjaśnij: Definicje fundamentalne prywatny stan: Komunikuje się wyłącznie przez
wiadomości: Może tworzyć nowych aktorów egzamin pyt13 AASD detail +Wyjaśnij: Agent vs Aktor | Cecha | Agent | Aktor | +|-------|-------|-------| +| Cel | Inteligentne zachowanie | Współbieżność | +| Stan | Beliefs, Goals, Intentions | Prywatny, izolowany | +| Komunikacja | ACL (semantyka) | Wiadomości (asynchroniczne) | +| Autonomia | Wysoka (decyzje) | Średnia (reaktywność) | +| egzamin pyt13 AASD detail +Wyjaśnij: Standardy komunikacji agentów #### FIPA (Foundation for Intelligent Physical Agents)
FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD detail +Wyjaśnij: Algorytmy negocjacji i aukcji #### Contract Net Protocol (CNP)
Manager Contractors + │ ┌───┬───┬───┐ + │────── cfp ──────────→│ A │ B │ C │ + │ └───┴───┴───┘ + │←───── propose ─────── │ │ + │←───── propose ──────────── │ + │←───── propose ── egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy konsensusu #### Raft (dla systemów aktorowych)
Leader Election: +1. Follower timeout → staje się Candidate +2. Candidate wysyła RequestVote do wszystkich +3. Większość głosów → nowy Leader +4. Leader wysyła heartbeats egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy koordynacji #### Distributed Mutual Exclusion
Algorytm Ricarta-Agrawali: +``` +Wejście do sekcji krytycznej: +1. Wyślij REQUEST(timestamp) do wszystkich +2. Czekaj na REPLY od wszystkich +3. Wejdź do sekcji krytycznej egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy dla aktorów #### Supervision Strategies (Akka)
// All-for-One: restart wszystkich dzieci +override val supervisorStrategy = + AllForOneStrategy() { + case _: Exception => Restart + } +``` egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy planowania (BDI) Plans: + plan1: walk(X,Y) :- distance(X,Y) < 1km + plan2: drive(X,Y) :- have(car), distance(X,Y) >= 1km + plan3: take_bus(X,Y) :- bus_available(X,Y)
Wybór planu na podstawie: +- Kontekstu (beliefs) +- Preferencji +- Kosztu +``` egzamin pyt14 AASD detail +Wyjaśnij: Algorytmy formowania koalicji φᵢ = Σ [|S|!(n-|S|-1)!/n!] × [v(S∪{i}) - v(S)]
Gdzie: +- S = podzbiór agentów bez i +- v(S) = wartość koalicji S +- n = liczba agentów egzamin pyt14 AASD detail +Wyjaśnij: Cele modelowania architektury | Cel | Opis | +|-----|------| +| Komunikacja | Wspólny język dla stakeholderów | +| Dokumentacja | Zapis decyzji architektonicznych | +| Analiza | Weryfikacja atrybutów jakościowych | +| Planowanie | Roadmapa rozwoju systemu | +| Zarządzanie złożonością | Abstrakcja, dekompozycja | egzamin pyt15 AIS detail +Wyjaśnij: ADR (Architecture Decision Records) ```markdown +# ADR-001: Wybór bazy danych
## Context +System wymaga przechowywania danych użytkowników... egzamin pyt15 AIS detail +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne. • Nazwa: identyfikator
• Kontekst: kiedy stosować
• Problem: co rozwiązuje
• Rozwiązanie: struktura i zachowanie
• Konsekwencje: trade-offs egzamin pyt16 AIS main +Wyjaśnij: Cel wzorców architektonicznych | Cel | Opis | +|-----|------| +| Reużywalność | Sprawdzone rozwiązania typowych problemów | +| Komunikacja | Wspólne słownictwo ("używamy MVC") | +| Dokumentacja | Zapis wiedzy architektonicznej | +| Jakość | Adresowanie atrybutów jakościowych | +| Edukacja | Nauka z doświadczeń innyc egzamin pyt16 AIS detail +Wyjaśnij: Jak powstają wzorce • Nazwa: identyfikator
• Kontekst: kiedy stosować
• Problem: co rozwiązuje
• Rozwiązanie: struktura i zachowanie
• Konsekwencje: trade-offs egzamin pyt16 AIS detail +Wyjaśnij: Katalogowanie wzorców | Katalog | Zakres | Przykłady | +|---------|--------|-----------| +| POSA (Pattern-Oriented Software Architecture) | Architektura | Layers, Pipes&Filters | +| GoF (Gang of Four) | Projektowe | Factory, Observer | +| EIP (Enterprise Integration Patterns) | Integracja | Message Router, Aggreg egzamin pyt16 AIS detail +Wyjaśnij: Porównanie wzorców | Wzorzec | Skalowalność | Złożoność | Use Case | +|---------|--------------|-----------|----------| +| Monolith | Niska | Niska | MVP, małe zespoły | +| Layered | Średnia | Niska | Enterprise CRUD | +| Microservices | Wysoka | Wysoka | Duże systemy | +| Event-Driven | Wysoka | Średnia | egzamin pyt16 AIS detail +Wyjaśnij: Optymalizacja bez ograniczeń #### Problem +$$\min_{x \in \mathbb{R}^n} f(x)$$
#### Warunki konieczne (I rzędu) +Jeśli $x^$ jest minimum lokalnym i $f$ jest różniczkowalna: +$$\nabla f(x^) = 0$$ egzamin pyt17 AMO detail +Wyjaśnij: Optymalizacja z ograniczeniami #### Problem ogólny +$$\min_{x} f(x)$$ +$$\text{s.t. } g_i(x) \leq 0, \quad i = 1, \ldots, m$$ +$$\quad\quad h_j(x) = 0, \quad j = 1, \ldots, p$$
#### Lagrangian +$$L(x, \lambda, \mu) = f(x) + \sum_{i=1}^{m} \lambda_i g_i(x) + \sum_{j=1}^{p} \mu_j h_j(x)$$ egzamin pyt17 AMO detail +Wyjaśnij: Warunki KKT (Karush-Kuhn-Tucker) Jeśli $x^*$ jest minimum i spełnione są warunki regularności:
1. Stacjonarność: +$$\nabla_x L(x^, \lambda^, \mu^*) = 0$$ egzamin pyt17 AMO detail +Wyjaśnij: Warunki regularności (Constraint Qualification) Warunki zapewniające, że KKT są konieczne:
LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne egzamin pyt17 AMO detail +Wyjaśnij: Warunki dostateczne II rzędu Jeśli spełnione KKT i dla hesjanu Lagrangianu: +$$d^T \nabla_{xx}^2 L(x^, \lambda^, \mu^*) d > 0$$
dla wszystkich $d \neq 0$ spełniających: +- $\nabla g_i(x^)^T d = 0$ dla aktywnych $g_i$ +- $\nabla h_j(x^)^T d = 0$ dla wszystkich $h_j$ egzamin pyt17 AMO detail +Wyjaśnij: Porównanie metod | Metoda | Ograniczenia | Złożoność iter. | Zbieżność | +|--------|--------------|-----------------|-----------| +| Gradient | Bez | O(n) | Liniowa | +| Newton | Bez | O(n³) | Kwadratowa | +| BFGS | Bez | O(n²) | Superlinearna | +| SQP | Z | O(n³) per QP | Superlinearna | +| **Interior Poi egzamin pyt17 AMO detail +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. ### 1. Programowanie liniowe (LP)
#### Postać standardowa +$$\min c^T x$$ +$$\text{s.t. } Ax = b, \quad x \geq 0$$ egzamin pyt18 AMO main +Wyjaśnij: Programowanie liniowe (LP) #### Postać standardowa +$$\min c^T x$$ +$$\text{s.t. } Ax = b, \quad x \geq 0$$
c^T x = const + ↘ + ●───────● + /│ /│ + / │ / │ Wielościan dopuszczalny + ●──┼────● │ + │ ●────┼──● + │ / │ / + │/ │/ + ●───────● ← optimum (wierzchołek) +``` egzamin pyt18 AMO detail +Wyjaśnij: Programowanie kwadratowe (QP) #### Postać ogólna +$$\min \frac{1}{2} x^T Q x + c^T x$$ +$$\text{s.t. } Ax \leq b, \quad Ex = d$$
Gdzie Q jest macierzą symetryczną. egzamin pyt18 AMO detail +Wyjaśnij: Metody rozwiązywania QP 1. Zgadnij zbiór aktywnych ograniczeń W +2. Rozwiąż QP z ograniczeniami W jako równości +3. Sprawdź: + - Czy rozwiązanie dopuszczalne? (jeśli nie: usuń z W) + - Czy mnożniki ≥ 0? (jeśli nie: dodaj do W) +4. Powtarzaj do zbieżności +```
Zalety: Dokładne rozwiązanie, warm start +Wady: Liczba iteracji zależy od kombinatoryki egzamin pyt18 AMO detail +Wyjaśnij: Przypadki szczególne #### Least Squares (najmniejsze kwadraty) +$$\min \|Ax - b\|_2^2 = \min x^T A^T A x - 2b^T A x + b^T b$$
Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO detail +Wyjaśnij: Narzędzia | Narzędzie | Typ | Metody | +|-----------|-----|--------| +| CPLEX | Komercyjny | Simplex, Barrier, QP | +| Gurobi | Komercyjny | Simplex, Barrier, QP | +| GLPK | Open source | Simplex | +| OSQP | Open source | ADMM dla QP | +| CVXPY | Python | Interfejs do solverów | egzamin pyt18 AMO detail +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). • Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę
• Ekstrakcja informacji fonetycznej: Usunięcie informacji mówcy (częściowo)
• Reprezentacja kompaktowa: dla modeli (HMM, DNN)
• Dźwięczne:: pobudzenie okresowe (struny głosowe)
• Bezdźwięczne:: pobudzenie szumowe egzamin pyt19 EASAR main +Wyjaśnij: Cel parametryzacji mowy • Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę
• Ekstrakcja informacji fonetycznej: Usunięcie informacji mówcy (częściowo)
• Reprezentacja kompaktowa: dla modeli (HMM, DNN) egzamin pyt19 EASAR detail +Wyjaśnij: LPC (Linear Predictive Coding) • Dźwięczne:: pobudzenie okresowe (struny głosowe)
• Bezdźwięczne:: pobudzenie szumowe egzamin pyt19 EASAR detail +Wyjaśnij: Porównanie MFCC vs LPC | Cecha | MFCC | LPC | +|-------|------|-----| +| Podstawa | Percepcja słuchowa | Model produkcji mowy | +| Filtracja | Bank filtrów Mel | Model all-pole | +| Wymiarowość | 12-13 + delty | 10-20 | +| Zastosowanie | Rozpoznawanie mowy | Kodowanie, synteza | +| Korelacja | Niska (DCT dek egzamin pyt19 EASAR detail +Wyjaśnij: Rozszerzenia #### PLP (Perceptual Linear Prediction) +Łączy LPC z percepcją słuchową: +- Filtracja w skali Bark +- Krzywa równej głośności +- Kompresja intensity-loudness
#### Filter Banks (dla DNN) +Nowoczesne podejście: +- Log Mel filterbanks (bez DCT) +- 40-80 filtrów +- DNN uczy się własnych cech egzamin pyt19 EASAR detail +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. ### 1. System rozpoznawania mowy - architektura
### 2. HMM (Hidden Markov Model) - klasyczne podejście egzamin pyt20 EASAR main +Wyjaśnij: System rozpoznawania mowy - architektura ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Sygnał audio │ +│ ↓ │ +│ [Ekstrakcja cech] ──→ MFCC/Filterbanks │ +│ ↓ egzamin pyt20 EASAR detail +Wyjaśnij: HMM (Hidden Markov Model) - klasyczne podejście Każdy stan emituje obserwacje (MFCC) według rozkładu GMM: +b_j(o) = Σ_m c_{jm} N(o; μ_{jm}, Σ_{jm}) +```
α_t(j) = max_{i} [α_{t-1}(i) · a_{ij}] · b_j(o_t) egzamin pyt20 EASAR detail +Wyjaśnij: Deep Learning w rozpoznawaniu mowy Attention-based (Seq2Seq): +┌──────────────────────────────────────────────────────────────┐ +│ Audio → [Encoder] → [Attention] → [Decoder] → Tekst │ +│ ↓ │ +│ Wyrównanie uczone │ +│
Audio waveform + ↓ +[CNN Feature Encoder] + ↓ +[Transformer Encoder] × N + ↓ +[CTC / Attention Decoder] + ↓ +Tekst egzamin pyt20 EASAR detail +Wyjaśnij: Porównanie HMM vs DNN | Aspekt | GMM-HMM | DNN-HMM | End-to-End | +|--------|---------|---------|------------| +| Model akustyczny | GMM | DNN | DNN | +| Model czasowy | HMM | HMM | CTC/Attention | +| Wyrównanie | Viterbi | Viterbi | Uczone/CTC | +| Trening | EM (Baum-Welch) | Backprop | Backprop | +| **Interpr egzamin pyt20 EASAR detail +Wyjaśnij: Ewolucja wydajności ``` +WER na Switchboard (telefon):
Rok Model WER +2010 GMM-HMM ~18% +2012 DNN-HMM ~12% +2015 LSTM-HMM ~8% +2017 LAS (Seq2Seq) ~6% +2020 Conformer ~4% +2023 Whisper Large ~3% + Poziom ludzki ~4% +``` egzamin pyt20 EASAR detail +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? • Percepcji: poprzez sensory
• Działania: poprzez efektory
• Interakcji: ze środowiskiem egzamin pyt21 ERPM main +Wyjaśnij: Agent upostaciowiony (Embodied Agent) • Percepcji: poprzez sensory
• Działania: poprzez efektory
• Interakcji: ze środowiskiem egzamin pyt21 ERPM detail +Wyjaśnij: Formalny model agenta Formalnie: + see: E → P (funkcja percepcji) + action: P* → A (funkcja decyzyjna) + next: E × A → E (funkcja przejścia środowiska) +```
#### Specyfikacja w logice temporalnej egzamin pyt21 ERPM detail +Wyjaśnij: Zastosowanie w ROS (Robot Operating System) [Selector ?] + / | \ + / | \ + [Seq→] [Seq→] [Idle] + / \ | + / \ | +[Check] [Pick] [Navigate]
Węzły: +- Sequence (→): wykonaj wszystkie po kolei +- Selector (?): wykonaj pierwszy sukces +- Action: atomowa akcja +- Condition: sprawdzenie warunku +``` egzamin pyt21 ERPM detail +Wyjaśnij: Hybrydowa architektura 3T ``` +┌─────────────────────────────────────────────────────────────────┐ +│ THREE-TIER (3T) Architecture │ +│ │ +│ ┌─────────────────────────────────────────────────────────┐ │ +│ │ PLANNER (deliberati egzamin pyt21 ERPM detail +Wyjaśnij: Korzyści podejścia agentowego | Korzyść | Opis | +|---------|------| +| Modularność | Rozdzielenie percepcji, decyzji, akcji | +| Abstrakcja | Ukrycie szczegółów sprzętu | +| Autonomia | Robot sam decyduje o działaniach | +| Reużywalność | Zachowania przenośne między platformami | +| Weryfikowalność | Formalna spec egzamin pyt21 ERPM detail +Wyjaśnij: Klasyfikacja języków programowania robotów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ JĘZYKI PROGRAMOWANIA ROBOTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ POZIOM ABSTRAKCJI: │ +│ egzamin pyt22 ERPM detail +Wyjaśnij: Klasyfikacja wg metody programowania | Metoda | Opis | Przykłady | +|--------|------|-----------| +| Online (Teach-in) | Programowanie przez demonstrację | Pendant, prowadzenie ręczne | +| Offline | Programowanie bez robota | Symulacja, CAD/CAM | +| Tekstowe | Kod źródłowy | RAPID, KRL, Karel | +| Graficzne | Bloki, flowchar egzamin pyt22 ERPM detail +Wyjaśnij: Języki producentów robotów przemysłowych ! MoveJ = ruch w przestrzeni złączy (Joint) +! MoveL = ruch liniowy (Linear) +! v500 = prędkość 500 mm/s +! fine/z50 = dokładność (fine = dokładnie) +```
; PTP = Point-to-Point (ruch złączowy) +; LIN = ruch liniowy +; CIRC = ruch kołowy +``` egzamin pyt22 ERPM detail +Wyjaśnij: Porównanie języków producentów | Cecha | RAPID (ABB) | KRL (KUKA) | Karel (FANUC) | +|-------|-------------|------------|---------------| +| Paradygmat | Proceduralny | Proceduralny | Proceduralny | +| Typy ruchów | MoveJ, MoveL, MoveC | PTP, LIN, CIRC | MOVE TO | +| Zmienne | VAR, PERS, CONST | DECL | VAR | +| I/O | S egzamin pyt22 ERPM detail +Wyjaśnij: Języki uniwersalne i frameworki #### ROS (Robot Operating System)
rospy.init_node('robot_controller') +pub = rospy.Publisher('/cmd_vel', Twist, queue_size=10) egzamin pyt22 ERPM detail +Wyjaśnij: Języki graficzne | Narzędzie | Producent | Opis | +|-----------|-----------|------| +| RobotStudio | ABB | RAPID + symulacja 3D | +| KUKA.Sim | KUKA | KRL + symulacja | +| ROBOGUIDE | FANUC | Karel + symulacja | +| Blockly | Google | Programowanie wizualne (edukacja) | +| Scratch for Robots | MIT | Edu egzamin pyt22 ERPM detail +Wyjaśnij: Klasyfikacja wg poziomu abstrakcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Task-Level: │ +│ "Złóż produkt X z części A, B, C" │ +│ → Planowanie automatyczne, AI │ +│ Przykłady: STRIPS, PDD egzamin pyt22 ERPM detail +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. ### 1. Problem czasu w systemach rozproszonych
Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji. egzamin pyt23 ERSMS main +Wyjaśnij: Problem czasu w systemach rozproszonych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Brak globalnego zegara: │ +│ │ +│ Node A: ──●────────●────────●──→ czas lokalny A │ +│ e1 e2
Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji. egzamin pyt23 ERSMS detail +Wyjaśnij: Zegar Lamporta (Scalar Clock) 1. Przed każdym zdarzeniem lokalnym: + C_i := C_i + 1
2. Wysyłając wiadomość m: + C_i := C_i + 1 + Dołącz timestamp(m) = C_i egzamin pyt23 ERSMS detail +Wyjaśnij: Zegary wektorowe (Vector Clocks) 1. Przed każdym zdarzeniem lokalnym: + V_i[i] := V_i[i] + 1
2. Wysyłając wiadomość m: + V_i[i] := V_i[i] + 1 + Dołącz timestamp(m) = V_i egzamin pyt23 ERSMS detail +Wyjaśnij: Porównanie | Cecha | Lamport | Vector Clock | +|-------|---------|--------------| +| Rozmiar | O(1) | O(N) | +| a → b ⟹ C(a) < C(b) | ✅ | ✅ | +| C(a) < C(b) ⟹ a → b | ❌ | ✅ | +| Wykrycie współbieżności | ❌ | ✅ | +| Zastosowanie | Uporządkowanie | Wykrywanie konfliktów | egzamin pyt23 ERSMS detail +Wyjaśnij: Warianty i rozszerzenia | Wariant | Opis | +|---------|------| +| Interval Tree Clocks | Dynamiczna liczba procesów | +| Bloom Clocks | Probabilistyczne, kompaktowe | +| Hybrid Logical Clocks | Lamport + czas fizyczny | +| Matrix Clocks | Wiedza o wiedzy innych | egzamin pyt23 ERSMS detail +Wyjaśnij: Problem spójności w systemach rozproszonych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Repliki danych: │ +│ │ +│ Client A Client B │ +│ │ write(x=1) egzamin pyt24 ERSMS detail +Wyjaśnij: Spektrum modeli spójności ``` +Silne ←─────────────────────────────────────────→ Słabe + +Linearizability Eventual + │ Consistency + ↓ ↑ +Sequential egzamin pyt24 ERSMS detail +Wyjaśnij: Silne modele spójności #### Linearizability (Linearyzacja)
Timeline: +Client A: ─────[write(x=1)]─────────────────────→ +Client B: ───────────[read(x)]──────────────────→ + ↓ + Musi zwrócić 1! egzamin pyt24 ERSMS detail +Wyjaśnij: Słabe modele spójności Timeline: +write(x=1) @ Replica A + ↓ (propagacja) + ↓ + ↓ ... czas ... + ↓ +read(x)=1 @ Replica B (eventually)
Gwarancje: +✅ Dostępność (AP w CAP) +✅ Niska latencja +❌ Stare dane przez jakiś czas +❌ Możliwe konflikty +``` egzamin pyt24 ERSMS detail +Wyjaśnij: CAP Theorem ``` +┌─────────────────────────────────────────────────────────────────┐ +│ CAP Theorem │ +│ │ +│ Consistency (C) │ +│ egzamin pyt24 ERSMS detail +Wyjaśnij: Porównanie modeli | Model | Gwarancje | Wydajność | Przykłady | +|-------|-----------|-----------|-----------| +| Linearizable | Najsilniejsze | Niska | Spanner, CockroachDB | +| Sequential | Silne | Średnia | Zookeeper | +| Causal | Przyczynowe | Dobra | COPS, MongoDB | +| Session | Per-sesja | Dobra | Dy egzamin pyt24 ERSMS detail +Wyjaśnij: Strategie rozwiązywania konfliktów #### Last-Writer-Wins (LWW) +``` +Konflikt: write(x=1) || write(x=2) +Rozwiązanie: Większy timestamp wygrywa +Problem: Utrata danych! +```
#### Multi-Value (Siblings) +``` +Konflikt: write(x=1) || write(x=2) +Rozwiązanie: Przechowaj oba: x=[1,2] +Klient rozwiązuje przy odczycie (Riak) +``` egzamin pyt24 ERSMS detail +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. ### 1. Definicja MIP (Mixed Integer Programming)
min c^T x +s.t. Ax ≤ b + x_i ∈ Z dla i ∈ I (zmienne całkowite) + x_j ∈ R dla j ∈ J (zmienne ciągłe) + x ≥ 0 egzamin pyt25 MOD main +Wyjaśnij: Definicja MIP (Mixed Integer Programming) ``` +Programowanie całkowitoliczbowe:
min c^T x +s.t. Ax ≤ b + x_i ∈ Z dla i ∈ I (zmienne całkowite) + x_j ∈ R dla j ∈ J (zmienne ciągłe) + x ≥ 0 egzamin pyt25 MOD detail +Wyjaśnij: Metody rozwiązywania | Metoda | Typ | Gwarancja optimum | +|--------|-----|-------------------| +| Branch and Bound | Dokładna | ✅ | +| Branch and Cut | Dokładna | ✅ | +| Branch and Price | Dokładna | ✅ | +| Cutting Planes | Dokładna | ✅ | +| Heurystyki | Przybliżona | ❌ | +| Metaheurystyki | Przybliżon egzamin pyt25 MOD detail +Wyjaśnij: Branch and Bound (B&B) - metoda dokładna LP relaxation + x* = 2.7 + /\ + / \ + x ≤ 2 x ≥ 3 + / \ + LP: z=10 LP: z=8 + / \ + (dalej) (przycinaj jeśli + najlepsze ≥ 8) +```
#### Przykład: Max 3x + 2y, x + y ≤ 4, x,y ∈ Z+ egzamin pyt25 MOD detail +Wyjaśnij: Czynniki wpływające na efektywność B&B | Czynnik | Wpływ | Strategie | +|---------|-------|-----------| +| Jakość relaksacji | Lepsza → mniej węzłów | Silne formulacje, cutting planes | +| Wybór zmiennej do branch | Balans drzewa | Most fractional, strong branching | +| Wybór węzła | DFS vs BFS | Best-first (best bound) | +| **Prz
#### Strategie wyboru zmiennej (branching) egzamin pyt25 MOD detail +Wyjaśnij: Ulepszenia: Branch and Cut ``` +Branch and Bound + Cutting Planes:
W każdym węźle: +1. Rozwiąż LP relaksację +2. Jeśli rozwiązanie niecałkowite: + - Generuj cięcia (Gomory, Cover, Clique...) + - Dodaj cięcia do LP + - Powtórz do limitu +3. Jeśli nadal niecałkowite → branch egzamin pyt25 MOD detail +Scharakteryzować informatyczne narzędzia optymalizacji dyskretnej. Jakie są warunki i wymagania, jakie możliwości oraz trudności wiążą się ze stosowaniem gotowych narzędzi. ### Porównanie wydajności (benchmark)
CPLEX ████████████████████████████ 100% +Gurobi ███████████████████████████ 98% +SCIP ████████████████ 60% +CBC ████████████ 45% +GLPK ████████ 30% +``` egzamin pyt26 MOD main +Wyjaśnij: Kategorie narzędzi ``` +┌─────────────────────────────────────────────────────────────────┐ +│ NARZĘDZIA OPTYMALIZACJI DYSKRETNEJ │ +├─────────────────────────────────────────────────────────────────┤ +│ SOLVERY MIP │ SOLVERY CP │ METAHEURYSTYKI │ +│ (Mixed Integer │ egzamin pyt26 MOD detail +Wyjaśnij: Solvery MIP | Solver | Licencja | Cechy | +|--------|----------|-------| +| CPLEX | Komercyjny (IBM) | Najszybszy dla dużych MIP | +| Gurobi | Komercyjny (academic free) | Bardzo szybki, dobry API | +| SCIP | Open source (ZIB) | Framework extensible | +| CBC | Open source (COIN-OR) | Dobry darmowy so egzamin pyt26 MOD detail +Wyjaśnij: Porównanie wydajności (benchmark) ``` +Typowe czasy dla problemów MIPLIB (średnie):
CPLEX ████████████████████████████ 100% +Gurobi ███████████████████████████ 98% +SCIP ████████████████ 60% +CBC ████████████ 45% +GLPK ████████ 30% +``` egzamin pyt26 MOD detail +Wyjaśnij: Solvery Constraint Programming | Solver | Język | Cechy | +|--------|-------|-------| +| CP-SAT | Python/C++ | Google, bardzo szybki | +| Gecode | C++ | Akademicki, elastyczny | +| Chuffed | MiniZinc | Lazy clause generation | +| OR-Tools | Multi | Google, CP + routing + MIP | egzamin pyt26 MOD detail +Wyjaśnij: Kiedy CP vs MIP? | Aspekt | MIP | CP | +|--------|-----|-----| +| Ograniczenia globalne | Słabo | Świetnie (alldiff, cumulative) | +| Relaksacja | LP (silna) | Słabsza | +| Scheduling | Średnio | Świetnie | +| Kombinatoryczne | Dobrze | Bardzo dobrze | egzamin pyt26 MOD detail +Wyjaśnij: Języki modelowania #### AMPL +```ampl +set PRODUCTS; +param profit{PRODUCTS}; +param capacity;
var produce{PRODUCTS} >= 0 integer; egzamin pyt26 MOD detail +Wyjaśnij: Warunki i wymagania | Wymaganie | Opis | +|-----------|------| +| Licencja | Komercyjne (CPLEX, Gurobi) vs Open source | +| API/Język | Python, C++, Java, Julia | +| Format modelu | MPS, LP, AMPL, własny | +| Pamięć | Duże modele = duże wymagania RAM | +| Wielowątkowość | Parallel B&B, concurrent LP | egzamin pyt26 MOD detail +Wyjaśnij: Typowe wymagania sprzętowe ``` +Mały problem (< 1000 zmiennych): + - RAM: 4 GB + - CPU: dowolny + - Czas: sekundy
Średni problem (1000-100k zmiennych): + - RAM: 16-32 GB + - CPU: multi-core + - Czas: minuty-godziny egzamin pyt26 MOD detail +Wyjaśnij: Możliwości | Możliwość | Opis | +|-----------|------| +| Gwarancja optimum | Metody dokładne (B&B, B&C) | +| Gap tracking | Śledzenie jakości rozwiązania | +| Callbacks | Własne cięcia, heurystyki, lazy constraints | +| Warm start | Start od znanego rozwiązania | +| Tuning | Automatyczne dostraja egzamin pyt26 MOD detail +Wyjaśnij: Trudności | Trudność | Opis | Rozwiązanie | +|----------|------|-------------| +| Czas obliczeń | NP-trudność | Heurystyki, time limit | +| Słaba formulacja | Duży integrality gap | Silniejsze modele, cięcia | +| Symetria | Wiele równoważnych rozw. | Symmetry breaking | +| Numeryka | Błędy zaokrągl egzamin pyt26 MOD detail +Wyjaśnij: Diagnostyka problemów Diagnoza: +1. solver.computeIIS() # znajdź konflikt +2. Sprawdź constraints +3. Poluzuj ograniczenia
Diagnoza: +1. Gap się nie zmniejsza → słaba formulacja +2. Dużo węzłów B&B → symetria +3. LP wolne → presolve, scaling +``` egzamin pyt26 MOD detail +Wyjaśnij: Best practices ``` +┌─────────────────────────────────────────────────────────────────┐ +│ 1. FORMULACJA │ +│ - Unikaj big-M (słaba relaksacja) │ +│ - Używaj wskaźnikowych (indicator constraints) │ +│ - Tight bounds na zmi egzamin pyt26 MOD detail +Wyjaśnij: Model danych jako fundament systemu ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ARCHITEKTURA SYSTEMU │ +│ │ +│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ +│ │ UI │ │ egzamin pyt27 MODA detail +Wyjaśnij: Konsekwencje złego modelu danych | Problem | Konsekwencje | +|---------|--------------| +| Redundancja | Anomalie (insert, update, delete), niespójność | +| Brak normalizacji | Duplikacja, trudna aktualizacja | +| Nadmierna normalizacja | Wolne zapytania (wiele JOIN) | +| Złe typy danych | Błędy konwersji, utrata precyzj egzamin pyt27 MODA detail +Wyjaśnij: Wpływ na różne aspekty projektu Dobry model: +SELECT * FROM orders o +JOIN customers c ON o.customer_id = c.id -- integer FK +JOIN products p ON o.product_id = p.id +WHERE c.city_id = 1; -- indexed lookup +→ Index scans, szybkie JOIN na integer PK/FK +```
Dobry model: +- Dedykowane tabele i kolumny z opisowymi nazwami +- ENUM lub tabela słownikowa dla statusów +- Komentarze w schemacie, dokumentacja ERD +``` egzamin pyt27 MODA detail +Wyjaśnij: Cechy dobrego modelu danych | Cecha | Opis | +|-------|------| +| Poprawność | Odzwierciedla dziedzinę biznesową | +| Kompletność | Wszystkie wymagane dane | +| Spójność | Brak sprzeczności, integralność | +| Minimalizm | Brak zbędnej redundancji | +| Elastyczność | Możliwość rozszerzenia | +| Wydajność | Odpo egzamin pyt27 MODA detail +Wyjaśnij: Wpływ na jakość danych (GIGO) ┌──────────────────┐ +│ Złe dane wejść. │ → Zły model → Złe decyzje biznesowe +│ (brak walidacji) │ +└──────────────────┘
Dobry model wymusza jakość: +- NOT NULL gdzie wymagane +- CHECK constraints (age > 0) +- FOREIGN KEY (referential integrity) +- UNIQUE (brak duplikatów) +- Trigger dla złożonej walidacji +``` egzamin pyt27 MODA detail +Wyjaśnij: Model danych a architektura aplikacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Model danych wpływa na: │ +│ │ +│ • ORM mapping (Entity classes) │ +│ • API endpoints (REST r egzamin pyt27 MODA detail +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. ### 2. Model konceptualny (Conceptual Data Model)
#### Cel +- Zrozumienie dziedziny biznesowej +- Komunikacja z interesariuszami (nietechnicznymi) +- Identyfikacja głównych encji i relacji egzamin pyt28 MODA main +Wyjaśnij: Przegląd faz ewolucji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ FAZY EWOLUCJI MODELU DANYCH │ +│ │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ KONCEPTUALNY │ → │ egzamin pyt28 MODA detail +Wyjaśnij: Model konceptualny (Conceptual Data Model) #### Cel +- Zrozumienie dziedziny biznesowej +- Komunikacja z interesariuszami (nietechnicznymi) +- Identyfikacja głównych encji i relacji
┌──────────┐ ┌──────────┐ + │ KLIENT │ składa │ZAMÓWIENIE│ + │ │ 1────M │ │ + └──────────┘ └──────────┘ + │ + │ zawiera + │ M + │ egzamin pyt28 MODA detail +Wyjaśnij: Model logiczny (Logical Data Model) #### Cel +- Szczegółowa struktura danych +- Normalizacja +- Definicja atrybutów i kluczy +- Niezależność od DBMS
┌────────────────────────┐ ┌────────────────────────┐ +│ KLIENT │ │ ZAMÓWIENIE │ +├────────────────────────┤ ├────────────────────────┤ +│ PK klient_id │───┐ │ PK zamowienie_id │ +│ imie │ │ │ FK klient_id │─ egzamin pyt28 MODA detail +Wyjaśnij: Model fizyczny (Physical Data Model) #### Cel +- Implementacja w konkretnym DBMS +- Optymalizacja wydajności +- Definicja indeksów, partycji, storage
CREATE INDEX idx_klient_email ON klient(email); +CREATE INDEX idx_klient_nazwisko ON klient(nazwisko); egzamin pyt28 MODA detail +Wyjaśnij: Porównanie faz | Aspekt | Konceptualny | Logiczny | Fizyczny | +|--------|--------------|----------|----------| +| Odbiorcy | Biznes | Analitycy, projektanci | DBA, developerzy | +| Abstrakcja | Wysoka | Średnia | Niska | +| DBMS | Niezależny | Niezależny | Specyficzny | +| Typy danych | Brak | Logiczne egzamin pyt28 MODA detail +Wyjaśnij: Transformacje między fazami ``` +┌──────────────────────────────────────────────────────────────────┐ +│ Konceptualny → Logiczny: │ +│ • Encje → Tabele │ +│ • Atrybuty → Kolumny │ +│ • Relacje M:N → Ta egzamin pyt28 MODA detail +Wyjaśnij: Ewolucja w czasie (produkcja) ``` +Wersja 1.0 → 1.1 → 2.0 → ...
Narzędzia migracji: +- Flyway +- Liquibase +- Django migrations +- Alembic (SQLAlchemy) egzamin pyt28 MODA detail +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$
Gdzie: +- $S(n)$ = przyśpieszenie (speedup) +- $p$ = część programu, która może być zrównoleglona (0 ≤ p ≤ 1) +- $n$ = liczba procesorów/rdzeni +- $(1-p)$ = część sekwencyjna egzamin pyt29 PORR main +Wyjaśnij: Prawo Amdahla $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$
Gdzie: +- $S(n)$ = przyśpieszenie (speedup) +- $p$ = część programu, która może być zrównoleglona (0 ≤ p ≤ 1) +- $n$ = liczba procesorów/rdzeni +- $(1-p)$ = część sekwencyjna egzamin pyt29 PORR detail +Wyjaśnij: Wizualizacja ograniczenia ``` +Speedup + ↑ +20 ┤ ........... p=99% + │ ...... + │ ...... +15 ┤ ..... + │ ..... + │ .... ______ p=95% +10 ┤ .... _____/
Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk. egzamin pyt29 PORR detail +Wyjaśnij: Czynniki zmniejszające rzeczywiste przyśpieszenie ``` +S_real < S_Amdahl ze względu na:
┌─────────────────────────────────────────────────────────────────┐ +│ 1. OVERHEAD SYNCHRONIZACJI │ +│ - Mutex, semaphore contention │ +│ - Barrier wait time │ +│ - Lock granularity (coar egzamin pyt29 PORR detail +Wyjaśnij: Efektywność równoległa $$E(n) = \frac{S(n)}{n} = \frac{1}{n \cdot (1-p) + p}$$
Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR detail +Wyjaśnij: Rozszerzone prawo Amdahla (z overhead) $$S(n) = \frac{1}{(1-p) + \frac{p}{n} + O(n)}$$
Gdzie $O(n)$ = overhead zależny od n (komunikacja, synchronizacja). egzamin pyt29 PORR detail +Wyjaśnij: Struktura modelu matematycznego ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MODEL OPTYMALIZACYJNY │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ min/max f(x) egzamin pyt30 MOM detail +Wyjaśnij: Techniki modelowania McCormick envelopes: +w ≥ x·LB_y + y·LB_x - LB_x·LB_y +w ≥ x·UB_y + y·UB_x - UB_x·UB_y +w ≤ x·LB_y + y·UB_x - LB_y·UB_x +w ≤ x·UB_y + y·LB_x - UB_y·LB_x
Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM detail +Wyjaśnij: Wielokryterialne podejmowanie decyzji ``` +min f₁(x), f₂(x), ..., f_k(x) ← konfliktujące cele
1. WEIGHTED SUM: + min Σ w_i · f_i(x) + Problem: nie znajduje wszystkich Pareto-optymalnych egzamin pyt30 MOM detail +Wyjaśnij: Analiza wrażliwości ``` +┌─────────────────────────────────────────────────────────────────┐ +│ Co się zmieni gdy zmienią się dane wejściowe? │ +├─────────────────────────────────────────────────────────────────┤ +│ Shadow price (dual variable): │ +│ - Ile warta jest jedn egzamin pyt30 MOM detail +Wyjaśnij: Częste błędy | Błąd | Konsekwencja | Rozwiązanie | +|------|--------------|-------------| +| Brak bounds | Unbounded lub słaba relaxation | Zawsze definiuj LB, UB | +| Za duże M | Numerical issues, wolne | Tight big-M | +| Redundantne ograniczenia | Wolniejsze, confusion | Minimalizuj | +| Zła skala | egzamin pyt30 MOM detail +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. ### 1. Klasyfikacja problemów optymalizacyjnych
$$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$ egzamin pyt31 MOM main +Wyjaśnij: Klasyfikacja problemów optymalizacyjnych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ KLASYFIKACJA PROBLEMÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ LINIOW egzamin pyt31 MOM detail +Wyjaśnij: Definicje kluczowe $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$
$$f \text{ wypukła} \Leftrightarrow f(\lambda x + (1-\lambda)y) \leq \lambda f(x) + (1-\lambda) f(y)$$ egzamin pyt31 MOM detail +Wyjaśnij: Testowanie wypukłości 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x
2. Kompozycja: + - Suma wypukłych → wypukła + - max(f, g) gdzie f, g wypukłe → wypukła + - f(Ax+b) gdzie f wypukła → wypukła egzamin pyt31 MOM detail +Wyjaśnij: Dualność ``` +Primal (P): Dual (D): +min f(x) max L(λ, μ) +s.t. g(x) ≤ 0 s.t. λ ≥ 0 + h(x) = 0
Lagrangian: L(x,λ,μ) = f(x) + λᵀg(x) + μᵀh(x) egzamin pyt31 MOM detail +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? #### Synchroniczna vs Asynchroniczna
KOMUNIKACJA ASYNCHRONICZNA: +┌─────────────────────────────────────────────────────────────────┐ +│ Nadawca nie czeka na odbiorcę │ +│ │ +│ Proces A Proces B │ egzamin pyt32 PORR main +Wyjaśnij: Definicje podstawowe #### Synchroniczna vs Asynchroniczna
KOMUNIKACJA ASYNCHRONICZNA: +┌─────────────────────────────────────────────────────────────────┐ +│ Nadawca nie czeka na odbiorcę │ +│ │ +│ Proces A Proces B │ egzamin pyt32 PORR detail +Wyjaśnij: Kombinacje w MPI | Funkcja MPI | Blokująca? | Synchroniczna? | Opis | +|-------------|------------|----------------|------| +| `MPI_Send` | Blokująca | Zależne od impl. | Standard send | +| `MPI_Ssend` | Blokująca | Synchroniczna | Czeka na recv | +| `MPI_Bsend` | Blokująca | Asynchroniczna | Buforowana | +| `MPI_Rsend` egzamin pyt32 PORR detail +Wyjaśnij: Problem zakleszczenia (Deadlock) #### Scenariusz: Algorytm Jacobiego
// Proces 0: // Proces 1: +MPI_Send(to=1, data); MPI_Send(to=0, data); +MPI_Recv(from=1, data); MPI_Recv(from=0, data); egzamin pyt32 PORR detail +Wyjaśnij: Rozwiązania problemu zakleszczenia #### 4.1 Zmiana kolejności operacji
Przebieg: +┌──────────────────┬──────────────────┐ +│ PROCES 0 │ PROCES 1 │ +├──────────────────┼──────────────────┤ +│ Send(to=1) ──────│──→ Recv(from=0) │ +│ [zakończone] │ [zakończone] │ +│ Recv(from=1) ←───│─── Send(to=0) │ +│ [zakończone] │ [zakończone] │ +└───────── egzamin pyt32 PORR detail +Wyjaśnij: Porównanie rozwiązań | Rozwiązanie | Zalety | Wady | +|-------------|--------|------| +| Zmiana kolejności | Proste, brak overhead | Wymaga asymetrii kodu | +| Isend/Irecv | Elastyczne, overlap | Złożoność kodu | +| Sendrecv | Proste, bezpieczne | Mniej elastyczne | +| Bsend | Podobne do standardowego | Wymag egzamin pyt32 PORR detail +Wyjaśnij: Algorytm Jacobiego - pełny przykład ```c +// Iteracyjne rozwiązanie równania Laplace'a +// Grid podzielony między procesy
for (int iter = 0; iter < MAX_ITER; iter++) { + // Wymiana granic z sąsiadami + + // Bezpieczna wymiana z lewym sąsiadem + if (rank > 0) { + MPI_Sendrecv( + &u[1], 1, MPI_DOUBLE, rank-1, 0, // wyślij lewą granicę + &u[0], 1, MPI_DOUBLE, rank-1, 0, // odbi egzamin pyt32 PORR detail +Wyjaśnij: Wzorce komunikacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ RING (pierścień) - każdy z sąsiadami: │ +│ │ +│ ┌───→ P0 ───→ P1 ───→ P2 ───→ P3 ───┐ │ +│ └─────────────────── egzamin pyt32 PORR detail +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model. ### 1. Definicja modelu Pub/Sub
Subskrypcje: + home/living-room/# → wszystko z living-room + home/+/temperature → temperatura ze wszystkich pomieszczeń + home/# → wszystko z home +``` egzamin pyt33 PSD main +Wyjaśnij: Definicja modelu Pub/Sub ``` +┌─────────────────────────────────────────────────────────────────┐ +│ MODEL PUBLISH-SUBSCRIBE │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ PUBLISHERS egzamin pyt33 PSD detail +Wyjaśnij: Typy subskrypcji | Typ | Opis | Przykład | +|-----|------|----------| +| Topic-based | Subskrypcja na nazwany temat | `subscribe("orders")` | +| Content-based | Filtrowanie po zawartości | `price > 100 AND category = "electronics"` | +| Type-based | Na podstawie typu wiadomości | `subscribe(OrderEvent.class) egzamin pyt33 PSD detail +Wyjaśnij: Wildcardy (MQTT) ``` +Hierarchia tematów: + home/living-room/temperature + home/living-room/humidity + home/bedroom/temperature + home/kitchen/temperature
Subskrypcje: + home/living-room/# → wszystko z living-room + home/+/temperature → temperatura ze wszystkich pomieszczeń + home/# → wszystko z home +``` egzamin pyt33 PSD detail +Wyjaśnij: Gwarancje dostarczenia ``` +┌─────────────────────────────────────────────────────────────────┐ +│ QoS (Quality of Service) levels: │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ QoS 0: AT MOST ONCE (f egzamin pyt33 PSD detail +Wyjaśnij: Rozwiązania techniczne // Producer +producer.send(new ProducerRecord<>("orders", key, value));
// Consumer +consumer.subscribe(Arrays.asList("orders")); +while (true) { + ConsumerRecords records = consumer.poll(Duration.ofMillis(100)); + for (ConsumerRecord record : records) { + process(record); + } +} +``` egzamin pyt33 PSD detail +Wyjaśnij: Zalety i wady Pub/Sub ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ZALETY: │ +│ ✓ Luźne powiązanie (decoupling) │ +│ ✓ Skalowalność (dodawanie subskrybentów bez zmian publishera) │ +│ ✓ Asynchroniczność (brak egzamin pyt33 PSD detail +Wyjaśnij: Wzorce użycia ``` +1. EVENT SOURCING: + [Service] ─publish─→ [Kafka] ←─consume─ [Projections] + Wszystkie zmiany jako events, rebuild state z log
2. CQRS (Command Query Responsibility Segregation): + [Write Model] ─events─→ [Event Bus] ─→ [Read Model] + Oddzielne modele do zapisu i odczytu egzamin pyt33 PSD detail +Wyjaśnij: Charakterystyka danych strumieniowych ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DANE STRUMIENIOWE vs BATCH │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ BATCH: egzamin pyt34 PSD detail +Wyjaśnij: Platformy Stream Processing KStream source = builder.stream("input-topic");
KTable, Long> counts = source + .groupByKey() + .windowedBy(TimeWindows.of(Duration.ofMinutes(5))) + .count(); egzamin pyt34 PSD detail +Wyjaśnij: Porównanie platform | Cecha | Kafka Streams | Flink | Spark Streaming | +|-------|---------------|-------|-----------------| +| Model | True streaming | True streaming | Micro-batch | +| Deployment | Library | Cluster | Cluster | +| Latency | Niska | Bardzo niska | Średnia (~100ms) | +| State | RocksDB | Roc egzamin pyt34 PSD detail +Wyjaśnij: Algorytmy strumieniowe #### Approximate counting - HyperLogLog
HyperLogLog: +• O(1) space (kilka KB) +• ~2% error dla 12-bit registers +• Używa hash → trailing zeros egzamin pyt34 PSD detail +Wyjaśnij: Obsługa opóźnień i Out-of-Order ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WATERMARKS + LATE DATA │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Stream: ─●(t=1)──●( egzamin pyt34 PSD detail +Wyjaśnij: Exactly-Once Semantics ``` +┌─────────────────────────────────────────────────────────────────┐ +│ GWARANCJE PRZETWARZANIA: │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ AT-MOST-ONCE: egzamin pyt34 PSD detail +Wyjaśnij: Use Cases | Use Case | Technologia | Opis | +|----------|-------------|------| +| Fraud detection | Flink CEP | Pattern matching w czasie rzeczywistym | +| IoT analytics | Kafka Streams | Agregacja danych z sensorów | +| Real-time dashboards | Spark + Druid | Metryki biznesowe | +| Log analysis | E egzamin pyt34 PSD detail +Wyjaśnij: Definicja układów cyber-fizycznych (CPS) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ CYBER-PHYSICAL SYSTEM (CPS) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌────────────────── egzamin pyt35 SIU detail +Wyjaśnij: Współpraca agentów w sieci Protokół consensus: + ẋᵢ = Σⱼ∈Nᵢ aᵢⱼ(xⱼ - xᵢ)
gdzie: +- xᵢ = stan agenta i +- Nᵢ = sąsiedzi agenta i +- aᵢⱼ = waga połączenia egzamin pyt35 SIU detail +Wyjaśnij: Warunki zbieżności consensus ``` +Twierdzenie: Protokół consensus ẋ = -Lx zbiega do consensus ⟺ + Graf komunikacji jest (słabo) spójny
Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU detail +Wyjaśnij: Model uczenia ze wzmocnieniem ``` +┌─────────────────────────────────────────────────────────────────┐ +│ REINFORCEMENT LEARNING LOOP │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌─ egzamin pyt36 SIU detail +Wyjaśnij: Elementy składowe | Element | Symbol | Opis | +|---------|--------|------| +| State | s ∈ S | Obserwacja środowiska | +| Action | a ∈ A | Decyzja agenta | +| Reward | r ∈ ℝ | Sygnał zwrotny | +| Policy | π(a\|s) | Strategia wyboru akcji | +| Value function | V(s), Q(s,a) | Oczekiwana nagroda | +| **Disco egzamin pyt36 SIU detail +Wyjaśnij: Markov Decision Process (MDP) S: Zbiór stanów +A: Zbiór akcji +P: P(s'|s,a) - prawdopodobieństwa przejść +R: R(s,a,s') - funkcja nagrody +γ: Współczynnik dyskontowania
Właściwość Markowa: + P(sₜ₊₁|s₀,a₀,...,sₜ,aₜ) = P(sₜ₊₁|sₜ,aₜ) + + Przyszłość zależy tylko od obecnego stanu! +``` egzamin pyt36 SIU detail +Wyjaśnij: Funkcje wartości $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$
#### Action Value Function Q(s,a) egzamin pyt36 SIU detail +Wyjaśnij: Algorytmy ┌─────────────────────────────────────────────────────────────────┐ +│ SARSA (on-policy) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Q(s,a) ← Q(s,a) + α[r + γ Q egzamin pyt36 SIU detail +Wyjaśnij: Klasyfikacja algorytmów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ │ +│ ┌── Model-based (zna/uczy się P, R) │ +│ RL Methods ─┤ │ +│ └── Model egzamin pyt36 SIU detail +Wyjaśnij: Exploration vs Exploitation | Strategia | Opis | +|-----------|------| +| ε-greedy | Z prawdop. ε losowa akcja | +| Softmax/Boltzmann | P(a) ∝ exp(Q(s,a)/τ) | +| UCB | a = argmax[Q(s,a) + c√(ln N / n(a))] | +| Thompson Sampling | Próbkowanie z posterior | +| Curiosity-driven | Bonus za nowość | egzamin pyt36 SIU detail +Wyjaśnij: Własności i wyzwania ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WŁASNOŚCI: │ +│ ✓ Uczenie przez interakcję (nie supervised) │ +│ ✓ Delayed rewards (kredyt za sekwencję akcji) │ +│ ✓ Generalizacja (do nowyc egzamin pyt36 SIU detail +Wyjaśnij: Właściwości rzeczywistych sieci ``` +┌─────────────────────────────────────────────────────────────────┐ +│ TYPOWE CECHY SIECI RZECZYWISTYCH │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. SMALL-WORLD EFFECT: egzamin pyt37 TASS detail +Wyjaśnij: Model Erdős-Rényi (Random Graph) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ G(n, p) - Graf losowy │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Porównanie z rzeczywistością | Cecha | ER Model | Rzeczywiste sieci | +|-------|----------|-------------------| +| Clustering | C = p (niski) | C >> p (wysoki) ❌ | +| Średnia ścieżka | L ~ log(n) ✓ | L ~ log(n) ✓ | +| Rozkład stopni | Poisson | Power-law ❌ | +| Huby | Brak | Istnieją ❌ | egzamin pyt37 TASS detail +Wyjaśnij: Model Watts-Strogatz (Small-World) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ SMALL-WORLD MODEL │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Właściwości ``` +Dla małych p (np. p = 0.01):
L(p) C(p) + ↑ ↑ + │● │●●●●●●●●●●●●●●●●● + │ ● │ ● + │ ●● │ ●● + │ ●●●●│ ●●●●● + └────────→ p └────────────────→ p + +L spada szybko przy małych p (shortcuts) +C pozostaje wysoki do większych p +``` egzamin pyt37 TASS detail +Wyjaśnij: Model Barabási-Albert (Scale-Free) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PREFERENTIAL ATTACHMENT MODEL │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Konstrukcja: egzamin pyt37 TASS detail +Wyjaśnij: Porównanie zbiorcze ``` +┌──────────────┬───────────────┬───────────────┬───────────────┐ +│ Właściwość │ Erdős-Rényi │ Watts-Strogatz│ Barabási-Albert│ +├──────────────┼───────────────┼───────────────┼───────────────┤ +│ Clustering │ Niski (C=p) │ Wysoki │ Niski │ +│ Śr. ścieżka │ log(n) │ lo
Rzeczywiste sieci (WWW, social, biological): +• Wysoki clustering → WS lepszy +• Power-law → BA lepszy +• Short paths → wszystkie OK egzamin pyt37 TASS detail +Wyjaśnij: Modele rozszerzone ``` +┌─────────────────────────────────────────────────────────────────┐ +│ HOLME-KIM MODEL (BA + clustering): │ +│ Po preferential attachment → dodaj trójkąt z prawdop. p │ +│ Łączy power-law z wysokim clustering │ +├────────────────────────── egzamin pyt37 TASS detail +Wyjaśnij: Grafy dwudzielne (Bipartite Graphs) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ GRAF DWUDZIELNY │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Zbiór U (np. dokume egzamin pyt38 TASS detail +Wyjaśnij: Projekcja grafu dwudzielnego ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROJEKCJA = przekształcenie grafu dwudzielnego na jednomodowy │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Graf dwudzielny: egzamin pyt38 TASS detail +Wyjaśnij: Metody projekcji #### 3.1 Projekcja binarna (Simple/Unweighted)
P = B · Bᵀ (dla projekcji na U) +P = Bᵀ · B (dla projekcji na V) egzamin pyt38 TASS detail +Wyjaśnij: Zastosowanie w grupowaniu dokumentów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PIPELINE GRUPOWANIA DOKUMENTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. PREPROCESSING
Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS detail +Wyjaśnij: Algorytmy grupowania na projekcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ LOUVAIN (Community Detection): │ +│ • Optymalizuje modularność Q │ +│ • Iteracyjne przenoszenie węzłów między grupami │ +│ • O(n log n) - szybki egzamin pyt38 TASS detail +Wyjaśnij: Problemy i rozwiązania | Problem | Opis | Rozwiązanie | +|---------|------|-------------| +| Gęstość | Projekcja tworzy gęste grafy | Threshold na wagi | +| Huby | Popularne słowa łączą wszystko | TF-IDF, filtering | +| Skalowalność | O(n²) krawędzi | Sparse representation, LSH | +| Utrata info | Projekcja trac egzamin pyt38 TASS detail +Wyjaśnij: Definicja problemu segmentacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ SEGMENTACJA OBRAZU │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Obraz wejściowy: egzamin pyt39 TWM detail +Wyjaśnij: Metody klasyczne #### 2.1 Thresholding (progowanie)
Otsu (automatyczny próg): + - Maksymalizuje wariancję między klasami + - σ²_between = w₀w₁(μ₀ - μ₁)² egzamin pyt39 TWM detail +Wyjaśnij: Porównanie metod klasycznych | Metoda | Zalety | Wady | +|--------|--------|------| +| Thresholding | Szybki, prosty | Tylko 2 klasy, wrażliwy na oświetlenie | +| Region Growing | Intuicyjny | Wymaga seedów, over-segmentation | +| Watershed | Dobre krawędzie | Over-segmentation | +| Mean Shift | Brak k | Wolny, param egzamin pyt39 TWM detail +Wyjaśnij: Porównanie architektur DL | Architektura | mIoU (ADE20K) | Parametry | Cechy | +|--------------|---------------|-----------|-------| +| FCN | ~30% | ~135M | Pierwsze DL dla segmentacji | +| U-Net | - | ~31M | Medical, skip connections | +| DeepLabv3+ | ~45% | ~60M | ASPP, dilated conv | +| SegFormer-B5 | ~51% | ~8 egzamin pyt39 TWM detail +Wyjaśnij: Loss functions ``` +Cross-Entropy Loss: + L = -Σᵢ Σc yᵢc log(pᵢc) + + Problem: class imbalance (dużo tła, mało obiektów)
Dice Loss: + L = 1 - 2|X ∩ Y| / (|X| + |Y|) + + Bezpośrednio optymalizuje IoU-like metric egzamin pyt39 TWM detail +Wyjaśnij: Metryki | Metryka | Formuła | Opis | +|---------|---------|------| +| Pixel Accuracy | TP / (TP+FP+FN+TN) | % poprawnych pikseli | +| IoU (Jaccard) | TP / (TP+FP+FN) | Intersection over Union | +| mIoU | mean IoU per class | Standard dla segmentacji | +| Dice | 2TP / (2TP+FP+FN) | F1 dla segmenta egzamin pyt39 TWM detail +Wyjaśnij: Definicja problemu detekcji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DETEKCJA OBIEKTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Obraz wejściowy: egzamin pyt40 TWM detail +Wyjaśnij: Metody Deep Learning #### 3.1 Two-Stage Detectors (R-CNN family)
┌─────────────────────────────────────────────────────────────────┐ +│ Fast R-CNN (2015) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Image → CNN → Feature map egzamin pyt40 TWM detail +Wyjaśnij: Konstrukcja detektora z klasyfikatora ``` +┌─────────────────────────────────────────────────────────────────┐ +│ JAK ZROBIĆ DETEKTOR MAJĄC KLASYFIKATOR? │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Metoda 1: SLIDING WINDO egzamin pyt40 TWM detail +Wyjaśnij: Non-Maximum Suppression (NMS) ``` +Problem: Wiele overlapping detections
┌─────────┐ + │ ┌──────┼──┐ + │ │ 🚗 │ │ ← 3 nakładające się bbox + │ │ │ │ + └──┼──────┘ │ + └─────────┘ egzamin pyt40 TWM detail +Wyjaśnij: Decyzje w warunkach ryzyka ``` +┌─────────────────────────────────────────────────────────────────┐ +│ WARUNKI PODEJMOWANIA DECYZJI │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ PEWNOŚĆ: Znamy do egzamin pyt41 WDWR detail +Wyjaśnij: Metody interaktywne - przegląd ``` +┌─────────────────────────────────────────────────────────────────┐ +│ INTERAKTYWNE = Dialog z decydentem │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌──────────────┐ egzamin pyt41 WDWR detail +Wyjaśnij: Metoda loterii (Lottery Method) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ELICYTACJA FUNKCJI UŻYTECZNOŚCI │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Cel: Wyznaczyć U(x) dla egzamin pyt41 WDWR detail +Wyjaśnij: Metoda pewnego ekwiwalentu (Certainty Equivalent) ``` +CE (Certainty Equivalent) = pewna kwota równoważna loterii
Dla loterii L = (p₁: x₁, p₂: x₂, ...): + CE(L) taki że U(CE) = E[U(L)] = Σ pᵢ U(xᵢ) egzamin pyt41 WDWR detail +Wyjaśnij: Metoda AHP (Analytic Hierarchy Process) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ AHP - Hierarchiczna struktura problemu (Saaty) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ ┌─── egzamin pyt41 WDWR detail +Wyjaśnij: Metoda PROMETHEE ``` +┌─────────────────────────────────────────────────────────────────┐ +│ PROMETHEE - Preference Ranking Organization Method │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. Dla każdego kryteriu egzamin pyt41 WDWR detail +Wyjaśnij: Metoda ELECTRE ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ELECTRE - ELimination Et Choix Traduisant la REalité │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Outranking: "a jest co n egzamin pyt41 WDWR detail +Wyjaśnij: Idea dominacji stochastycznej ``` +┌─────────────────────────────────────────────────────────────────┐ +│ DOMINACJA STOCHASTYCZNA (Stochastic Dominance) │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Cel: Porównać rozkłady egzamin pyt42 WDWR detail +Wyjaśnij: Dominacja stochastyczna pierwszego rzędu (FSD) $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$
gdzie $F(x) = P(X \leq x)$ to dystrybuanta (CDF) egzamin pyt42 WDWR detail +Wyjaśnij: Dominacja stochastyczna drugiego rzędu (SSD) $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$
$$E[U(A)] \geq E[U(B)] \quad \forall U: U' \geq 0, U'' \leq 0$$ egzamin pyt42 WDWR detail +Wyjaśnij: Porównanie FSD i SSD ``` +┌─────────────────────────────────────────────────────────────────┐ +│ FSD vs SSD │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Przykład 1: FSD egzamin pyt42 WDWR detail +Wyjaśnij: Zastosowanie w modelach wyboru Test SSD: +• E[A] = 10% > E[B] = 8% ✓ +• σ[A] = 15% < σ[B] = 20% ✓
Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: + A dominuje B (SSD) egzamin pyt42 WDWR detail +Wyjaśnij: Testowanie dominacji ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ALGORYTM SPRAWDZANIA SD │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dane: Dwa rozkłady emp egzamin pyt42 WDWR detail +Wyjaśnij: Ograniczenia | Ograniczenie | Opis | +|--------------|------| +| Częściowe uporządkowanie | Nie wszystkie pary porównywalne | +| Konserwatywność | Wiele par bez dominacji | +| Wymóg pełnego rozkładu | Potrzebna cała dystrybuanta | +| Brak dominacji ≠ obojętność | Brak dominacji nie znaczy równoważność egzamin pyt42 WDWR detail +Wyjaśnij: Notacja Graham'a (α|β|γ) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ NOTACJA KLASYFIKACJI ZADAŃ SZEREGOWANIA │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ α | egzamin pyt43 ZBOP detail +Wyjaśnij: Pole α - Środowisko maszynowe | Symbol | Opis | +|--------|------| +| 1 | Jedna maszyna | +| P | Maszyny równoległe identyczne | +| Pm | m maszyn równoległych identycznych | +| Q | Maszyny równoległe o różnych prędkościach | +| R | Maszyny niezwiązane (unrelated) | +| F | Flow shop (linia produkcyjna) | +| Fm
MASZYNY RÓWNOLEGŁE (Pm): + Job 1 ──→ ┌───┐ + │M1 │ ──→ + Job 2 ──→ ├───┤ + │M2 │ ──→ Output + Job 3 ──→ ├───┤ + │M3 │ ──→ + └───┘ egzamin pyt43 ZBOP detail +Wyjaśnij: Pole β - Charakterystyki zadań | Symbol | Opis | +|--------|------| +| rⱼ | Release dates (terminy dostępności) | +| dⱼ | Due dates (terminy wymagane) | +| d̄ⱼ | Deadlines (nieprzekraczalne terminy) | +| prec | Precedence constraints (kolejność) | +| pmtn | Preemption allowed (przerwanie dozwolone) | +| pⱼ=1 | Un egzamin pyt43 ZBOP detail +Wyjaśnij: Pole γ - Kryteria optymalizacji | Symbol | Nazwa | Formuła | +|--------|-------|---------| +| Cmax | Makespan | max Cⱼ | +| ΣCⱼ | Total completion time | Σ Cⱼ | +| Σwⱼ Cⱼ | Weighted completion | Σ wⱼ Cⱼ | +| Lmax | Max lateness | max(Cⱼ - dⱼ) | +| Tmax | Max tardiness | max(0, Cⱼ - dⱼ) | +| ΣTⱼ | Total tardiness | egzamin pyt43 ZBOP detail +Wyjaśnij: Złożoność obliczeniowa ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ZŁOŻONOŚĆ WYBRANYCH PROBLEMÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ WIELOMIANOWE (P): egzamin pyt43 ZBOP detail +Wyjaśnij: Inne klasyczne reguły | Reguła | Problem | Opis | +|--------|---------|------| +| SPT | 1 \|\| ΣCⱼ | Shortest Processing Time | +| WSPT | 1 \|\| ΣwⱼCⱼ | Weighted SPT (wⱼ/pⱼ malejąco) | +| EDD | 1 \|\| Lmax | Earliest Due Date | +| LPT | Pm \|\| Cmax | Longest Processing Time (heur.) | +| Moore | 1 \|\| ΣUⱼ egzamin pyt43 ZBOP detail +Wyjaśnij: Algorytm Johnsona (F2 || Cmax) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ALGORYTM JOHNSONA - Flow shop 2 maszyny │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dane: n zadań, czasy (a egzamin pyt43 ZBOP detail +Wyjaśnij: Łańcuch dostaw - struktura ``` +┌─────────────────────────────────────────────────────────────────┐ +│ ŁAŃCUCH DOSTAW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Dostawcy → Producent egzamin pyt44 ZBOP detail +Wyjaśnij: Koszty zapasów ``` +┌─────────────────────────────────────────────────────────────────┐ +│ STRUKTURA KOSZTÓW │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ 1. KOSZTY UTRZYMANIA ( egzamin pyt44 ZBOP detail +Wyjaśnij: Model EOQ (Economic Order Quantity) Ordering cost = K × (D/Q) (D/Q zamówień rocznie) +Holding cost = h × (Q/2) (średni zapas = Q/2)
┌──────────┐ + Q* = │ 2·K·D │ + │ ────── │ + │ h │ + └──────────┘ egzamin pyt44 ZBOP detail +Wyjaśnij: Model z punktem zamawiania (ROP) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ REORDER POINT (ROP) - uwzględnienie lead time │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Poziom zapasu: egzamin pyt44 ZBOP detail +Wyjaśnij: Model (s, S) / (R, Q) | Model | Opis | +|-------|------| +| (s, Q) | Zamów Q gdy poziom spadnie do s | +| (s, S) | Zamów do poziomu S gdy spadnie do s | +| (R, S) | Co R okresów uzupełnij do S | +| (R, s, S) | Co R okresów: jeśli ≤ s, uzupełnij do S |
Polityka: Gdy poziom ≤ s, zamów aby osiągnąć S +``` egzamin pyt44 ZBOP detail +Wyjaśnij: Vendor Managed Inventory (VMI) ``` +┌─────────────────────────────────────────────────────────────────┐ +│ VMI - Dostawca zarządza zapasami klienta │ +├─────────────────────────────────────────────────────────────────┤ +│ │ +│ Tradycyjnie: egzamin pyt44 ZBOP detail +Wyjaśnij: Wskaźniki efektywności | Wskaźnik | Formuła | Cel | +|----------|---------|-----| +| Inventory Turnover | COGS / Avg Inventory | Wyższy = lepszy | +| Days of Inventory | 365 / Turnover | Niższy = lepszy | +| Fill Rate | Zamówienia zrealizowane / Wszystkie | Wyższy | +| Service Level | P(brak stockout) | 95-99% egzamin pyt44 ZBOP detail +Wyjaśnij: Pytanie "Jaki jest cel Pana pracy magisterskiej i dlaczego wybrano akurat temat porównania silników gier?" egzamin pyt45 Ogólne detail +Wyjaśnij: Odpowiedź wzorcowa Praktyczna potrzeba: wybór silnika to kluczowa decyzja wpływająca na cały cykl życia projektu
Brak obiektywnych porównań: większość istniejących materiałów ma charakter subiektywny lub marketingowy
Dominacja rynkowa: Unity i Unreal wspólnie obsługują >70% globalnego rynku gier
Reprezentatywność architektur: silniki reprezentują fundamentalnie różne podejścia (C# z GC vs C++ z ręcznym zarządzaniem pamięcią) egzamin pyt45 Ogólne detail +Wyjaśnij: Wydajność - Szybkość renderowania (FPS) +- Zużycie pamięci RAM +- Obciążenie procesora +- Zużycie pamięci karty graficznej +- Czas ładowania scen egzamin pyt45 Ogólne detail +Wyjaśnij: Funkcjonalność - Wsparcie dla różnych typów renderingu +- Systemy fizyki +- Systemy audio +- Wsparcie dla VR/AR +- Możliwości skryptowania egzamin pyt45 Ogólne detail diff --git a/pytania/anki_filter_extract_main.txt b/pytania/anki_filter_extract_main.txt new file mode 100644 index 0000000..8c5bb6c --- /dev/null +++ b/pytania/anki_filter_extract_main.txt @@ -0,0 +1,28 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_filter+extract+main + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (Finite Automaton - FA): Języki regularne (Typ 3)

Automat ze Stosem (Pushdown Automaton - PDA): Języki bezkontekstowe (Typ 2)

Maszyna Turinga (Turing Machine - TM): Języki rekurencyjnie przeliczalne (Typ 0) egzamin pyt01 AISDI main +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. Architektury agentów: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.

Standardy komunikacji agentów: FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD main +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. Algorytmy negocjacji i aukcji: Manager Contractors

Algorytmy konsensusu: Client ──request──→ Primary

Algorytmy koordynacji: Algorytm Ricarta-Agrawali:

Algorytmy uczenia wieloagentowego: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]

Algorytmy dla aktorów: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. Optymalizacja bez ograniczeń: (Gradient zerowy - punkt stacjonarny)

Warunki KKT (Karush-Kuhn-Tucker): Jeśli $x^*$ jest minimum i spełnione są warunki regularności:

Warunki regularności (Constraint Qualification): LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne

Warunki dostateczne II rzędu: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. Programowanie liniowe (LP): Złożoność: O(2^n) worst-case, ale praktycznie bardzo szybki

Programowanie kwadratowe (QP): Gdzie Q jest macierzą symetryczną.

Metody rozwiązywania QP: 1. Zgadnij zbiór aktywnych ograniczeń W

Przypadki szczególne: Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO main +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). Cel parametryzacji mowy: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę

MFCC (Mel-Frequency Cepstral Coefficients): mel(f) = 2595 · log₁₀(1 + f/700)

LPC (Linear Predictive Coding): Dźwięczne:: pobudzenie okresowe (struny głosowe) egzamin pyt19 EASAR main +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. HMM (Hidden Markov Model) - klasyczne podejście: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:

Deep Learning w rozpoznawaniu mowy: Attention-based (Seq2Seq):

Ewolucja wydajności: Rok Model WER egzamin pyt20 EASAR main +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? Agent upostaciowiony (Embodied Agent): Percepcji: poprzez sensory

Formalny model agenta: Specyfikacja żywotności: egzamin pyt21 ERPM main +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. Języki producentów robotów przemysłowych: ! MoveJ = ruch w przestrzeni złączy (Joint)

Języki uniwersalne i frameworki: rospy.init_node('robot_controller') egzamin pyt22 ERPM main +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. Problem czasu w systemach rozproszonych: Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

Zegar Lamporta (Scalar Clock): 1. Przed każdym zdarzeniem lokalnym:

Zegary wektorowe (Vector Clocks): 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. Silne modele spójności: Implementacja: Consensus (Paxos, Raft), single leader

Słabe modele spójności: Implementacja: DNS, Dynamo, Cassandra egzamin pyt24 ERSMS main +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. Definicja MIP (Mixed Integer Programming): Przypadki szczególne:

Branch and Bound (B&B) - metoda dokładna: LP relaxation egzamin pyt25 MOD main +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. Model konceptualny (Conceptual Data Model): ┌──────────┐ ┌──────────┐

Model logiczny (Logical Data Model): ┌────────────────────────┐ ┌────────────────────────┐

Model fizyczny (Physical Data Model): CREATE INDEX idx_klient_email ON klient(email); egzamin pyt28 MODA main +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? Prawo Amdahla: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$

Wizualizacja ograniczenia: Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.

Co osłabia ograniczenie Amdahla?: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n

Czynniki zmniejszające rzeczywiste przyśpieszenie: ┌─────────────────────────────────────────────────────────────────┐

Efektywność równoległa: Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR main +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych. Typowe problemy w modelowaniu: Przykład - planowanie produkcji:

Techniki modelowania: Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM main +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. Definicje kluczowe: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$

Liniowość vs nieliniowość: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$

Testowanie wypukłości: 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x egzamin pyt31 MOM main +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? Definicje podstawowe: KOMUNIKACJA ASYNCHRONICZNA:

Problem zakleszczenia (Deadlock): // Proces 0: // Proces 1:

Rozwiązania problemu zakleszczenia: MPI_Irecv(from=partner, data_in, &req_recv); // Nieblokujące recv egzamin pyt32 PORR main +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. Modele przetwarzania: Processing: ───●───────●──●──●───────→

Platformy Stream Processing: KStream source = builder.stream("input-topic");

Algorytmy strumieniowe: Przykład: Redis PFADD, PFCOUNT egzamin pyt34 PSD main +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. Współpraca agentów w sieci: L = Laplacian grafu komunikacji

Warunki zbieżności consensus: Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU main +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. Funkcje wartości: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$

Algorytmy: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. Metody projekcji: P = B · Bᵀ (dla projekcji na U)

Zastosowanie w grupowaniu dokumentów: Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS main +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? Metody Deep Learning: ┌─────────────────────────────────────────────────────────────────┐

Non-Maximum Suppression (NMS): Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? Dominacja stochastyczna pierwszego rzędu (FSD): $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$

Dominacja stochastyczna drugiego rzędu (SSD): $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$

Zastosowanie w modelach wyboru: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main diff --git a/pytania/anki_filter_main.txt b/pytania/anki_filter_main.txt new file mode 100644 index 0000000..285d562 --- /dev/null +++ b/pytania/anki_filter_main.txt @@ -0,0 +1,28 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_filter+main + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (Finite Automaton - FA): Języki regularne (Typ 3)

Automat ze Stosem (Pushdown Automaton - PDA): Języki bezkontekstowe (Typ 2)

Maszyna Turinga (Turing Machine - TM): Języki rekurencyjnie przeliczalne (Typ 0) egzamin pyt01 AISDI main +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. Architektury agentów: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.

Standardy komunikacji agentów: FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD main +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. Algorytmy negocjacji i aukcji: Manager Contractors

Algorytmy konsensusu: Client ──request──→ Primary

Algorytmy koordynacji: Algorytm Ricarta-Agrawali:

Algorytmy uczenia wieloagentowego: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]

Algorytmy dla aktorów: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. Optymalizacja bez ograniczeń: (Gradient zerowy - punkt stacjonarny)

Warunki KKT (Karush-Kuhn-Tucker): Jeśli $x^*$ jest minimum i spełnione są warunki regularności:

Warunki regularności (Constraint Qualification): LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne

Warunki dostateczne II rzędu: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. Programowanie liniowe (LP): Złożoność: O(2^n) worst-case, ale praktycznie bardzo szybki

Programowanie kwadratowe (QP): Gdzie Q jest macierzą symetryczną.

Metody rozwiązywania QP: 1. Zgadnij zbiór aktywnych ograniczeń W

Przypadki szczególne: Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO main +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). Cel parametryzacji mowy: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę

MFCC (Mel-Frequency Cepstral Coefficients): mel(f) = 2595 · log₁₀(1 + f/700)

LPC (Linear Predictive Coding): Dźwięczne:: pobudzenie okresowe (struny głosowe) egzamin pyt19 EASAR main +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. HMM (Hidden Markov Model) - klasyczne podejście: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:

Deep Learning w rozpoznawaniu mowy: Attention-based (Seq2Seq):

Ewolucja wydajności: Rok Model WER egzamin pyt20 EASAR main +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? Agent upostaciowiony (Embodied Agent): Percepcji: poprzez sensory

Formalny model agenta: Specyfikacja żywotności: egzamin pyt21 ERPM main +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. Języki producentów robotów przemysłowych: ! MoveJ = ruch w przestrzeni złączy (Joint)

Języki uniwersalne i frameworki: rospy.init_node('robot_controller') egzamin pyt22 ERPM main +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. Problem czasu w systemach rozproszonych: Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

Zegar Lamporta (Scalar Clock): 1. Przed każdym zdarzeniem lokalnym:

Zegary wektorowe (Vector Clocks): 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. Silne modele spójności: Implementacja: Consensus (Paxos, Raft), single leader

Słabe modele spójności: Implementacja: DNS, Dynamo, Cassandra egzamin pyt24 ERSMS main +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. Definicja MIP (Mixed Integer Programming): Przypadki szczególne:

Branch and Bound (B&B) - metoda dokładna: LP relaxation egzamin pyt25 MOD main +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. Model konceptualny (Conceptual Data Model): ┌──────────┐ ┌──────────┐

Model logiczny (Logical Data Model): ┌────────────────────────┐ ┌────────────────────────┐

Model fizyczny (Physical Data Model): CREATE INDEX idx_klient_email ON klient(email); egzamin pyt28 MODA main +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? Prawo Amdahla: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$

Wizualizacja ograniczenia: Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.

Co osłabia ograniczenie Amdahla?: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n

Czynniki zmniejszające rzeczywiste przyśpieszenie: ┌─────────────────────────────────────────────────────────────────┐

Efektywność równoległa: Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR main +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych. Typowe problemy w modelowaniu: Przykład - planowanie produkcji:

Techniki modelowania: Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM main +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. Definicje kluczowe: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$

Liniowość vs nieliniowość: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$

Testowanie wypukłości: 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x egzamin pyt31 MOM main +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? Definicje podstawowe: KOMUNIKACJA ASYNCHRONICZNA:

Problem zakleszczenia (Deadlock): // Proces 0: // Proces 1:

Rozwiązania problemu zakleszczenia: MPI_Irecv(from=partner, data_in, &req_recv); // Nieblokujące recv egzamin pyt32 PORR main +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. Modele przetwarzania: Processing: ───●───────●──●──●───────→

Platformy Stream Processing: KStream source = builder.stream("input-topic");

Algorytmy strumieniowe: Przykład: Redis PFADD, PFCOUNT egzamin pyt34 PSD main +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. Współpraca agentów w sieci: L = Laplacian grafu komunikacji

Warunki zbieżności consensus: Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU main +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. Funkcje wartości: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$

Algorytmy: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. Metody projekcji: P = B · Bᵀ (dla projekcji na U)

Zastosowanie w grupowaniu dokumentów: Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS main +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? Metody Deep Learning: ┌─────────────────────────────────────────────────────────────────┐

Non-Maximum Suppression (NMS): Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? Dominacja stochastyczna pierwszego rzędu (FSD): $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$

Dominacja stochastyczna drugiego rzędu (SSD): $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$

Zastosowanie w modelach wyboru: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main diff --git a/pytania/anki_generator.py b/pytania/anki_generator.py new file mode 100644 index 0000000..0f6c2f2 --- /dev/null +++ b/pytania/anki_generator.py @@ -0,0 +1,331 @@ +#!/usr/bin/env python3 +""" +Anki Generator - Modular approach with 3 combinable strategies. + +Usage: + python anki_generator.py [options] + +Options: + --filter Apply strict filtering (answers > 100 chars) + --extract Use improved extraction algorithm + --main-only Only generate main exam questions (45 comprehensive cards) + +Combinations: + python anki_generator.py # Basic extraction, no filter + python anki_generator.py --filter # Approach 1: Strict filter only + python anki_generator.py --extract # Approach 2: Better extraction only + python anki_generator.py --main-only # Approach 3: Main questions only + python anki_generator.py --filter --extract # Approach 4: Filter + Better extraction + python anki_generator.py --filter --main-only # Approach 5: Filter + Main only + python anki_generator.py --extract --main-only # Approach 6: Better extraction + Main only + python anki_generator.py --filter --extract --main-only # Approach 7: All three +""" + +import os +import re +import argparse +from pathlib import Path + +# ============================================================================= +# SHARED UTILITIES +# ============================================================================= + +def clean_text(text): + """Clean and format text for Anki.""" + if not text: + return "" + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'(?\1', text) + text = text.replace('\t', ' ') + text = text.replace('"', '"') + text = re.sub(r' +', ' ', text) + return text.strip() + +def get_file_metadata(filepath): + """Extract question number and subject from filename.""" + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + num = match.group(1) if match else "00" + + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + subj_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subj_match.group(1) if subj_match else "Ogólne" + + return num, subject, content + +def get_main_question(content): + """Extract the main exam question.""" + q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if q_match: + return re.sub(r'\s+', ' ', q_match.group(1).strip()) + return None + +# ============================================================================= +# APPROACH 1: STRICT FILTERING +# ============================================================================= + +def apply_strict_filter(cards, min_length=100): + """Filter cards to only include those with answers > min_length characters.""" + return [c for c in cards if len(c['back']) > min_length] + +# ============================================================================= +# APPROACH 2: BETTER EXTRACTION +# ============================================================================= + +def extract_structured_content(body): + """Improved extraction - multiple content types with better formatting.""" + parts = [] + + # 1. Definitions + def_match = re.search(r'#### Definicja[^\n]*\n([^\n#]+)', body) + if def_match: + parts.append(f"Definicja: {def_match.group(1).strip()}") + + # 2. Bullet points with bold terms + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)', body) + for term, desc in bullets[:5]: + if desc.strip(): + parts.append(f"• {term}: {desc.strip()}") + else: + parts.append(f"• {term}") + + # 3. Key-value patterns + if len(parts) < 2: + kvs = re.findall(r'\*\*([^*\n]+)\*\*\s*[-–:]\s*([^\n*]{10,150})', body) + for k, v in kvs[:4]: + entry = f"{k.strip()}: {v.strip()}" + if entry not in parts: + parts.append(entry) + + # 4. Paragraphs as fallback + if not parts: + paras = [p.strip() for p in body.split('\n\n') + if p.strip() and not p.startswith('```') and not p.startswith('|') and len(p.strip()) > 30] + for p in paras[:2]: + parts.append(p[:300]) + + return '
'.join([clean_text(p) for p in parts]) if parts else None + +def extract_cards_better(filepath): + """Extract cards with improved algorithm.""" + num, subject, content = get_file_metadata(filepath) + base_tags = f"egzamin pyt{num} {subject}" + cards = [] + + # Main question + main_q = get_main_question(content) + if main_q: + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^�]|\Z)', content, re.DOTALL) + if answer_match: + answer = extract_structured_content(answer_match.group(1)) + if answer: + cards.append({'front': clean_text(main_q), 'back': answer, 'tags': f"{base_tags} main"}) + + # Detail sections + sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', content, re.MULTILINE | re.DOTALL) + for header, body in sections: + header = header.strip() + if 'Przykład' in header or '"' in header or 'Mnemonic' in header or len(body) < 50: + continue + + answer = extract_structured_content(body) + if answer: + cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': f"{base_tags} detail"}) + + return cards + +def extract_cards_basic(filepath): + """Basic extraction - simpler algorithm.""" + num, subject, content = get_file_metadata(filepath) + base_tags = f"egzamin pyt{num} {subject}" + cards = [] + + # Main question - just headers + main_q = get_main_question(content) + if main_q: + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)', content, re.DOTALL) + if answer_match: + headers = re.findall(r'^### (?:\d+\.\s*)?(.+)$', answer_match.group(1), re.MULTILINE) + if headers: + answer = '
    ' + ''.join([f'
  • {clean_text(h)}
    • ' for h in headers[:6]]) + '
' + cards.append({'front': clean_text(main_q), 'back': answer, 'tags': f"{base_tags} main"}) + + # Detail sections - first paragraph only + sections = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', content, re.MULTILINE | re.DOTALL) + for header, body in sections: + header = header.strip() + body = body.strip() + if len(body) < 50 or 'Przykład' in header: + continue + + paras = [p.strip() for p in body.split('\n\n') if p.strip() and not p.startswith('```')] + if paras: + answer = clean_text(paras[0][:400]) + cards.append({'front': f"Wyjaśnij: {clean_text(header)}", 'back': answer, 'tags': f"{base_tags} detail"}) + + return cards + +# ============================================================================= +# APPROACH 3: MAIN QUESTIONS ONLY +# ============================================================================= + +def extract_main_only(filepath): + """Extract only the main exam question with comprehensive answer.""" + num, subject, content = get_file_metadata(filepath) + base_tags = f"egzamin pyt{num} {subject} main" + + main_q = get_main_question(content) + if not main_q: + return [] + + # Build comprehensive answer from multiple sections + answer_parts = [] + + # Get main answer section + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^�]|\Z)', content, re.DOTALL) + if answer_match: + section = answer_match.group(1) + + # Get all ### headers with their first substantive content + headers = re.findall(r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', section, re.MULTILINE | re.DOTALL) + + for header, body in headers[:5]: + header = header.strip() + if 'Przykład' in header or 'Mnemonic' in header or '"' in header: + continue + + # Get key point from this section + key_point = None + + # Try to get a definition or first bullet + def_match = re.search(r'Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*', body) + if def_match: + key_point = def_match.group(1).strip() + + if not key_point: + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)', body) + if bullets: + term, desc = bullets[0] + key_point = f"{term}: {desc.strip()}" if desc.strip() else term + + if not key_point: + para_match = re.search(r'\n\n([^#\n\-•|`][^\n]{20,150})', body) + if para_match: + key_point = para_match.group(1).strip() + + if key_point: + answer_parts.append(f"{header}: {key_point}") + + if answer_parts: + answer = '

'.join([clean_text(p) for p in answer_parts]) + return [{'front': clean_text(main_q), 'back': answer, 'tags': base_tags}] + + return [] + +# ============================================================================= +# MAIN GENERATOR +# ============================================================================= + +def generate_anki(use_filter=False, use_better_extract=False, main_only=False): + """Generate Anki deck with specified approaches.""" + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + + # Determine output filename based on options + suffix_parts = [] + if use_filter: + suffix_parts.append("filter") + if use_better_extract: + suffix_parts.append("extract") + if main_only: + suffix_parts.append("main") + suffix = "_".join(suffix_parts) if suffix_parts else "basic" + + output_file = Path(f"/home/kuchy/praca_magisterska/pytania/anki_{suffix}.txt") + deck_name = f"Egzamin_{suffix.replace('_', '+')}" + + all_cards = [] + + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + if main_only: + # Approach 3: Only main questions + cards = extract_main_only(md_file) + elif use_better_extract: + # Approach 2: Better extraction + cards = extract_cards_better(md_file) + else: + # Basic extraction + cards = extract_cards_basic(md_file) + + all_cards.extend(cards) + + # Approach 1: Apply filtering if requested + if use_filter: + all_cards = apply_strict_filter(all_cards, min_length=100) + + # Remove duplicates + seen = set() + unique = [] + for c in all_cards: + key = c['front'][:80] + if key not in seen: + seen.add(key) + unique.append(c) + + # Write output + with open(output_file, 'w', encoding='utf-8') as f: + f.write(f"#separator:Tab\n#html:true\n#notetype:Basic\n#deck:{deck_name}\n\n") + for c in unique: + f.write(f"{c['front']}\t{c['back']}\t{c['tags']}\n") + + # Statistics + lengths = [len(c['back']) for c in unique] + short = sum(1 for l in lengths if l < 50) + medium = sum(1 for l in lengths if 50 <= l < 150) + good = sum(1 for l in lengths if l >= 150) + + print(f"✅ Generated: {output_file.name}") + print(f" Cards: {len(unique)}") + print(f" Quality: {short} short / {medium} medium / {good} good") + print() + + return output_file + +def main(): + parser = argparse.ArgumentParser(description="Generate Anki flashcards with modular approaches") + parser.add_argument('--filter', action='store_true', help='Approach 1: Strict filtering (>100 chars)') + parser.add_argument('--extract', action='store_true', help='Approach 2: Better extraction algorithm') + parser.add_argument('--main-only', action='store_true', help='Approach 3: Main exam questions only') + parser.add_argument('--all-combinations', action='store_true', help='Generate all 7 combinations') + + args = parser.parse_args() + + if args.all_combinations: + # Generate all 7 combinations + print("=" * 60) + print("Generating all 7 combinations...") + print("=" * 60 + "\n") + + combinations = [ + (True, False, False), # 1: Filter only + (False, True, False), # 2: Extract only + (False, False, True), # 3: Main only + (True, True, False), # 4: Filter + Extract + (True, False, True), # 5: Filter + Main + (False, True, True), # 6: Extract + Main + (True, True, True), # 7: All three + ] + + for i, (f, e, m) in enumerate(combinations, 1): + print(f"--- Combination {i} (filter={f}, extract={e}, main={m}) ---") + generate_anki(use_filter=f, use_better_extract=e, main_only=m) + else: + generate_anki( + use_filter=args.filter, + use_better_extract=args.extract, + main_only=args.main_only + ) + +if __name__ == "__main__": + main() diff --git a/pytania/anki_main.txt b/pytania/anki_main.txt new file mode 100644 index 0000000..9544f02 --- /dev/null +++ b/pytania/anki_main.txt @@ -0,0 +1,40 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin_main + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (Finite Automaton - FA): Języki regularne (Typ 3)

Automat ze Stosem (Pushdown Automaton - PDA): Języki bezkontekstowe (Typ 2)

Maszyna Turinga (Turing Machine - TM): Języki rekurencyjnie przeliczalne (Typ 0) egzamin pyt01 AISDI main +Omówić i porównać algorytmy najkrótszej ścieżki wskazując ich kluczowe właściwości i logikę budowy: Dijkstry, Belmana-Forda, A*. Wprowadzenie - problem najkrótszej ścieżki: Warianty problemu: egzamin pyt02 AISDI main +Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. Wprowadzenie: Redundancja: = niepożądane powtarzanie danych egzamin pyt03 BD2 main +Omówić główne kategorie elementów biblioteki STL. Jaka jest ich rola i wzajemne powiązania? Odpowiedź uzasadnić na przykładach. Filozofia STL: Generyczność: szablony (templates) umożliwiają pracę z dowolnymi typami egzamin pyt05 PROI main +Przedstawić sieciowe modele optymalizacji stosowane w systemach zarządzania. Omówić ich właściwości. Wprowadzenie: Węzły: = punkty decyzyjne, lokalizacje, zdarzenia egzamin pyt12 WSYZ main +Omówić szczegółowo teorie, definicje, standardy i narzędzia wykorzystywane przy projektowaniu i implementacji systemów opartych na koncepcji agenta i aktora. Architektury agentów: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.

Standardy komunikacji agentów: FIPA-ACL (Agent Communication Language): egzamin pyt13 AASD main +Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. Algorytmy negocjacji i aukcji: Manager Contractors

Algorytmy konsensusu: Client ──request──→ Primary

Algorytmy koordynacji: Algorytm Ricarta-Agrawali:

Algorytmy uczenia wieloagentowego: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]

Algorytmy dla aktorów: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main +Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury. Notacje i języki modelowania: Zasada: Zoom in/out między poziomami egzamin pyt15 AIS main +Czemu służą wzorce architektoniczne? Jak powstają? Jak są katalogowane? Omówić przykładowe wzorce architektoniczne. Jak powstają wzorce: Nazwa: identyfikator egzamin pyt16 AIS main +Przedstawić warunki konieczne i dostateczne optymalności różniczkowalnych zadań optymalizacji bez ograniczeń i z ograniczeniami oraz warunki regularności i omówić metody poszukiwania rozwiązań zadań optymalizacji nieliniowej. Optymalizacja bez ograniczeń: (Gradient zerowy - punkt stacjonarny)

Warunki KKT (Karush-Kuhn-Tucker): Jeśli $x^*$ jest minimum i spełnione są warunki regularności:

Warunki regularności (Constraint Qualification): LICQ: $\{\nabla g_i(x^) : g_i(x^) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne

Warunki dostateczne II rzędu: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main +Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. Programowanie liniowe (LP): Złożoność: O(2^n) worst-case, ale praktycznie bardzo szybki

Programowanie kwadratowe (QP): Gdzie Q jest macierzą symetryczną.

Metody rozwiązywania QP: 1. Zgadnij zbiór aktywnych ograniczeń W

Przypadki szczególne: Rozwiązanie: $(A^T A)x = A^T b$ (równanie normalne) egzamin pyt18 AMO main +Przedstawić metody wyznaczania cech (parametryzacji) sygnału mowy: MFCC (cechy mel-cepstralne) i LPC (cechy według liniowej predykcji). Cel parametryzacji mowy: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę

MFCC (Mel-Frequency Cepstral Coefficients): mel(f) = 2595 · log₁₀(1 + f/700)

LPC (Linear Predictive Coding): Dźwięczne:: pobudzenie okresowe (struny głosowe) egzamin pyt19 EASAR main +Przedstawić klasyczną metodę rozpoznawania mowy opartą o HMM (Ukryte Modele Markowa). Porównać ją z metodami korzystającymi z głębokich sieci neuronowych. HMM (Hidden Markov Model) - klasyczne podejście: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:

Deep Learning w rozpoznawaniu mowy: Attention-based (Seq2Seq):

Ewolucja wydajności: Rok Model WER egzamin pyt20 EASAR main +Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? Agent upostaciowiony (Embodied Agent): Percepcji: poprzez sensory

Formalny model agenta: Specyfikacja żywotności: egzamin pyt21 ERPM main +Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. Języki producentów robotów przemysłowych: ! MoveJ = ruch w przestrzeni złączy (Joint)

Języki uniwersalne i frameworki: rospy.init_node('robot_controller') egzamin pyt22 ERPM main +Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. Problem czasu w systemach rozproszonych: Problem: Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

Zegar Lamporta (Scalar Clock): 1. Przed każdym zdarzeniem lokalnym:

Zegary wektorowe (Vector Clocks): 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main +Omówić silne i słabe modele spójności danych w środowisku rozproszonym. Silne modele spójności: Implementacja: Consensus (Paxos, Raft), single leader

Słabe modele spójności: Implementacja: DNS, Dynamo, Cassandra egzamin pyt24 ERSMS main +Gdzie znajdują zastosowania zadania programowania matematycznego całkowitoliczbowego i jak można je rozwiązywać? Omówić wybraną metodę dokładną, wyjaśnić dla jakich praktycznych problemów ma ona zastosowanie i co może wpływać na jej efektywność. Definicja MIP (Mixed Integer Programming): Przypadki szczególne:

Branch and Bound (B&B) - metoda dokładna: LP relaxation egzamin pyt25 MOD main +Scharakteryzować informatyczne narzędzia optymalizacji dyskretnej. Jakie są warunki i wymagania, jakie możliwości oraz trudności wiążą się ze stosowaniem gotowych narzędzi. Porównanie wydajności (benchmark): CPLEX ████████████████████████████ 100% egzamin pyt26 MOD main +Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. Model konceptualny (Conceptual Data Model): ┌──────────┐ ┌──────────┐

Model logiczny (Logical Data Model): ┌────────────────────────┐ ┌────────────────────────┐

Model fizyczny (Physical Data Model): CREATE INDEX idx_klient_email ON klient(email); egzamin pyt28 MODA main +Oszacować ilościowo przyśpieszenie wykonania programu sekwencyjnego z fragmentami równoległymi na maszynie wielordzeniowej. Co osłabia to ograniczenie? Prawo Amdahla: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$

Wizualizacja ograniczenia: Obserwacja: Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.

Co osłabia ograniczenie Amdahla?: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n

Czynniki zmniejszające rzeczywiste przyśpieszenie: ┌─────────────────────────────────────────────────────────────────┐

Efektywność równoległa: Wniosek: Efektywność spada z liczbą procesorów. Trzeba zwiększać problem (Gustafson) lub zmniejszać (1-p). egzamin pyt29 PORR main +Omówić metody oraz typowe problemy w modelowaniu matematycznym dla problemów decyzyjnych i optymalizacyjnych. Typowe problemy w modelowaniu: Przykład - planowanie produkcji:

Techniki modelowania: Problem: |x| (wartość bezwzględna) egzamin pyt30 MOM main +Wyjaśnić główne zagadnienia modelowania matematycznego w systemach decyzyjnych z wykorzystaniem pojęć (nie)wypukłości i (nie)liniowości. Definicje kluczowe: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$

Liniowość vs nieliniowość: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$

Testowanie wypukłości: 1. HESJAN: H = ∇²f(x) ≽ 0 (dodatnio półokreślony) dla wszystkich x egzamin pyt31 MOM main +Podać definicję komunikacji synchronicznej i asynchronicznej oraz blokującej i nieblokującej. Jak uniknąć zakleszczenia, gdy dwa symetryczne procesy (np. realizujące algorytm iteracyjny Jacobiego) mają w kodzie następujące po sobie wywołania funkcji wysyłającej komunikat do partnera i odbierającej komunikat wysłany przez niego? Definicje podstawowe: KOMUNIKACJA ASYNCHRONICZNA:

Problem zakleszczenia (Deadlock): // Proces 0: // Proces 1:

Rozwiązania problemu zakleszczenia: MPI_Irecv(from=partner, data_in, &req_recv); // Nieblokujące recv egzamin pyt32 PORR main +Scharakteryzować model przesyłania komunikatów publikuj-subskrybuj oraz przykładowe rozwiązania techniczne wykorzystujące ten model. Rozwiązania techniczne: channel.queue_bind(exchange='logs', queue=queue_name) egzamin pyt33 PSD main +Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. Modele przetwarzania: Processing: ───●───────●──●──●───────→

Platformy Stream Processing: KStream source = builder.stream("input-topic");

Algorytmy strumieniowe: Przykład: Redis PFADD, PFCOUNT egzamin pyt34 PSD main +Na czym polega specyfika modelowania matematycznego układów cyber-fizycznych? Podać przykłady współpracy agentów w sieci i problemów w osiąganiu pożądanego zachowania układu. Współpraca agentów w sieci: L = Laplacian grafu komunikacji

Warunki zbieżności consensus: Szybkość zbieżności ~ λ₂(L) (algebraic connectivity) egzamin pyt35 SIU main +Omówić ogólny algorytm, elementy składowe oraz własności uczenia się ze wzmocnieniem. Funkcje wartości: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$

Algorytmy: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main +Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. Metody projekcji: P = B · Bᵀ (dla projekcji na U)

Zastosowanie w grupowaniu dokumentów: Graf dwudzielny projekcja (cosine similarity): egzamin pyt38 TASS main +Scharakteryzować problem segmentacji obrazu. Przedstawić podstawowe strategie i algorytmy segmentacji przy użyciu metod klasycznych oraz sieci neuronowych. Metody klasyczne: Otsu (automatyczny próg): egzamin pyt39 TWM main +Opisać problem detekcji obiektów w obrazach. Przedstawić podstawowe strategie i algorytmy detekcji przy użyciu metod klasycznych oraz sieci neuronowych. Jak skonstruować detektor obiektów dysponując istniejącym klasyfikatorem tych obiektów? Metody Deep Learning: ┌─────────────────────────────────────────────────────────────────┐

Non-Maximum Suppression (NMS): Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main +Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. Metoda pewnego ekwiwalentu (Certainty Equivalent): Dla loterii L = (p₁: x₁, p₂: x₂, ...): egzamin pyt41 WDWR main +Scharakteryzować relacje dominacji stochastycznej pierwszego i drugiego rzędu. Jak mogą być użyte w modelach wyboru w warunkach ryzyka? Dominacja stochastyczna pierwszego rzędu (FSD): $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$

Dominacja stochastyczna drugiego rzędu (SSD): $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$

Zastosowanie w modelach wyboru: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main +Jakie cechy zadań szeregowania wykorzystuje się do ich klasyfikacji? Omówić przykładową metodę dla wybranego problemu szeregowania. Pole α - Środowisko maszynowe: MASZYNY RÓWNOLEGŁE (Pm): egzamin pyt43 ZBOP main +Jakie problemy wiążą się z zarządzaniem zapasami w łańcuchu dostaw? Omówić przykładowy model zarządzania zapasami w łańcuchu dostaw. Model EOQ (Economic Order Quantity): Ordering cost = K × (D/Q) (D/Q zamówień rocznie) egzamin pyt44 ZBOP main diff --git a/pytania/anki_manual.txt b/pytania/anki_manual.txt new file mode 100644 index 0000000..f34a1b4 --- /dev/null +++ b/pytania/anki_manual.txt @@ -0,0 +1,118 @@ +#separator:Tab +#html:true +#notetype:Basic +#deck:Egzamin Magisterski - Ręcznie +#tags column:3 + +Porównać 'siłę wyrazu' automatu skończonego, automatu ze stosem oraz maszyny Turinga. Jakie klasy języków rozpoznaje każdy z nich? Automat Skończony (FA) → Języki regularne (Typ 3)
• Brak pamięci - tylko aktualny stan
• Równoważny wyrażeniom regularnym
• Przykład: identyfikatory, wzorce tekstu
• NIE rozpozna: aⁿbⁿ (wymaga liczenia)

Automat ze Stosem (PDA) → Języki bezkontekstowe (Typ 2)
• Pamięć: stos LIFO (nieskończony, ale ograniczony dostęp)
• Potrafi liczyć pary: aⁿbⁿ ✓
• NIE rozpozna: aⁿbⁿcⁿ (wymaga 3 liczników)
• UWAGA: DPDA ⊂ NPDA (niedeterministyczny silniejszy!)

Maszyna Turinga (TM) → Języki rekurencyjnie przeliczalne (Typ 0)
• Pamięć: nieskończona taśma R/W
• Rozpoznaje wszystko co obliczalne (teza Churcha-Turinga)
• DTM ≡ NTM pod względem mocy pyt01 AISDI automaty hierarchia_chomskiego + +Dlaczego automat skończony nie może rozpoznać języka L = {aⁿbⁿ}? Automat skończony nie ma pamięci poza swoim stanem. Aby rozpoznać aⁿbⁿ, musiałby "zapamiętać" ile było liter 'a', żeby porównać z liczbą 'b'.

Skończona liczba stanów = skończona "pamięć" = nie może liczyć do dowolnie dużego n.

Dowód formalny: Lemat o pompowaniu - dla słowa aᵖbᵖ (gdzie p = stała pompowania), pompując część y w xyz, dostaniemy nierówną liczbę a i b. pyt01 AISDI automaty pumping_lemma + +Dlaczego DPDA jest słabszy niż NPDA, ale DFA = NFA? DFA = NFA (równoważne):
Każdy NFA można przekształcić w DFA przez konstrukcję podzbiorową (powerset construction). Stany DFA = podzbiory stanów NFA.

DPDA ⊂ NPDA (DPDA słabszy):
Stos wymaga "odgadnięcia" kiedy skończyć odkładanie i zacząć zdejmowanie. Przykład: palindromy parzyste L = {wwᴿ} - NPDA "zgaduje" środek słowa, DPDA nie może.

Kluczowa różnica: przy stosie niedeterminizm daje realną przewagę, przy samych stanach - nie. pyt01 AISDI automaty dpda_npda + +Omówić i porównać algorytmy najkrótszej ścieżki: Dijkstry, Bellmana-Forda, A*. Dijkstra (1959) - zachłanny, SSSP
• Wymóg: wagi ≥ 0
• Złożoność: O(V²) lub O((V+E)log V) z kopcem
• Idea: wybieraj wierzchołek o najmniejszej znanej odległości

Bellman-Ford (1958) - programowanie dynamiczne
• Działa dla ujemnych wag (wykrywa ujemne cykle)
• Złożoność: O(V·E)
• Idea: V-1 iteracji relaksacji wszystkich krawędzi

A* (1968) - heurystyczny, single-pair
• Wymóg: heurystyka dopuszczalna h(n) ≤ h*(n)
• f(n) = g(n) + h(n) (koszt dotarcia + szacowany koszt do celu)
• Znacznie szybszy od Dijkstry dla konkretnego celu pyt02 AISDI algorytmy_grafowe najkrotsza_sciezka + +Dlaczego algorytm Dijkstry nie działa dla ujemnych wag? Dijkstra oznacza wierzchołki jako "zakończone" gdy je przetworzy - zakłada, że znaleziona odległość jest ostateczna.

Problem: Ujemna krawędź może później "poprawić" już zakończony wierzchołek.

Przykład:
S→C = 2 (Dijkstra ustala jako finalne)
S→A→B→C = 1 + (-5) + 1 = -3 < 2

Bellman-Ford rozwiązuje to robiąc V-1 iteracji po WSZYSTKICH krawędziach. pyt02 AISDI dijkstra ujemne_wagi + +Co to jest heurystyka dopuszczalna w A* i dlaczego jest ważna? Heurystyka dopuszczalna (admissible): h(n) ≤ h*(n)
czyli heurystyka nigdy nie przeszacowuje rzeczywistego kosztu do celu.

Dlaczego ważna:
• Gwarantuje optymalność - A* znajdzie najkrótszą ścieżkę
• Jeśli h(n) > h*(n), A* może pominąć optymalną ścieżkę

Przykłady:
• Odległość euklidesowa (linia prosta) - zawsze ≤ rzeczywistej trasy
• h(n) = 0 → A* = Dijkstra (bezpieczne, ale wolne)

Heurystyka spójna (consistent): h(n) ≤ c(n,n') + h(n') - silniejsza, przyspiesza A* pyt02 AISDI a_star heurystyka + +Czym jest redundancja w bazach danych i jakie anomalie powoduje? Redundancja = ta sama informacja przechowywana w wielu miejscach.

Trzy anomalie:

1. Anomalia wstawiania
Nie można dodać danych bez innych danych.
Przykład: nowy kurs bez studentów

2. Anomalia usuwania
Usunięcie danych powoduje utratę innych informacji.
Przykład: usunięcie ostatniego studenta kursu = utrata info o kursie

3. Anomalia modyfikacji
Zmiana wymaga aktualizacji wielu wierszy.
Przykład: zmiana nazwiska prowadzącego = update wielu rekordów

Rozwiązanie: Normalizacja - dekompozycja tabel pyt03 BD2 redundancja anomalie + +Wyjaśnij postacie normalne 1NF, 2NF, 3NF. 1NF - Pierwsza Postać Normalna
• Atomowość wartości (brak list/tablic w komórkach)
• Istnieje klucz główny

2NF - Druga Postać Normalna
• Spełnia 1NF
• Brak częściowych zależności (atrybut zależy od CAŁEGO klucza złożonego, nie od części)
• Dotyczy tylko tabel z kluczem wielokolumnowym

3NF - Trzecia Postać Normalna
• Spełnia 2NF
• Brak przechodnich zależności (A→B→C, gdzie B nie jest kluczem)
• Atrybuty wtórne zależą TYLKO od klucza

Hierarchia: 5NF ⊂ 4NF ⊂ BCNF ⊂ 3NF ⊂ 2NF ⊂ 1NF pyt03 BD2 normalizacja postacie_normalne + +Co to jest BCNF i czym różni się od 3NF? BCNF (Boyce-Codd Normal Form):
Dla każdej nietrywialnej zależności funkcyjnej X→Y, X musi być nadkluczem.

Różnica od 3NF:
3NF dopuszcza: X→A gdzie A jest atrybutem pierwszym (należy do klucza)
BCNF: NIE dopuszcza - zawsze X musi być nadkluczem

Przykład naruszenia 3NF ale spełnienia BCNF:
Relacja z kluczami kandydującymi {A,B} i {A,C}
Zależność B→C narusza BCNF (B nie jest nadkluczem)
ale spełnia 3NF (C jest atrybutem pierwszym)

Praktyka: 3NF zwykle wystarcza, BCNF może utrudnić dekompozycję pyt03 BD2 bcnf normalizacja + +Co oznacza ACID w kontekście transakcji bazodanowych? A - Atomicity (Atomowość)
Transakcja wykonuje się w całości lub wcale. Brak częściowych zmian.

C - Consistency (Spójność)
Dane przechodzą z jednego spójnego stanu w drugi. Reguły biznesowe zawsze spełnione.

I - Isolation (Izolacja)
Równoległe transakcje nie widzą swoich pośrednich zmian. Brak efektów ubocznych.

D - Durability (Trwałość)
Zatwierdzone zmiany przetrwają awarie systemu.

Przykład - przelew bankowy:
Bez A: awaria po odjęciu = utrata pieniędzy
Bez C: saldo ujemne mimo ograniczenia
Bez I: inna transakcja widzi stan pośredni
Bez D: po COMMIT dane giną pyt04 BD2 acid transakcje + +Dlaczego baza danych stanowi dobry fundament systemów informatycznych? 1. Transakcyjność (ACID)
Gwarancja spójności i niezawodności operacji

2. Niezależność danych
• Fizyczna: zmiana indeksów/partycjonowania bez zmiany aplikacji
• Logiczna: zmiana schematu z minimalnym wpływem (widoki)

3. Współbieżność
Wiele aplikacji jednocześnie: blokady, MVCC, poziomy izolacji

4. Integralność
• Ograniczenia: PK, FK, CHECK, NOT NULL
• Wyzwalacze i procedury składowane

5. Optymalizacja
Automatyczny optymalizator zapytań, indeksy, statystyki

6. Bezpieczeństwo
Kontrola dostępu, audyt, szyfrowanie pyt04 BD2 bazy_danych fundament + +Jakie są główne kategorie elementów STL i jak są powiązane? 4 główne kategorie:

1. KONTENERY - struktury przechowujące dane
• Sekwencyjne: vector, list, deque
• Asocjacyjne: map, set (drzewo czerwono-czarne)
• Nieuporządkowane: unordered_map (hash table)

2. ITERATORY - abstrakcja wskaźnika
• input, output, forward, bidirectional, random access
• Łączą kontenery z algorytmami

3. ALGORYTMY - operacje na danych
• sort, find, transform, copy, accumulate
• Działają na iteratorach, nie na kontenerach bezpośrednio

4. FUNKTORY - obiekty wywoływalne
• less, greater, plus
• Lambdy od C++11

Powiązanie: Algorytmy operują na kontenerach PRZEZ iteratory, parametryzowane funktorami pyt05 PROI stl cpp + +Kiedy użyć vector, a kiedy list w STL? std::vector - tablica dynamiczna
• Dostęp O(1) przez indeks
• Wstawianie na końcu O(1) amortyzowane
• Wstawianie w środku O(n) - przesunięcie elementów
• Cache-friendly (ciągła pamięć)
→ Użyj gdy: częsty dostęp losowy, głównie dodajesz na koniec

std::list - lista dwukierunkowa
• Dostęp O(n) - brak indeksowania
• Wstawianie/usuwanie O(1) w dowolnym miejscu (po znalezieniu)
• Nie invaliduje iteratorów przy modyfikacji
→ Użyj gdy: częste wstawianie/usuwanie w środku, iteratory muszą pozostać ważne

Praktyka: vector w 95% przypadków (cache matters!) pyt05 PROI stl vector_list + +Różnica między map a unordered_map w STL? std::map (drzewo czerwono-czarne)
• Operacje: O(log n)
• Elementy posortowane według klucza
• Wymaga operator< dla klucza
• Stabilna wydajność

std::unordered_map (tablica haszująca)
• Operacje: O(1) średnio, O(n) pesymistycznie
• Elementy nieposortowane
• Wymaga std::hash dla klucza
• Szybsza dla dużych zbiorów z dobrą funkcją hash

Kiedy map:
• Potrzebujesz posortowanych kluczy
• Iterujesz po zakresach

Kiedy unordered_map:
• Tylko lookup/insert (brak iteracji po kolejności)
• Duże zbiory danych pyt05 PROI stl map_unordered + +Jaki jest cel three-way handshake w TCP? Cele:
1. Nawiązanie połączenia - obie strony zgadzają się komunikować
2. Synchronizacja ISN - wymiana początkowych numerów sekwencyjnych
3. Uzgodnienie parametrów - MSS, Window Scale, SACK

Przebieg:
1. Klient → SYN, seq=x (stan: SYN_SENT)
2. Serwer → SYN+ACK, seq=y, ack=x+1 (stan: SYN_RECEIVED)
3. Klient → ACK, seq=x+1, ack=y+1 (stan: ESTABLISHED)

Dlaczego 3 kroki?
• 2 kroki: serwer nie wie czy klient otrzymał jego ISN
• 3 kroki: obie strony potwierdziły swoje ISN pyt08 SKM tcp handshake + +Co to jest numer sekwencyjny w TCP i jaka jest jego wartość początkowa? Sequence Number (SEQ) = numer pierwszego bajtu danych w segmencie.

Interpretacja:
• SEQ=1000, 500 bajtów danych → następny segment ma SEQ=1500
• Umożliwia składanie segmentów w kolejności
• Wykrywanie duplikatów i braków

Acknowledgment Number (ACK) = numer NASTĘPNEGO oczekiwanego bajtu.
ACK=1500 oznacza: "otrzymałem wszystko do bajtu 1499"

Wartość początkowa (ISN):
• Losowa (nie 0!) ze względów bezpieczeństwa
• Zapobiega atakom typu session hijacking
• Historycznie: ISN = (timer * 250) mod 2³²
• Współcześnie: kryptograficznie losowy pyt08 SKM tcp seq_ack + +Czym różni się proces od wątku? PROCES
• Oddzielna przestrzeń adresowa (izolacja)
• Własny PCB (Process Control Block)
• Komunikacja: IPC (pipe, socket, shared memory)
• Przełączanie: kosztowne (zmiana kontekstu MMU)
• Awaria jednego nie wpływa na inne

WĄTEK
• Współdzieli przestrzeń adresową procesu
• Własny: stos, rejestry, PC
• Wspólne: kod, dane, heap, pliki
• Przełączanie: szybkie (bez zmiany tablic stron)
• Awaria jednego = awaria całego procesu

Analogia:
Proces = mieszkanie (własne zasoby)
Wątek = współlokator (wspólna kuchnia, łazienka) pyt09 SOI procesy_watki + +Jakie są problemy synchronizacji wątków i jak je rozwiązać? PROBLEMY:

1. Wyścig (Race Condition)
Wynik zależy od kolejności wykonania
→ Rozwiązanie: sekcja krytyczna z mutexem

2. Zakleszczenie (Deadlock)
Wątki czekają na siebie nawzajem
→ Rozwiązanie: kolejność blokad, timeout, wykrywanie

3. Zagłodzenie (Starvation)
Wątek nigdy nie dostaje zasobu
→ Rozwiązanie: sprawiedliwe szeregowanie, kolejki

4. Livelock
Wątki aktywne, ale nie robią postępu
→ Rozwiązanie: losowe opóźnienia

MECHANIZMY:
• Mutex, Semafor, Monitor
• Zmienna warunkowa (condition variable)
• Read-write lock
• Operacje atomowe pyt09 SOI synchronizacja watki + +Warunki konieczne wystąpienia zakleszczenia (deadlock). 4 warunki Coffmana (wszystkie muszą być spełnione):

1. Wzajemne wykluczanie (Mutual Exclusion)
Zasób może być używany tylko przez jeden proces

2. Trzymaj i czekaj (Hold and Wait)
Proces trzyma zasoby czekając na kolejne

3. Brak wywłaszczania (No Preemption)
Zasobów nie można odebrać siłą

4. Cykliczne oczekiwanie (Circular Wait)
P1→P2→P3→P1 (cykl oczekiwań)

Zapobieganie:
Złam dowolny warunek:
• Ustal globalną kolejność zasobów (łamie 4)
• Żądaj wszystkich zasobów naraz (łamie 2)
• Pozwól na wywłaszczanie (łamie 3) pyt09 SOI deadlock warunki + +Co to jest stronicowanie i segmentacja? Porównaj. STRONICOWANIE (Paging)
• Pamięć dzielona na równe ramki (np. 4KB)
• Tablica stron: strona → ramka
• Fragmentacja wewnętrzna (ostatnia strona)
• Niewidoczne dla programisty
• Umożliwia pamięć wirtualną (swap)

SEGMENTACJA (Segmentation)
• Pamięć dzielona logicznie: kod, dane, stos
• Segmenty różnej wielkości
• Fragmentacja zewnętrzna
• Widoczna dla programisty (ochrona, współdzielenie)

PORÓWNANIE:
| Cecha | Stronic. | Segment. |
| Jednostka | Stała | Zmienna |
| Fragmentacja | Wewnętrzna | Zewnętrzna |
| Widoczność | Ukryta | Jawna |

Praktyka: Często łączone (segmentacja + stronicowanie) pyt10 SOI zarzadzanie_pamiecia stronic_segment + +Jakie standardy służą do modelowania procesów biznesowych? BPMN 2.0 (Business Process Model and Notation)
• Główny standard dla procesów biznesowych
• Wykonywalne diagramy (silniki workflow)
• Elementy: zdarzenia (kółka), bramki (romby), czynności (prostokąty), przepływy
• Swimlanes = odpowiedzialności

UML (Unified Modeling Language)
• Diagram aktywności ≈ flowchart
• Diagram przypadków użycia
• Głównie dla systemów IT, nie procesów biznesowych

EPC (Event-driven Process Chain)
• Metodyka ARIS
• Zdarzenia → Funkcje → Zdarzenia
• Popularne w SAP

Praktyka: BPMN dla biznesu, UML dla IT pyt11 ISA bpmn modelowanie_procesow + +Czym różnią się bramki XOR, AND i OR w BPMN? XOR (Exclusive Gateway) ◇
• Dokładnie JEDNA ścieżka wybrana
• Rozgałęzienie: warunki wzajemnie wykluczające
• Scalenie: czeka na pierwszą (nie synchronizuje)
• Przykład: Decyzja tak/nie

AND (Parallel Gateway) ◇+
• WSZYSTKIE ścieżki aktywowane/wymagane
• Rozgałęzienie: równoległe wykonanie
• Scalenie: synchronizacja (czeka na wszystkie)
• Przykład: Równoległa weryfikacja dokumentów

OR (Inclusive Gateway) ◇○
• JEDNA LUB WIĘCEJ ścieżek
• Rozgałęzienie: aktywuje te, których warunki spełnione
• Scalenie: czeka na wszystkie aktywowane
• Przykład: Opcjonalne kroki procesu pyt11 ISA bpmn bramki + +Jakie są podstawowe sieciowe modele optymalizacji? 1. Najkrótsza ścieżka (Shortest Path)
min Σ cᵢⱼxᵢⱼ od s do t
Algorytmy: Dijkstra, Bellman-Ford, A*

2. Maksymalny przepływ (Max Flow)
max przepływ od źródła do ujścia
Ograniczenie: przepustowość krawędzi
Algorytmy: Ford-Fulkerson, Edmonds-Karp

3. Minimalny koszt przepływu (Min Cost Flow)
Połączenie: przepływ + koszt jednostkowy
Zastosowanie: transport, przydział zadań

4. Problem przydziału (Assignment)
n pracowników → n zadań, min koszt
Każdy pracownik = jedno zadanie
Algorytm: Metoda węgierska O(n³)

5. Problem komiwojażera (TSP)
Najkrótsza trasa przez wszystkie miasta
NP-trudny! pyt12 WSYZ optymalizacja sieciowa + +Czym różni się system agentowy od systemu aktorów? SYSTEM AGENTOWY
• Agent = autonomiczny, reaktywny, proaktywny, społeczny
• Architektura BDI (Beliefs-Desires-Intentions)
• Komunikacja: FIPA-ACL (semantyka, performatywy)
• Cel: symulacja, AI, negocjacje
• Przykład: JADE, Jason

SYSTEM AKTORÓW
• Aktor = lekka jednostka obliczeniowa
• Komunikacja: asynchroniczne wiadomości (fire-and-forget)
• Brak stanu współdzielonego (share nothing)
• Cel: współbieżność, skalowalność, fault-tolerance
• Przykład: Akka, Erlang/OTP

Kluczowa różnica:
Agent = inteligentny, autonomiczny, ma cele
Aktor = jednostka obliczeniowa, reaktywna, bez "inteligencji" pyt13 ISA agenty_aktorzy + +Co to jest architektura BDI w systemach agentowych? BDI = Beliefs-Desires-Intentions

Beliefs (Przekonania)
Co agent wie o świecie
Baza wiedzy, może być niepełna/błędna

Desires (Pragnienia)
Cele, które agent chce osiągnąć
Mogą być sprzeczne ze sobą

Intentions (Intencje)
Wybrane cele, do których agent się zobowiązał
Plany działania

Cykl decyzyjny:
1. Percepcja → aktualizuj Beliefs
2. Generuj opcje (desires)
3. Deliberacja → wybierz intentions
4. Wykonaj plan
5. Powtórz

Zastosowania: robotyka, symulacja zachowań, gry pyt13 ISA bdi agenty + +Jakie są algorytmy koordynacji w systemach wieloagentowych? 1. Contract Net Protocol (CNET)
Manager ogłasza zadanie → Agenty składają oferty → Wybór najlepszej
Zastosowanie: alokacja zadań

2. Aukcje wieloagentowe
• Angielska (rosnąca), holenderska (malejąca)
• Vickrey (druga cena) - zachęca do prawdziwych ofert
• Kombinatoryczne - pakiety zasobów

3. Protokoły konsensusu
Agenty uzgadniają wspólną wartość
ẋᵢ = Σⱼ aᵢⱼ(xⱼ - xᵢ) → zbieżność do średniej

4. Multi-Agent Reinforcement Learning
• Independent Q-learning
• Cooperative/Competitive
• Emergent behavior pyt14 ISA wieloagentowe koordynacja + +Co to jest framework TOGAF w modelowaniu architektury? TOGAF = The Open Group Architecture Framework

ADM (Architecture Development Method):
Cykliczny proces 8 faz:
1. Preliminary - przygotowanie
2. Vision - wizja architektury
3. Business Architecture - procesy biznesowe
4. IS Architecture - dane + aplikacje
5. Technology Architecture - infrastruktura
6. Opportunities & Solutions - planowanie migracji
7. Migration Planning - szczegółowy plan
8. Governance - zarządzanie zmianami

4 domeny architektury:
• Business, Data, Application, Technology (BDAT)

Praktyka: Standard korporacyjny, duże organizacje pyt15 ISA togaf architektura + +Porównaj wzorce architektoniczne: Layers, Microservices, Event-Driven. LAYERS (Warstwowa)
Prezentacja → Logika → Dane
✓ Prostota, separacja
✗ Monolityczna, trudna skalowalność

MICROSERVICES
Małe, niezależne serwisy
✓ Skalowalność, niezależny deployment
✓ Różne technologie
✗ Złożoność operacyjna, distributed transactions
Wymaga: API Gateway, Service Discovery

EVENT-DRIVEN (EDA)
Komponenty komunikują się przez zdarzenia
✓ Luźne powiązania, reaktywność
✓ Skalowalność, CQRS/Event Sourcing
✗ Trudne debugowanie, eventual consistency
Wymaga: Message Broker (Kafka, RabbitMQ)

Praktyka: Często łączone (microservices + events) pyt16 ISA wzorce_architektoniczne + +Jakie są warunki KKT w optymalizacji nieliniowej? KKT = Karush-Kuhn-Tucker

Dla problemu: min f(x), g(x) ≤ 0, h(x) = 0

Warunki konieczne optimum:

1. Stacjonarność:
∇f(x*) + Σμᵢ∇gᵢ(x*) + Σλⱼ∇hⱼ(x*) = 0

2. Dopuszczalność pierwotna:
g(x*) ≤ 0, h(x*) = 0

3. Dopuszczalność dualna:
μᵢ ≥ 0 (dla ograniczeń nierównościowych)

4. Complementary slackness:
μᵢ · gᵢ(x*) = 0 (aktywne lub μ=0)

Dla wypukłych: KKT są wystarczające!
Dla niewypukłych: tylko konieczne (lokalne opt.) pyt17 MOM kkt optymalizacja_nieliniowa + +Czym różni się metoda simpleks od interior point? METODA SIMPLEKS
• Porusza się po wierzchołkach wielościanu
• Iteracja: przejście do lepszego sąsiada
• Złożoność: O(2ⁿ) pesymistycznie
• W praktyce: bardzo szybka dla większości problemów
• Problemy zdegenerowane: cycling

INTERIOR POINT (bariery)
• Porusza się WEWNĄTRZ wielościanu
• Zbliża się do granicy przy optimum
• Złożoność: wielomianowa O(n³·L)
• Lepsza dla bardzo dużych problemów
• Wymaga więcej pamięci

Praktyka:
Simplex: małe/średnie LP, basis info
Interior Point: duże LP, QP, SDP pyt18 MOM simplex lp + +Jak działa parametryzacja MFCC w rozpoznawaniu mowy? MFCC = Mel-Frequency Cepstral Coefficients

Pipeline przetwarzania:
1. Pre-emphasis: y[n] = x[n] - αx[n-1] (wzmocnienie wysokich częstotliwości)
2. Ramkowanie: okna 20-40ms z overlap
3. FFT: spektrum częstotliwościowe
4. Mel filterbank: 26-40 filtrów w skali mel (nieliniowa, jak ucho)
5. Log: logarytm energii filtrów
6. DCT: 12-13 współczynników cepstralnych

Rozszerzenia:
• Δ (pierwsza pochodna) - dynamika
• ΔΔ (druga pochodna)
• Razem: 39 cech (13 + 13 + 13)

Dlaczego mel? Ucho słyszy nieliniowo - różnice w niskich częstotliwościach ważniejsze pyt19 RUM mfcc parametryzacja_mowy + +Porównaj HMM i Deep Learning w rozpoznawaniu mowy. HMM (Hidden Markov Model)
• Stany ukryte → emisje (GMM)
• Algorytmy: Viterbi, Forward-Backward, Baum-Welch
• Zalety: interpretowalność, mało danych
• Wady: założenie Markowa, ręczne features

DNN-HMM (Hybrid)
• DNN zastępuje GMM do modelowania emisji
• HMM nadal modeluje sekwencję
• Breakthrough: 2012 (Hinton et al.)

End-to-End Deep Learning
• CTC (Connectionist Temporal Classification)
• Attention/Transformer (Seq2Seq)
• Brak alignmentu, brak HMM
• Przykłady: DeepSpeech, Whisper

Praktyka 2024: Transformery dominują (Whisper, Wav2Vec) pyt20 RUM hmm deep_learning mowa + +Co to jest agent upostaciowiony (embodied agent)? Embodied Agent = agent z "ciałem" w fizycznym świecie

Różnica od agenta symulowanego:
• Interakcja z rzeczywistym środowiskiem
• Sensory: kamery, LIDAR, enkodery
• Efektory: silniki, chwytaki
• Niepewność: szum, opóźnienia, awarie

Architektura (typowa):
1. Percepcja: sensory → model świata
2. Planowanie: cel → sekwencja akcji
3. Wykonanie: akcje → efektory
4. Feedback: monitorowanie i korekta

Frameworki:
• ROS (Robot Operating System)
• BDI dla robotów (Jason + ROS)

Wyzwania:
• Real-time constraints
• Niepewność percepcji
• Bezpieczeństwo (safety-critical) pyt21 SIU embodied_agent roboty + +Jakie są poziomy języków programowania robotów? Hierarchia (od wysokiego do niskiego):

1. Task Level (najwyższy)
"Zmontuj produkt A" - planowanie zadań
AI, reasoning

2. Robot Level
Ruchy w przestrzeni kartezjańskiej
Ścieżki, trajektorie end-effector

3. Motion Level
Kinematyka, trajektorie stawów
Planowanie ruchu (RRT, A*)

4. Servo Level (najniższy)
Sterowanie silnikami
PID, kontrola pozycji/prędkości

Języki przemysłowe:
• RAPID (ABB)
• KRL (KUKA)
• Karel (FANUC)
• URScript (Universal Robots)

Standardy: IEC 61131-3 (PLC), ROS (research) pyt22 SIU jezyki_robotow programowanie + +Jak działają zegary logiczne Lamporta? Problem: Brak globalnego zegara w systemach rozproszonych

Algorytm:
Każdy proces Pᵢ ma licznik Cᵢ:
1. Przed zdarzeniem lokalnym: Cᵢ++
2. Wysyłanie msg: Cᵢ++, dołącz timestamp
3. Odbiór msg z timestamp t: Cᵢ = max(Cᵢ, t) + 1

Właściwości:
✓ a → b ⟹ C(a) < C(b) (porządek zachowany)
✗ C(a) < C(b) ⟹ a → b (NIE! mogą być współbieżne)

Zegary wektorowe:
Wektor V[1..N] dla N procesów
V[i] = wiedza procesu o wszystkich
a → b ⟺ V(a) < V(b) (obustronna implikacja!)

Zastosowanie: Causal ordering, wykrywanie współbieżności pyt23 ERSMS zegary_logiczne lamport + +Czym różni się linearizability od eventual consistency? LINEARIZABILITY (najsilniejsza)
• Operacja wygląda jakby wykonała się atomowo
• "Globalny porządek czasu rzeczywistego"
• Wynik natychmiast widoczny wszędzie
• Kosztowna: wymaga koordynacji (Paxos, Raft)
• Przykład: transakcje bankowe

EVENTUAL CONSISTENCY (najsłabsza)
• "Ostatecznie wszystkie repliki się zsynchronizują"
• Brak gwarancji kiedy
• Możliwe stare odczyty
• Wysoka dostępność (AP w CAP)
• Przykład: DNS, caching, social media feeds

Pomiędzy:
• Sequential: globalny porządek, nie real-time
• Causal: porządek przyczynowy zachowany pyt24 ERSMS spojnosc consistency + +Co to jest Branch and Bound i jak działa? Branch and Bound = metoda dokładna dla MIP

Idea:
1. Relaksacja LP: rozwiąż bez ograniczeń całkowitoliczbowych
2. Jeśli rozwiązanie całkowite → STOP
3. BRANCH: wybierz zmienną ułamkową xᵢ
4. Utwórz 2 podproblemy: xᵢ ≤ ⌊x*ᵢ⌋ i xᵢ ≥ ⌈x*ᵢ⌉
5. BOUND: jeśli LP ≤ best known → prune

Przycinanie (pruning):
• Infeasible: brak rozwiązania LP
• Optimality: LP ≤ incumbent
• Integrality: znalezione całkowite

Strategie wyboru węzła:
• Best-first (najlepsze ograniczenie)
• Depth-first (mniej pamięci)
• Best-estimate (heurystyka) pyt25 MOD branch_and_bound mip + +Jakie są główne narzędzia do optymalizacji dyskretnej? SOLVERY MIP (komercyjne):
• CPLEX (IBM) - najszybszy
• Gurobi - bardzo szybki, dobre API

SOLVERY MIP (open source):
• SCIP - framework rozszerzalny
• CBC (COIN-OR) - dobry darmowy
• HiGHS - nowoczesny

CONSTRAINT PROGRAMMING:
• CP-SAT (Google OR-Tools) - bardzo szybki
• Gecode - akademicki
• MiniZinc - język modelowania

JĘZYKI MODELOWANIA:
• Pyomo (Python)
• JuMP (Julia)
• AMPL, GAMS (komercyjne)

Kiedy CP vs MIP?
CP: scheduling, alldifferent, kombinatoryczne
MIP: silna relaksacja LP, ciągłe zmienne pyt26 MOD solvery narzedzia + +Dlaczego jakość modelu danych jest krytyczna? Model danych = fundament systemu
Zmiana modelu → kaskadowe zmiany wszędzie

Konsekwencje złego modelu:

1. Wydajność:
JOIN na stringach vs integer PK/FK
Brak indeksów, denormalizacja → full scans

2. Spójność:
Redundancja → anomalie (insert, update, delete)
Brak constraints → nieprawidłowe dane

3. Utrzymywalność:
Niezrozumiałe nazwy (col1, temp_field)
Brak dokumentacji ERD

4. Koszty naprawy:
Analiza: tanie
Design: średnie
Implementacja: drogie
Produkcja: BARDZO drogie (migracje!) pyt27 MODA model_danych jakosc + +Jakie są fazy ewolucji modelu danych? 1. KONCEPTUALNY (CDM)
• CO przechowujemy (biznes)
• Zrozumiały dla nietechnicznych
• Encje i relacje (brak atrybutów szczegółowych)
• ERD uproszczony

2. LOGICZNY (LDM)
• JAK strukturyzujemy
• Atrybuty, typy logiczne, klucze PK/FK
• Normalizacja (min 3NF)
• Niezależny od DBMS

3. FIZYCZNY (PDM)
• JAK implementujemy
• Typy danych specyficzne dla DBMS
• Indeksy, partycjonowanie, tablespaces
• Optymalizacja wydajności

Transformacja:
CDM → LDM: dodaj atrybuty, normalizuj
LDM → PDM: dostosuj do DBMS, zoptymalizuj pyt28 MODA fazy_modelu ewolucja + +Co mówi prawo Amdahla o przyśpieszeniu równoległym? Formuła Amdahla:
S(n) = 1 / [(1-p) + p/n]

Gdzie:
• p = część równoległa (0-1)
• n = liczba procesorów
• (1-p) = część sekwencyjna

Maksymalne przyśpieszenie (n→∞):
S_max = 1/(1-p)

Przykład:
90% równoległe (p=0.9):
S_max = 1/0.1 = 10x
Nawet z nieskończoną liczbą CPU!

Wniosek: Część sekwencyjna LIMITUJE przyśpieszenie

Prawo Gustafsona: Skaluj problem, nie przyśpieszenie
S_scaled = 1 - p + p·n (liniowe z n!) pyt29 PORR amdahl rownolegle + +Jakie są etapy tworzenia modelu optymalizacyjnego? 1. ANALIZA PROBLEMU
• Zrozum dziedzinę biznesową
• Zidentyfikuj decyzje, cele, ograniczenia

2. ZMIENNE DECYZYJNE
• Co kontrolujemy? (x, y, z...)
• Typy: ciągłe, całkowite, binarne
• Zmienne muszą być mierzalne i kontrolowalne

3. FUNKCJA CELU
• min/max f(x)
• Co optymalizujemy? (koszt, zysk, czas)

4. OGRANICZENIA
• g(x) ≤ 0, h(x) = 0
• Zasoby, fizyka, logika biznesowa

5. WALIDACJA
• Extreme cases
• Known solutions
• Analiza wrażliwości

Problemy: Big-M (słaba relaksacja), symetria pyt30 MOM modelowanie optymalizacja + +Dlaczego wypukłość jest ważna w optymalizacji? Problem wypukły:
• min f(x) gdzie f wypukła
• Ograniczenia definiują zbiór wypukły

Kluczowa właściwość:
LOKALNE optimum = GLOBALNE optimum

Konsekwencje:
1. Gwarancja znalezienia najlepszego rozwiązania
2. Algorytmy wielomianowe (interior point)
3. Silna dualność (zero gap)
4. KKT wystarczające (nie tylko konieczne)

Niewypukłe problemy:
• Wiele minimów lokalnych
• NP-trudne
• Tylko lokalne optimum (gradient, Newton)
• Metaheurystyki: SA, GA (bez gwarancji)

Praktyka: Przekształć w wypukły jeśli możliwe! pyt31 MOM wypuklosc optymalizacja + +Różnica między komunikacją blokującą a nieblokującą w MPI. BLOKUJĄCA
• MPI_Send, MPI_Recv
• Zwraca gdy operacja "zakończona"
• Bufor można bezpiecznie użyć ponownie
• Ryzyko deadlocka przy złej kolejności

NIEBLOKUJĄCA
• MPI_Isend, MPI_Irecv
• Zwraca natychmiast (request handle)
• Operacja w tle
• MPI_Wait/MPI_Test do sprawdzenia
• Overlapping: obliczenia + komunikacja

Deadlock example:
P0: Send(to=1); Recv(from=1);
P1: Send(to=0); Recv(from=0);
→ Oba czekają na recv, nikt nie wysyła

Rozwiązanie: MPI_Sendrecv lub nieblokujące pyt32 PORR mpi blokujace + +Jak działa model Publish-Subscribe? Architektura:
PUBLISHERS → BROKER → SUBSCRIBERS

Cechy:
• Luźne powiązanie (publisher nie zna subscriberów)
• Asynchroniczność
• Skalowalność 1:N, N:M

Typy subskrypcji:
• Topic-based: subscribe("orders")
• Content-based: price > 100
• Hierarchical: home/+/temperature (wildcards)

QoS (Quality of Service):
• QoS 0: at most once (fire-and-forget)
• QoS 1: at least once (możliwe duplikaty)
• QoS 2: exactly once (4-way handshake)

Implementacje:
• Apache Kafka (log-based, high throughput)
• RabbitMQ (AMQP, flexible routing)
• MQTT (IoT, lightweight) pyt33 PSD pub_sub messaging + +Czym charakteryzuje się przetwarzanie danych strumieniowych? Strumień vs Batch:
• Unbounded (nieskończony)
• Ciągłe napływanie danych
• Wymagana niska latencja
• Brak możliwości przechowania wszystkiego

Windowing (okna czasowe):
• Tumbling: rozłączne, stała wielkość
• Sliding: nakładające się
• Session: oparte na aktywności
• Global: jedno okno, trigger decyduje

Event Time vs Processing Time:
• Event time: kiedy zdarzenie nastąpiło
• Processing time: kiedy dotarło
• Watermark: znacznik postępu event time

Platformy:
• Apache Flink (stateful, exactly-once)
• Kafka Streams (library, Kafka ecosystem)
• Apache Spark Streaming (micro-batch) pyt34 PSD streaming analityka + +Co to są systemy cyber-fizyczne (CPS)? CPS = Cyber + Physical w pętli sprzężenia

Komponenty:
• Cyber: obliczenia, komunikacja, sterowanie
• Physical: dynamika, fizyka, środowisko
• Sensors + Actuators = połączenie

Specyfika modelowania:
• Hybrid systems: ciągłe ODE + dyskretne automaty
• Real-time constraints
• Niepewność, szum, opóźnienia

Przykład - termostat:
Mode OFF: Ṫ = -α(T-Tₑ)
Mode ON: Ṫ = β - α(T-Tₑ)
Przełączanie: TTₕ → OFF

Consensus w sieci agentów:
ẋᵢ = Σⱼ aᵢⱼ(xⱼ - xᵢ) → zbieżność do średniej

Przykłady: autonomiczne pojazdy, smart grid, Industry 4.0 pyt35 SIU cps cyber_fizyczne + +Jakie są elementy uczenia ze wzmocnieniem? Model RL:
Agent ↔ Environment
Agent: akcja aₜ → Environment
Environment: stan sₜ₊₁, nagroda rₜ → Agent

Elementy:
• State (s): obserwacja środowiska
• Action (a): decyzja agenta
• Reward (r): sygnał zwrotny
• Policy π(a|s): strategia
• Value V(s), Q(s,a): oczekiwana nagroda
• Discount γ: ważność przyszłych nagród

MDP (Markov Decision Process):
P(sₜ₊₁|sₜ,aₜ) - tylko obecny stan ma znaczenie

Algorytmy:
• Value-based: Q-learning, DQN
• Policy-based: REINFORCE, PPO
• Actor-Critic: A2C, A3C, SAC

Cel: max E[Σ γᵗrₜ] pyt36 SIU rl uczenie_wzmocnienie + +Porównaj modele sieci złożonych: ER, Watts-Strogatz, Barabási-Albert. ERDŐS-RÉNYI (Random)
G(n,p) - krawędź z prawdop. p
• Rozkład stopni: Poisson
• Niski clustering C=p
• Krótka ścieżka L~log(n)
• Brak hubów

WATTS-STROGATZ (Small-World)
Regularna kratka + losowe przepinanie
• Wysoki clustering (zachowany)
• Krótka ścieżka (dodana)
• "6 degrees of separation"

BARABÁSI-ALBERT (Scale-Free)
Preferential attachment (rich-get-richer)
• Rozkład: power-law P(k)~k⁻ᵞ
• Huby (węzły o bardzo wysokim stopniu)
• Odporność na losowe awarie
• Wrażliwość na celowane ataki

Rzeczywiste sieci: cechy BA + WS (huby + clustering) pyt37 TASS sieci_zlozone modele + +Co to jest projekcja grafu dwudzielnego? Graf dwudzielny:
Dwa rozłączne zbiory U, V
Krawędzie tylko między U i V
Przykład: dokumenty ↔ słowa

Projekcja:
Przekształcenie na graf jednomodowy
P = B·Bᵀ (projekcja na U)
Węzły U połączone jeśli mają wspólnego sąsiada w V

Metody ważenia krawędzi:
• Simple count: |N(i) ∩ N(j)|
• Jaccard: |∩| / |∪|
• Cosine: dot product / normy
• TF-IDF: rzadkie słowa ważniejsze

Zastosowanie - grupowanie dokumentów:
1. Graf: dokumenty ↔ słowa
2. TF-IDF weights
3. Projekcja na dokumenty
4. Clustering na projekcji pyt38 TASS projekcje grafy_dwudzielne + +Jakie są metody segmentacji obrazu? KLASYCZNE:

1. Thresholding: Otsu (automatyczny próg)
2. Region Growing: seed → ekspansja po podobnych
3. Watershed: obraz jako topografia, zalewanie
4. Graph-based: Normalized Cuts, Laplacian

DEEP LEARNING:

1. FCN (Fully Convolutional):
Brak FC layers → dowolny rozmiar wejścia

2. U-Net:
Encoder-decoder + skip connections
Świetne dla małych datasetów (medycyna)

3. DeepLab:
Atrous/dilated convolutions
ASPP (multi-scale)

Typy segmentacji:
• Semantic: klasa dla piksela
• Instance: rozróżnia instancje
• Panoptic: unified (semantic + instance) pyt39 TWM segmentacja cv + +Jak działa detekcja obiektów (klasyczne vs deep learning)? KLASYCZNE:

1. Sliding Window + HOG/SIFT:
Przesuwaj okno, klasyfikuj fragment
Problem: O(scales × positions) - WOLNE

2. Viola-Jones (2001):
Haar features + AdaBoost cascade
Integral image → O(1) per feature
Real-time face detection

DEEP LEARNING:

1. Two-stage (R-CNN family):
Region proposals → CNN → classify
Faster R-CNN: RPN (learned proposals)

2. One-stage:
YOLO: grid cells, predict directly
SSD: multi-scale feature maps
Szybsze, mniej dokładne

Metryki: mAP (mean Average Precision), IoU pyt40 TWM detekcja_obiektow cv + +Co to jest dominacja stochastyczna pierwszego i drugiego rzędu? FSD (First-order Stochastic Dominance):
A ≥_FSD B ⟺ F_A(x) ≤ F_B(x) dla wszystkich x

• A "zawsze lepsze" od B
• KAŻDY racjonalny decydent (U'≥0) wybierze A
• Najsilniejsza, rzadko występuje

SSD (Second-order):
A ≥_SSD B ⟺ ∫F_A(t)dt ≤ ∫F_B(t)dt dla wszystkich x

• Dla decydentów risk-averse (U'≥0, U''≤0)
• Słabsza niż FSD, częstsza
• CDF mogą się przecinać, ale skumulowane pole - nie

Zastosowanie:
Porównanie portfeli/loterii BEZ znajomości dokładnej funkcji użyteczności
FSD/SSD → eliminacja zdominowanych opcji pyt42 WDWR dominacja_stochastyczna + +Jak klasyfikuje się zadania szeregowania (notacja Grahama)? Notacja: α | β | γ

α - Środowisko maszynowe:
• 1: jedna maszyna
• Pm: m maszyn równoległych
• Fm: flow shop z m maszynami
• Jm: job shop z m maszynami

β - Charakterystyki zadań:
• rⱼ: release dates
• dⱼ: due dates
• prec: precedence constraints
• pmtn: preemption allowed
• pⱼ=1: unit processing times

γ - Kryterium:
• Cmax: makespan (max completion)
• ΣCⱼ: total completion time
• Lmax: max lateness
• ΣTⱼ: total tardiness

Przykład: 1|rⱼ|Lmax - jedna maszyna, release dates, minimalizuj max spóźnienie pyt43 ZBOP szeregowanie scheduling + +Co to jest efekt byczego bicza (bullwhip effect)? Bullwhip Effect = amplifikacja wahań popytu w górę łańcucha dostaw

Mechanizm:
Mały popyt klienta → większe wahania detalisty → jeszcze większe dystrybutora → ogromne u producenta

Przyczyny:
1. Prognozowanie popytu (każdy poziom dodaje safety stock)
2. Batching zamówień (nie zamawiaj po 1 sztuce)
3. Wahania cen (promocje → stockpiling)
4. Rationing (przy niedoborze zawyżanie zamówień)

Konsekwencje:
• Nadmiar zapasów lub stockouts
• Nieefektywna produkcja
• Wysokie koszty

Rozwiązania:
• Współdzielenie informacji (VMI, CPFR)
• Everyday Low Price (brak promocji)
• Smaller batches pyt44 ZBOP bullwhip lancuch_dostaw + +Co to jest model EOQ i jakie ma założenia? EOQ = Economic Order Quantity

Formuła:
Q* = √(2KD/h)

Gdzie:
• K = koszt zamówienia (stały)
• D = roczny popyt
• h = koszt utrzymania jednostki/rok

Założenia:
• Popyt stały i znany
• Lead time stały i znany
• Natychmiastowa dostawa
• Brak braków (stockouts)
• Brak rabatów ilościowych

Całkowity koszt:
TC = (K × D/Q) + (h × Q/2)
Ordering cost + Holding cost

W praktyce: Punkt bazowy, modyfikowany dla:
• Losowy popyt → safety stock
• Lead time → reorder point
• Rabaty → quantity discounts model pyt44 ZBOP eoq zapasy + diff --git a/pytania/generate_anki.py b/pytania/generate_anki.py new file mode 100644 index 0000000..4114731 --- /dev/null +++ b/pytania/generate_anki.py @@ -0,0 +1,185 @@ +#!/usr/bin/env python3 +""" +Generate Anki flashcards from exam questions in odpowiedzi/ folder. +Creates a tab-separated file compatible with Anki import. +""" + +import os +import re +from pathlib import Path + +def extract_question_and_answer(filepath): + """Extract main question and key answer points from a markdown file.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + + # Extract file number for tagging + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + if match: + num = match.group(1) + topic = match.group(2).replace('-', '_') + else: + num = "00" + topic = "unknown" + + # Extract main title (usually contains the question) + title_match = re.search(r'^# (.+)$', content, re.MULTILINE) + title = title_match.group(1) if title_match else "Unknown" + + # Extract the main question from ## Pytanie section + question_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if question_match: + main_question = question_match.group(1).strip() + main_question = re.sub(r'\s+', ' ', main_question) + else: + main_question = title + + # Extract subject/przedmiot + subject_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subject_match.group(1) if subject_match else "Ogólne" + + # Create main question card - extract key sections for answer + answer_parts = [] + + # Look for main answer section + main_answer = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\n---\s*\n## |\Z)', content, re.DOTALL) + if main_answer: + answer_text = main_answer.group(1) + # Extract key points, definitions, headers + headers = re.findall(r'### (.+)', answer_text) + for h in headers[:5]: # Limit to first 5 headers + answer_parts.append(f"• {h}") + + # Also extract key definitions if present + definitions = re.findall(r'\*\*([^*]+)\*\*\s*[-–:]\s*([^*\n]+)', content) + for term, definition in definitions[:3]: + if len(definition) > 20 and len(definition) < 200: + answer_parts.append(f"• {term}: {definition.strip()}") + + # If we found answer parts, create main card + if answer_parts: + answer_html = "
".join(answer_parts[:8]) # Limit answer length + cards.append({ + 'question': main_question, + 'answer': answer_html, + 'tags': f"egzamin_magisterski pytanie_{num} {subject} {topic}" + }) + + # Extract sub-questions and key concepts as additional cards + # Look for ### headers with explanations + subsections = re.findall(r'### (\d+\.\s+)?(.+?)\n\n(.+?)(?=\n### |\n## |\n---|\Z)', content, re.DOTALL) + + for _, header, body in subsections: + if len(header) < 5 or header.startswith('Przykład'): + continue + + # Extract first substantive paragraph or key points + body_clean = body.strip() + + # Skip very short or code-only sections + if len(body_clean) < 50: + continue + + # Extract bullet points or first paragraph + bullets = re.findall(r'[-•]\s*\*\*(.+?)\*\*[:\s]*([^\n]+)?', body_clean) + if bullets: + answer_text = "
".join([f"• {b[0]}: {b[1].strip()}" if b[1] else f"• {b[0]}" for b in bullets[:5]]) + else: + # Get first meaningful paragraph + paragraphs = [p.strip() for p in body_clean.split('\n\n') if p.strip() and not p.startswith('```') and not p.startswith('|')] + if paragraphs: + first_para = paragraphs[0] + # Clean markdown + first_para = re.sub(r'\*\*(.+?)\*\*', r'\1', first_para) + first_para = re.sub(r'\*(.+?)\*', r'\1', first_para) + answer_text = first_para[:400] + else: + continue + + # Create sub-concept card + sub_question = f"Co to jest {header}?" if not header.endswith('?') else header + if "Charakterystyka" in header or "Definicja" in header or "Właściwości" in header: + # These are answer-type headers, reframe + parent_topic = title.replace("Pytanie", "").strip(": 0123456789") + sub_question = f"{header} - {parent_topic}" + + cards.append({ + 'question': sub_question, + 'answer': answer_text, + 'tags': f"egzamin_magisterski pytanie_{num} {subject} {topic} szczegoly" + }) + + # Extract key formulas/definitions as separate cards + formulas = re.findall(r'\*\*([A-Za-z\s]+(?:formuła|wzór|twierdzenie|definicja|lemat))\*\*[:\s]*\n?(.+?)(?=\n\n|\n\*\*|\Z)', content, re.IGNORECASE | re.DOTALL) + for formula_name, formula_content in formulas: + if len(formula_content) > 20: + cards.append({ + 'question': f"Podaj {formula_name.strip()}", + 'answer': formula_content.strip()[:300], + 'tags': f"egzamin_magisterski pytanie_{num} {subject} formuly" + }) + + return cards + +def clean_for_anki(text): + """Clean text for Anki import - escape special characters.""" + # Replace tabs with spaces + text = text.replace('\t', ' ') + # Convert markdown formatting to HTML + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'\*(.+?)\*', r'\1', text) + # Handle newlines - convert to
for Anki + text = text.replace('\n', '
') + # Remove multiple
+ text = re.sub(r'(
)+', '
', text) + # Remove leading/trailing
+ text = re.sub(r'^
|
$', '', text) + # Escape quotes in a way that works with tab-separated + text = text.replace('"', '"') + return text.strip() + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_egzamin_magisterski.txt") + + all_cards = [] + + # Process each file + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + print(f"Processing: {md_file.name}") + try: + cards = extract_question_and_answer(md_file) + all_cards.extend(cards) + print(f" -> Extracted {len(cards)} cards") + except Exception as e: + print(f" -> Error: {e}") + + # Write Anki file with headers + with open(output_file, 'w', encoding='utf-8') as f: + # Anki file headers + f.write("#separator:tab\n") + f.write("#html:true\n") + f.write("#columns:Front\tBack\tTags\n") + f.write("#deck:Egzamin Magisterski ISY\n") + f.write("#notetype:Basic\n") + f.write("\n") + + for card in all_cards: + front = clean_for_anki(card['question']) + back = clean_for_anki(card['answer']) + tags = card['tags'] + f.write(f"{front}\t{back}\t{tags}\n") + + print(f"\n✅ Created {len(all_cards)} flashcards") + print(f"📁 Output: {output_file}") + print("\nTo import into Anki:") + print("1. Open Anki → File → Import") + print("2. Select the .txt file") + print("3. Verify 'Allow HTML' is checked") + print("4. Click Import") + +if __name__ == "__main__": + main() diff --git a/pytania/generate_anki_final.py b/pytania/generate_anki_final.py new file mode 100644 index 0000000..283b6d3 --- /dev/null +++ b/pytania/generate_anki_final.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +""" +Generate comprehensive Anki flashcards from exam questions. +Creates tab-separated file for Anki import with proper HTML formatting. +""" + +import os +import re +from pathlib import Path + +def clean_text(text): + """Clean and format text for Anki.""" + if not text: + return "" + + # Convert markdown formatting to HTML + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'(?\1', text) + + # Handle special characters + text = text.replace('\t', ' ') + text = text.replace('"', '"') + + # Clean up whitespace but preserve intentional line breaks + text = re.sub(r' +', ' ', text) + text = text.strip() + + return text + +def format_list(items, numbered=False): + """Format a list of items as HTML.""" + if not items: + return "" + + tag = "ol" if numbered else "ul" + html = f"<{tag}>" + for item in items: + cleaned = clean_text(item) + if cleaned: + html += f"
  • {cleaned}
    • " + html += f"" + return html + +def extract_from_file(filepath): + """Extract flashcard data from a markdown file.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + + # Get file metadata + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + num = match.group(1) if match else "00" + topic_slug = match.group(2).replace('-', '_') if match else "unknown" + + # Extract subject + subj_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subj_match.group(1) if subj_match else "Ogólne" + + # Base tags + base_tags = f"egzamin_magisterski pyt{num} {subject}" + + # ===================================================== + # CARD TYPE 1: Main Exam Question + # ===================================================== + q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if q_match: + main_q = re.sub(r'\s+', ' ', q_match.group(1).strip()) + + # Extract key topics from main answer + answer_match = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [�🎯]|\n---\s*\n## |\Z)', content, re.DOTALL) + if answer_match: + answer_section = answer_match.group(1) + # Get main headers + headers = re.findall(r'^### (?:\d+\.\s*)?(.+)$', answer_section, re.MULTILINE) + headers = [h.strip() for h in headers if len(h.strip()) > 3][:6] + + if headers: + answer_html = "Kluczowe zagadnienia:" + format_list(headers) + cards.append({ + 'front': clean_text(main_q), + 'back': answer_html, + 'tags': f"{base_tags} pytanie_glowne" + }) + + # ===================================================== + # CARD TYPE 2: Subsection Cards (detailed concepts) + # ===================================================== + # Find all ### sections + sections = re.findall( + r'^### (?:\d+\.\s*)?(.+?)\n((?:(?!^###).)+)', + content, + re.MULTILINE | re.DOTALL + ) + + for header, body in sections: + header = header.strip() + body = body.strip() + + # Skip very short sections or example sections + if len(body) < 50 or header.lower().startswith('przykład'): + continue + + # Extract key information from body + answer_parts = [] + + # Look for #### sub-headers + subheaders = re.findall(r'^#### (.+)$', body, re.MULTILINE) + if subheaders: + answer_parts.extend(subheaders[:4]) + + # Look for bullet points with bold terms + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]+)?', body) + for term, desc in bullets[:5]: + if desc: + answer_parts.append(f"{term}: {desc.strip()}") + else: + answer_parts.append(f"{term}") + + # If no structured content, get first paragraph + if not answer_parts: + paras = [p.strip() for p in body.split('\n\n') + if p.strip() and not p.strip().startswith('```') + and not p.strip().startswith('|')] + if paras: + first = paras[0] + # Limit length + if len(first) > 300: + first = first[:300] + "..." + answer_parts.append(first) + + if answer_parts: + # Determine card type + if "Definicja" in header or "Co to" in header: + q = f"Co to jest: {header.replace('Definicja', '').strip()}?" + elif "Charakterystyka" in header: + q = f"Scharakteryzuj: {header.replace('Charakterystyka', '').strip()}" + elif header.endswith('?'): + q = header + else: + q = f"Omów: {header}" + + # Format answer + if len(answer_parts) > 1: + answer_html = format_list(answer_parts) + else: + answer_html = clean_text(answer_parts[0]) + + cards.append({ + 'front': clean_text(q), + 'back': answer_html, + 'tags': f"{base_tags} szczegoly" + }) + + # ===================================================== + # CARD TYPE 3: Algorithms/Formulas + # ===================================================== + algo_patterns = [ + r'#### Złożoność(?:\s+czasowa)?\s*\n(.+?)(?=\n####|\n###|\Z)', + r'Złożoność:\s*\*\*([^*]+)\*\*', + ] + + for pattern in algo_patterns: + matches = re.findall(pattern, content, re.DOTALL) + for match in matches[:2]: + if len(match) > 10: + # Find context - which algorithm? + algo_context = re.search(r'### (\d+\.\s*)?(.+?)(?=\n)', content[:content.find(match)]) + if algo_context: + algo_name = algo_context.group(2).strip() + cards.append({ + 'front': f"Jaka jest złożoność algorytmu/metody: {algo_name}?", + 'back': clean_text(match.strip()[:200]), + 'tags': f"{base_tags} zlozonosc" + }) + break + + # ===================================================== + # CARD TYPE 4: Comparisons (when file contains comparisons) + # ===================================================== + compare_match = re.search(r'## .*(Porównanie|Zestawienie|vs).*\n(.+?)(?=\n## |\Z)', content, re.DOTALL | re.IGNORECASE) + if compare_match: + compare_section = compare_match.group(2) + # Extract comparison items + items = re.findall(r'\|\s*\*\*([^|*]+)\*\*\s*\|([^|]+)\|', compare_section) + if items: + comparison_html = "" + for aspect, value in items[:6]: + comparison_html += f"" + comparison_html += "
    AspektWartość
    {clean_text(aspect)}{clean_text(value)}
    " + + # Get comparison title + title_match = re.search(r'## .*(Porównanie|Zestawienie).*?(\w+.*?(?:vs|i|oraz).*?\w+)', compare_match.group(0), re.IGNORECASE) + if title_match: + cards.append({ + 'front': f"Porównaj kluczowe różnice w temacie: pytanie {num}", + 'back': comparison_html, + 'tags': f"{base_tags} porownanie" + }) + + # ===================================================== + # CARD TYPE 5: Q&A from practice questions section + # ===================================================== + qa_section = re.search(r'## 🎓 Pytania.*?\n(.+?)(?=\n## |\Z)', content, re.DOTALL) + if qa_section: + qa_content = qa_section.group(1) + # Find Q&A pairs + qas = re.findall(r'### Q\d+:?\s*["\']?(.+?)["\']?\s*\n.*?Odpowiedź:\s*\n?(.+?)(?=\n### |\Z)', qa_content, re.DOTALL) + for q, a in qas[:3]: + q = re.sub(r'\s+', ' ', q.strip()) + a = a.strip() + if len(a) > 30: + # Limit answer length + a_lines = a.split('\n') + a_short = '\n'.join(a_lines[:5]) + if len(a_short) > 400: + a_short = a_short[:400] + "..." + + cards.append({ + 'front': clean_text(q), + 'back': clean_text(a_short).replace('\n', '
    '), + 'tags': f"{base_tags} egzamin_praktyka" + }) + + return cards + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_egzamin_magisterski.txt") + + all_cards = [] + + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + print(f"Processing: {md_file.name}", end=" ") + try: + cards = extract_from_file(md_file) + all_cards.extend(cards) + print(f"→ {len(cards)} cards") + except Exception as e: + print(f"→ ERROR: {e}") + + # Remove potential duplicates (same front) + seen = set() + unique_cards = [] + for card in all_cards: + if card['front'] not in seen: + seen.add(card['front']) + unique_cards.append(card) + + # Write output file + with open(output_file, 'w', encoding='utf-8') as f: + # Anki headers + f.write("#separator:tab\n") + f.write("#html:true\n") + f.write("#tags column:3\n") + f.write("#deck:Egzamin Magisterski ISY\n") + f.write("#notetype:Basic\n") + f.write("\n") + + for card in unique_cards: + # Ensure no tabs in content (would break parsing) + front = card['front'].replace('\t', ' ') + back = card['back'].replace('\t', ' ') + tags = card['tags'] + + f.write(f"{front}\t{back}\t{tags}\n") + + print(f"\n{'='*50}") + print(f"✅ Generated {len(unique_cards)} unique flashcards") + print(f"📁 Saved to: {output_file}") + print(f"{'='*50}") + print("\n📋 IMPORT INSTRUCTIONS:") + print("─" * 40) + print("Anki Desktop:") + print(" 1. File → Import") + print(" 2. Select: anki_egzamin_magisterski.txt") + print(" 3. Verify: Fields separated by Tab") + print(" 4. Check: Allow HTML in fields") + print(" 5. Click Import") + print() + print("AnkiWeb / AnkiDroid:") + print(" 1. First import on Anki Desktop") + print(" 2. Click Sync to upload to AnkiWeb") + print(" 3. Sync on mobile to download") + +if __name__ == "__main__": + main() diff --git a/pytania/generate_anki_v2.py b/pytania/generate_anki_v2.py new file mode 100644 index 0000000..8d6c6ba --- /dev/null +++ b/pytania/generate_anki_v2.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +""" +Generate Anki flashcards from exam questions in odpowiedzi/ folder. +Creates a tab-separated file compatible with Anki import. +""" + +import os +import re +from pathlib import Path + +def extract_main_question(content, filename): + """Extract the main exam question from the file.""" + # Extract the main question from ## Pytanie section + question_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + if question_match: + main_question = question_match.group(1).strip() + main_question = re.sub(r'\s+', ' ', main_question) + return main_question + + # Fallback to title + title_match = re.search(r'^# (.+)$', content, re.MULTILINE) + return title_match.group(1) if title_match else filename + +def extract_subject(content): + """Extract the subject code.""" + subject_match = re.search(r'Przedmiot:\s*(\w+)', content) + return subject_match.group(1) if subject_match else "Ogólne" + +def extract_key_points(content): + """Extract key points from the main answer section.""" + points = [] + + # Look for main answer section + main_answer = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## [^�]|\n---\s*\n## |\Z)', content, re.DOTALL) + if not main_answer: + return points + + answer_text = main_answer.group(1) + + # Extract ### headers as key points + headers = re.findall(r'^### (.+)$', answer_text, re.MULTILINE) + for h in headers[:6]: + # Clean header + h = re.sub(r'\d+\.\s*', '', h).strip() + if h and len(h) > 3: + points.append(h) + + return points + +def extract_definitions(content): + """Extract key definitions from the content.""" + definitions = [] + + # Pattern for **Term** - definition or **Term**: definition + pattern = r'\*\*([^*\n]+)\*\*\s*[-–:]\s*([^*\n]{20,150})' + matches = re.findall(pattern, content) + + for term, definition in matches: + term = term.strip() + definition = definition.strip() + # Filter out non-definition patterns + if term and definition and not term.startswith('Przykład') and not term.startswith('Uwaga'): + definitions.append((term, definition)) + + return definitions[:5] + +def clean_html(text): + """Convert markdown to HTML and clean for Anki.""" + if not text: + return "" + + # Replace markdown bold/italic with HTML + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'\*(.+?)\*', r'\1', text) + + # Clean up special characters + text = text.replace('\t', ' ') + text = text.replace('"', '"') + + # Handle newlines - convert to
    + text = text.replace('\n', ' ') + text = re.sub(r'\s+', ' ', text) + + return text.strip() + +def process_file(filepath): + """Process a single file and return flashcards.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + + # Extract metadata + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + if match: + num = match.group(1) + topic = match.group(2).replace('-', '_') + else: + num = "00" + topic = "unknown" + + subject = extract_subject(content) + main_question = extract_main_question(content, filename) + + # Base tags for this question + base_tags = f"egzamin_magisterski pytanie_{num} {subject}" + + # Card 1: Main question with key points + key_points = extract_key_points(content) + if key_points: + answer = "
      " + "".join([f"
    • {clean_html(p)}
      • " for p in key_points]) + "
    " + cards.append({ + 'front': clean_html(main_question), + 'back': answer, + 'tags': base_tags + }) + + # Card 2+: Key definitions as individual cards + definitions = extract_definitions(content) + for term, definition in definitions: + q = f"Definicja: {term}" + a = clean_html(definition) + cards.append({ + 'front': q, + 'back': a, + 'tags': f"{base_tags} definicje" + }) + + return cards + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_egzamin_magisterski.txt") + + all_cards = [] + + # Process each file + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + print(f"Processing: {md_file.name}") + try: + cards = process_file(md_file) + all_cards.extend(cards) + print(f" -> {len(cards)} cards") + except Exception as e: + print(f" -> Error: {e}") + import traceback + traceback.print_exc() + + # Write Anki-compatible file + with open(output_file, 'w', encoding='utf-8') as f: + # File headers for Anki + f.write("#separator:tab\n") + f.write("#html:true\n") + f.write("#tags column:3\n") + f.write("#deck:Egzamin Magisterski ISY\n") + f.write("#notetype:Basic\n") + f.write("\n") + + for card in all_cards: + front = card['front'] + back = card['back'] + tags = card['tags'] + + # Ensure no tabs in content + front = front.replace('\t', ' ') + back = back.replace('\t', ' ') + + f.write(f"{front}\t{back}\t{tags}\n") + + print(f"\n✅ Created {len(all_cards)} flashcards") + print(f"📁 Output: {output_file}") + print("\n=== Import Instructions ===") + print("1. Open Anki desktop → File → Import") + print("2. Select: anki_egzamin_magisterski.txt") + print("3. Set 'Fields separated by: Tab'") + print("4. Check 'Allow HTML in fields'") + print("5. Map: Field 1 → Front, Field 2 → Back, Field 3 → Tags") + print("6. Click Import") + print("\nFor AnkiWeb/AnkiDroid: Sync after importing on desktop") + +if __name__ == "__main__": + main() diff --git a/pytania/generate_anki_v3.py b/pytania/generate_anki_v3.py new file mode 100644 index 0000000..ecc32d1 --- /dev/null +++ b/pytania/generate_anki_v3.py @@ -0,0 +1,257 @@ +#!/usr/bin/env python3 +""" +Generate Anki flashcards with ACTUAL substantive answers, not just headers. +""" + +import os +import re +from pathlib import Path + +def clean_text(text): + """Clean text for Anki.""" + if not text: + return "" + text = re.sub(r'\*\*(.+?)\*\*', r'\1', text) + text = re.sub(r'(?\1', text) + text = text.replace('\t', ' ') + text = text.replace('"', '"') + text = re.sub(r' +', ' ', text) + return text.strip() + +def extract_real_answer(content, section_name): + """Extract actual content from a section, not just headers.""" + # Find the section + pattern = rf'### (?:\d+\.\s*)?{re.escape(section_name)}\s*\n((?:(?!^### ).)+)' + match = re.search(pattern, content, re.MULTILINE | re.DOTALL) + if not match: + return None + + body = match.group(1).strip() + + # Extract meaningful content + lines = [] + + # Get subheaders with their first line of content + subheader_pattern = r'#### ([^\n]+)\n([^\n#]+)' + for sub_header, first_line in re.findall(subheader_pattern, body): + lines.append(f"{sub_header.strip()}: {first_line.strip()}") + + # Get bullet points + bullet_pattern = r'[-•]\s*\*\*([^*]+)\*\*[:\s-]*([^\n]*)' + for term, desc in re.findall(bullet_pattern, body): + if desc.strip(): + lines.append(f"• {term.strip()}: {desc.strip()}") + else: + lines.append(f"• {term.strip()}") + + # If no structured content, get paragraphs + if not lines: + paras = [p.strip() for p in body.split('\n\n') + if p.strip() and not p.startswith('```') and not p.startswith('|')] + for p in paras[:2]: + if len(p) > 20 and len(p) < 400: + lines.append(p) + + return '
    '.join(lines[:6]) if lines else None + +def extract_cards(filepath): + """Extract flashcards from a file.""" + with open(filepath, 'r', encoding='utf-8') as f: + content = f.read() + + cards = [] + filename = os.path.basename(filepath) + match = re.match(r'(\d+)-(.+)\.md', filename) + num = match.group(1) if match else "00" + + subj_match = re.search(r'Przedmiot:\s*(\w+)', content) + subject = subj_match.group(1) if subj_match else "Ogólne" + base_tags = f"egzamin_magisterski pyt{num} {subject}" + + # Get main question + q_match = re.search(r'## Pytanie\s*\n\s*\*\*["\']?(.+?)["\']?\*\*', content, re.DOTALL) + main_question = re.sub(r'\s+', ' ', q_match.group(1).strip()) if q_match else None + + # =============================================== + # MAIN CARD: Question with REAL answer summary + # =============================================== + if main_question: + # Build a real answer from the main sections + answer_parts = [] + + # For automata question - extract key facts about each automaton + if "automat" in main_question.lower() or "maszyn" in main_question.lower(): + # FA + fa_match = re.search(r'Automat Skończony.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*', content, re.DOTALL) + if fa_match: + answer_parts.append(f"Automat Skończony (FA): {fa_match.group(1).strip()}") + + # PDA + pda_match = re.search(r'Automat ze Stosem.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*', content, re.DOTALL) + if pda_match: + answer_parts.append(f"Automat ze Stosem (PDA): {pda_match.group(1).strip()}") + + # TM + tm_match = re.search(r'Maszyna Turinga.*?Rozpoznawana klasa języków\s*\n\s*\*\*([^*]+)\*\*', content, re.DOTALL) + if tm_match: + answer_parts.append(f"Maszyna Turinga (TM): {tm_match.group(1).strip()}") + + # Generic extraction if specific didn't work + if not answer_parts: + # Look for key definitions/summaries + key_patterns = [ + r'#### Definicja\s*\n([^\n#]+)', + r'#### Charakterystyka\s*\n([^\n#]+)', + r'\*\*Definicja[:\s]*\*\*\s*([^\n]+)', + ] + for pattern in key_patterns: + for match in re.findall(pattern, content)[:3]: + if len(match) > 20: + answer_parts.append(match.strip()) + + # Still nothing? Get first substantive paragraph from main answer + if not answer_parts: + main_answer = re.search(r'## 📚 Odpowiedź główna\s*\n(.+?)(?=\n## |\Z)', content, re.DOTALL) + if main_answer: + # Skip headers, get actual content + text = main_answer.group(1) + paras = re.findall(r'\n\n([^#\n][^\n]{50,300})', text) + answer_parts = paras[:3] + + if answer_parts: + answer = '

    '.join([clean_text(p) for p in answer_parts]) + cards.append({ + 'front': clean_text(main_question), + 'back': answer, + 'tags': f"{base_tags} pytanie_glowne" + }) + + # =============================================== + # CONCEPT CARDS: Specific topics with real content + # =============================================== + # Find all ### sections and extract their actual content + sections = re.findall( + r'^### (?:\d+\.\s*)?([^\n]+)\n((?:(?!^### ).)*)', + content, + re.MULTILINE | re.DOTALL + ) + + for header, body in sections: + header = header.strip() + body = body.strip() + + # Skip short sections, mnemonics, examples + if len(body) < 80 or 'Przykład' in header or 'Mnemonic' in header or '"' in header: + continue + + # Extract real content + answer_lines = [] + + # Get definition if present + def_match = re.search(r'#### Definicja[^\n]*\n([^\n#]+(?:\n[^\n#]+)?)', body) + if def_match: + answer_lines.append(def_match.group(1).strip()) + + # Get characterization + char_match = re.search(r'#### Charakterystyka\s*\n((?:[-•][^\n]+\n?)+)', body) + if char_match: + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)', char_match.group(1)) + for term, desc in bullets[:4]: + answer_lines.append(f"• {term}: {desc.strip()}" if desc else f"• {term}") + + # Get bullet points if no structured content yet + if not answer_lines: + bullets = re.findall(r'[-•]\s*\*\*([^*]+)\*\*[:\s]*([^\n]*)', body) + for term, desc in bullets[:5]: + answer_lines.append(f"• {term}: {desc.strip()}" if desc else f"• {term}") + + # Get first paragraph if still nothing + if not answer_lines: + first_para = re.search(r'^([^#\n\-•|`][^\n]{30,250})', body, re.MULTILINE) + if first_para: + answer_lines.append(first_para.group(1)) + + if answer_lines: + question = f"Wyjaśnij: {header}" if not header.endswith('?') else header + answer = '
    '.join([clean_text(l) for l in answer_lines]) + + cards.append({ + 'front': clean_text(question), + 'back': answer, + 'tags': f"{base_tags} szczegoly" + }) + + # =============================================== + # Q&A CARDS: From practice questions section + # =============================================== + qa_matches = re.findall( + r'### Q\d+:\s*["\']?([^"\'?\n]+)\?*["\']?\s*\n.*?Odpowiedź:\s*\n(.+?)(?=\n### |\n## |\Z)', + content, re.DOTALL + ) + + for question, answer in qa_matches[:5]: + question = question.strip() + answer = answer.strip() + + # Clean up answer - get first meaningful part + answer_lines = answer.split('\n') + clean_answer = [] + for line in answer_lines[:6]: + line = line.strip() + if line and not line.startswith('```') and not line.startswith('|'): + clean_answer.append(line) + + if clean_answer: + cards.append({ + 'front': clean_text(question + '?'), + 'back': '
    '.join([clean_text(l) for l in clean_answer]), + 'tags': f"{base_tags} qa" + }) + + return cards + +def main(): + odpowiedzi_dir = Path("/home/kuchy/praca_magisterska/pytania/odpowiedzi") + output_file = Path("/home/kuchy/praca_magisterska/pytania/anki_egzamin_magisterski.txt") + + all_cards = [] + + for md_file in sorted(odpowiedzi_dir.glob("*.md")): + print(f"Processing: {md_file.name}", end=" ") + try: + cards = extract_cards(md_file) + all_cards.extend(cards) + print(f"→ {len(cards)} cards") + except Exception as e: + print(f"→ ERROR: {e}") + + # Remove duplicates + seen = set() + unique_cards = [] + for card in all_cards: + key = card['front'][:100] + if key not in seen: + seen.add(key) + unique_cards.append(card) + + # Write file + with open(output_file, 'w', encoding='utf-8') as f: + f.write("#separator:Tab\n") + f.write("#html:true\n") + f.write("#notetype:Basic\n") + f.write("#deck:Egzamin Magisterski ISY\n") + f.write("#columns:Front\tBack\tTags\n") + f.write("#tags column:3\n") + f.write("\n") + + for card in unique_cards: + front = card['front'].replace('\t', ' ') + back = card['back'].replace('\t', ' ') + tags = card['tags'] + f.write(f"{front}\t{back}\t{tags}\n") + + print(f"\n✅ Generated {len(unique_cards)} flashcards") + print(f"📁 Output: {output_file}") + +if __name__ == "__main__": + main()