mirror of
https://github.com/kuhyx/praca_magisterska.git
synced 2026-07-04 12:03:01 +02:00
feat: automatic and manual anki cards generator
This commit is contained in:
parent
59d6211319
commit
7e4077abd1
91
install_nvidia_nsight.sh
Executable file
91
install_nvidia_nsight.sh
Executable file
@ -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."
|
||||
91
pytania/anki_approach_1.py
Normal file
91
pytania/anki_approach_1.py
Normal file
@ -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'<b>\1</b>', text)
|
||||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', 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 = '<ul>' + ''.join([f'<li>{clean_text(h)}</li>' for h in headers[:6]]) + '</ul>'
|
||||
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()
|
||||
115
pytania/anki_approach_2.py
Normal file
115
pytania/anki_approach_2.py
Normal file
@ -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'<b>\1</b>', text)
|
||||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', 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"<b>Definicja:</b> {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"• <b>{term}</b>: {desc.strip()}")
|
||||
else:
|
||||
parts.append(f"• <b>{term}</b>")
|
||||
|
||||
# 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"<b>{k}</b>: {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 '<br>'.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()
|
||||
330
pytania/anki_egzamin_magisterski.txt
Normal file
330
pytania/anki_egzamin_magisterski.txt
Normal file
@ -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? <b>Automat Skończony (FA)</b>: Języki regularne (Typ 3)<br><br><b>Automat ze Stosem (PDA)</b>: Języki bezkontekstowe (Typ 2)<br><br><b>Maszyna Turinga (TM)</b>: 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: <b>M = (Q, Σ, δ, q₀, F)</b>
|
||||
- <b>Q</b> - skończony zbiór stanów<br>• <b>Pamięć</b>: Brak pamięci pomocniczej - tylko aktualny stan<br>• <b>Moc obliczeniowa</b>: Nie potrafi "liczyć" (porównywać ilości)<br>• <b>Równoważne formalizmy</b> egzamin_magisterski pyt01 AISDI szczegoly
|
||||
Wyjaśnij: Automat ze Stosem (Pushdown Automaton - PDA) Automat ze stosem to siódemka: <b>M = (Q, Σ, Γ, δ, q₀, Z₀, F)</b>
|
||||
- <b>Q</b> - skończony zbiór stanów<br>• <b>Pamięć</b>: Stos (LIFO) - pamięć potencjalnie nieskończona, ale z ograniczonym dostępem<br>• <b>Moc obliczeniowa</b>: Potrafi "liczyć" (porównywać pary ilości)<br>• <b>DPDA ⊂ NPDA</b>: Deterministyczne PDA są SŁABSZE niż niedeterministyczne!<br>• <b>Równoważne formalizmy</b>: Gramatyki bezkontekstowe (CFG) egzamin_magisterski pyt01 AISDI szczegoly
|
||||
Wyjaśnij: Maszyna Turinga (Turing Machine - TM) Maszyna Turinga to siódemka: <b>M = (Q, Σ, Γ, δ, q₀, qaccept, qreject)</b>
|
||||
- <b>Q</b> - skończony zbiór stanów<br>• <b>Pamięć</b>: Taśma nieskończona z dostępem swobodnym (R/W)<br>• <b>Moc obliczeniowa</b>: Maksymalna możliwa (teza Churcha-Turinga)<br>• <b>DTM ≡ NTM</b>: 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*. <b>Problem:</b> 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 <b>Problem:</b> 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 • <b>Autor:</b>: Edsger Dijkstra (1956, opublikowany 1959)<br>• <b>Typ:</b>: Zachłanny (greedy)<br>• <b>Problem:</b>: SSSP - najkrótsze ścieżki z jednego źródła do wszystkich wierzchołków<br>• <b>Ograniczenie:</b>: ⚠️ <b>Tylko nieujemne wagi krawędzi</b> (w(e) ≥ 0) egzamin_magisterski pyt02 AISDI szczegoly
|
||||
Wyjaśnij: Idea algorytmu (logika budowy) 1. <b>Relaksacja:</b> 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 <b>O(V · E)</b> - 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. <b>Dopuszczalność (Admissibility):</b> egzamin_magisterski pyt02 AISDI szczegoly
|
||||
Wyjaśnij: Przypadki specjalne: • <b>h(n) = 0:</b>: A* = Dijkstra egzamin_magisterski pyt02 AISDI szczegoly
|
||||
Wyjaśnij: Dijkstra • <b>Nawigacja GPS</b>: (drogi nie mają ujemnych odległości)<br>• <b>Routing w sieciach</b>: (OSPF protocol)<br>• <b>Mapy Google/Apple</b>: (dla małych obszarów) egzamin_magisterski pyt02 AISDI szczegoly
|
||||
Wyjaśnij: Bellman-Ford • <b>Routing w sieciach</b>: (RIP protocol - prostszy)<br>• <b>Arbitraż walutowy</b>: (szukanie cykli ujemnych = zysk!)<br>• <b>Systemy z "karami"</b>: (ujemne wagi = bonusy) egzamin_magisterski pyt02 AISDI szczegoly
|
||||
Wyjaśnij: A* • <b>Gry komputerowe</b>: - pathfinding NPC, RTS<br>• <b>Robotyka</b>: - planowanie ruchu<br>• <b>Puzzle</b>: - 8-puzzle, 15-puzzle<br>• <b>Nawigacja</b>: - gdy znamy pozycję celu<br>• <b>Dijkstra:</b>: 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. <b>Redundancja</b> (nadmiarowość) i <b>normalizacja</b> to dwa fundamentalne, przeciwstawne pojęcia w projektowaniu relacyjnych baz danych: egzamin_magisterski pyt03 BD2 pytanie_glowne
|
||||
Wyjaśnij: Wprowadzenie • <b>Redundancja</b>: = niepożądane powtarzanie danych<br>• <b>Normalizacja</b>: = proces eliminacji redundancji poprzez dekompozycję relacji egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: Definicja <b>Redundancja</b> 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 <b>Problem:</b> Nie można dodać danych bez dodania innych, niepotrzebnych danych. egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: Podstawowe pojęcia <b>X → Y</b> 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. <b>Atomowość wartości</b> - każda komórka zawiera jedną, niepodzielną wartość egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: 2NF - Druga Postać Normalna 2. <b>Każdy atrybut wtórny jest w pełni funkcyjnie zależny od całego klucza głównego</b> (nie od jego części) egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: 3NF - Trzecia Postać Normalna 2. <b>Brak przechodnich zależności funkcyjnych</b> - 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. <b>Dla każdej nietrywialnej FD X → Y, X jest nadkluczem</b> egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: 4NF - Czwarta Postać Normalna 2. <b>Brak nietrywialnych zależności wielowartościowych</b> (MVD - Multivalued Dependencies) egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: 5NF - Piąta Postać Normalna (PJNF) 2. <b>Brak zależności połączeniowych</b> (Join Dependencies) egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: Algorytm dekompozycji do 3NF 1. <b>Znajdź pokrycie kanoniczne</b> 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ć? • <b>Optymalizacja wydajności</b>: - złączenia są kosztowne<br>• <b>Systemy OLAP/hurtownie danych</b>: - dane głównie odczytywane<br>• <b>Raportowanie</b>: - predefiniowane zapytania egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Wyjaśnij: Techniki denormalizacji: 1. <b>Dodanie redundantnych kolumn</b> - 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 <b>klucza</b>, <b>całego klucza</b> i <b>tylko od klucza</b>." egzamin_magisterski pyt03 BD2 szczegoly
|
||||
Dlaczego baza danych stanowi dobry fundament do budowy wielu systemów informatycznych? Baza danych to <b>centralny komponent</b> 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) <b>nie wpływa</b> 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. <b>Analizuje zapytanie</b> (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) • <b>Replikacja</b>: - kopie do odczytu<br>• <b>Sharding</b>: - podział danych między serwery<br>• <b>Klastry</b>: - wysoka dostępność egzamin_magisterski pyt04 BD2 szczegoly
|
||||
Wyjaśnij: SQL jako lingua franca • <b>Standardowy język</b>: - SQL:2016, SQL:2023<br>• <b>Przenośność</b>: - kod działa na różnych SZBD<br>• <b>Narzędzia</b>: - uniwersalne IDE, ORM, ETL egzamin_magisterski pyt04 BD2 szczegoly
|
||||
Wyjaśnij: Bogaty ekosystem • <b>ORM</b>: (Hibernate, Entity Framework, SQLAlchemy)<br>• <b>Narzędzia migracji</b>: (Flyway, Liquibase)<br>• <b>Monitorowanie</b>: (Grafana, Datadog)<br>• <b>Backup</b>: (pg_dump, mysqldump, RMAN) egzamin_magisterski pyt04 BD2 szczegoly
|
||||
Wyjaśnij: Polyglot Persistence Nowoczesne systemy często używają <b>wielu baz</b> - 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. <b>STL (Standard Template Library)</b> 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 • <b>Generyczność</b>: - szablony (templates) umożliwiają pracę z dowolnymi typami<br>• <b>Wydajność</b>: - zero-overhead abstraction<br>• <b>Modularność</b>: - komponenty są niezależne i wymienne<br>• <b>Ortogonalność</b>: - 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<int> vec = {1, 2, 3, 4, 5}; egzamin_magisterski pyt05 PROI szczegoly
|
||||
Wyjaśnij: Iteratory specjalne std::vector<int> vec = {1, 2, 3}; egzamin_magisterski pyt05 PROI szczegoly
|
||||
Wyjaśnij: Kategorie algorytmów std::vector<int> vec = {1, 2, 3, 4, 5, 3}; egzamin_magisterski pyt05 PROI szczegoly
|
||||
Wyjaśnij: Rodzaje funktorów std::vector<int> vec = {3, 1, 4, 1, 5}; egzamin_magisterski pyt05 PROI szczegoly
|
||||
Wyjaśnij: Kluczowa zasada: Ortogonalność <b>M kontenerów × N algorytmów = M + N implementacji</b> (nie M × N!) egzamin_magisterski pyt05 PROI szczegoly
|
||||
Omówić metody reużywalności kodu i struktur danych w obiektowych językach programowania. <b>Reużywalność kodu (code reuse)</b> 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<int>& 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".<br><br>Wykonują pełne rozwiązywanie nazw w imieniu klienta, pytając kolejno serwery autorytatywne.<br><br>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 <b>DNS (Domain Name System)</b> 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) • <b>13 logicznych serwerów:</b>: a.root-servers.net do m.root-servers.net<br>• <b>Fizycznie:</b>: Setki serwerów (anycast)<br>• <b>Funkcja:</b>: Wskazują serwery TLD<br>• <b>gTLD:</b>: .com, .org, .net (generic)<br>• <b>ccTLD:</b>: .pl, .de, .uk (country code) egzamin_magisterski pyt07 SKM szczegoly
|
||||
Wyjaśnij: 2 Serwery rekursywne (Recursive Resolvers) <b>Definicja:</b> 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) <b>Definicja:</b> 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) <b>Definicja:</b> 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. <b>Resolver otrzymuje odpowiedź</b> 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. <b>Mniejsza liczba = więcej zapytań na serwer:</b> 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? <b>TCP (Transmission Control Protocol)</b> to protokół warstwy transportowej zapewniający: egzamin_magisterski pyt08 SKM pytanie_glowne
|
||||
Wyjaśnij: Wprowadzenie do TCP <b>TCP (Transmission Control Protocol)</b> to protokół warstwy transportowej zapewniający: egzamin_magisterski pyt08 SKM szczegoly
|
||||
Wyjaśnij: Cele uzgadniania trójetapowego 1. <b>Nawiązanie połączenia</b> - 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 <b>Sequence Number (SEQ)</b> = numer pierwszego bajtu danych w segmencie egzamin_magisterski pyt08 SKM szczegoly
|
||||
Wyjaśnij: Kumulatywne potwierdzenia TCP używa <b>cumulative ACK</b> - 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. <b>Bezpieczeństwo</b> - przewidywalny ISN umożliwia ataki (TCP hijacking) egzamin_magisterski pyt08 SKM szczegoly
|
||||
Wyjaśnij: Generowanie ISN • <b>M</b>: = timer (jak wyżej)<br>• <b>F</b>: = funkcja kryptograficzna (MD5/SHA)<br>• <b>secretkey</b>: = 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. <b>Proces</b> i <b>wątek</b> 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 • <b>Binarny</b>: (0/1) - jak mutex<br>• <b>Licznikowy</b>: - ogranicza liczbę wątków (np. pula połączeń) egzamin_magisterski pyt09 SOI szczegoly
|
||||
Kiedy procesy? • <b>Izolacja</b>: - awaria jednego nie wpływa na inne<br>• <b>Bezpieczeństwo</b>: - różne uprawnienia<br>• <b>Różne języki/technologie</b>: - mikrousługi<br>• <b>Niezawodność</b>: - restart bez wpływu na system egzamin_magisterski pyt09 SOI szczegoly
|
||||
Kiedy wątki? • <b>Współdzielenie danych</b>: - bez kopiowania<br>• <b>Responsywność</b>: - UI thread + worker threads<br>• <b>Równoległość CPU</b>: - obliczenia na wielu rdzeniach<br>• <b>I/O asynchroniczne</b>: - 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. <b>Zarządzanie pamięcią</b> 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 <b>Problem:</b> 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 • <b>Strona (Page)</b>: - blok pamięci wirtualnej (4KB typowo)<br>• <b>Ramka (Frame)</b>: - 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 <b>Problem:</b> Tablica stron dla 32-bit przestrzeni z 4KB stronami = 2²⁰ wpisów × 4B = <b>4MB per proces!</b> egzamin_magisterski pyt10 SOI szczegoly
|
||||
Wyjaśnij: TLB (Translation Lookaside Buffer) <b>Problem:</b> Każdy dostęp do pamięci wymaga 2+ odczytów (tablica + dane). egzamin_magisterski pyt10 SOI szczegoly
|
||||
Wyjaśnij: Ochrona w segmentacji • <b>R</b>: (Read) - odczyt dozwolony<br>• <b>W</b>: (Write) - zapis dozwolony<br>• <b>X</b>: (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. <b>Ochrona</b> 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. <b>Start i koniec:</b> 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. <b>Sieciowe modele optymalizacji</b> to matematyczne reprezentacje problemów decyzyjnych w postaci grafów (sieci), gdzie: egzamin_magisterski pyt12 WSYZ pytanie_glowne
|
||||
Wyjaśnij: Właściwości • <b>NP-trudny</b>: - 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 <b>Agent</b> = system komputerowy umieszczony w środowisku, zdolny do <b>autonomicznego działania</b> 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 <b>FIPA-ACL</b> (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. <b>Zastosowania:</b> Przydział zadań, zarządzanie zasobami, e-commerce<br><br>Problem: Środowisko niestacjonarne (inni agenci się zmieniają)<br><br>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 • <b>Nazwa</b>: - identyfikator<br>• <b>Kontekst</b>: - kiedy stosować<br>• <b>Problem</b>: - co rozwiązuje<br>• <b>Rozwiązanie</b>: - struktura i zachowanie<br>• <b>Konsekwencje</b>: - 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. <b>Sprawdzenie:</b> Wszystkie wartości własne $\lambda_i > 0 \Rightarrow H \succ 0$<br><br>Jeśli $x^*$ jest minimum i spełnione są warunki regularności:<br><br><b>LICQ:</b> $\{\nabla g_i(x^<i>) : g_i(x^</i>) = 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. <b>Złożoność:</b> O(2^n) worst-case, ale praktycznie bardzo szybki<br><br><b>Rozwiązanie:</b> $(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). - <b>Redukcja wymiarowości:</b> 16kHz × 16bit → ~13-40 cech/ramkę<br><br><b>Typowo:</b> p = 10-16 dla mowy (8kHz), p = 16-20 (16kHz) egzamin_magisterski pyt19 EASAR pytanie_glowne
|
||||
Wyjaśnij: Cel parametryzacji mowy • <b>Redukcja wymiarowości:</b>: 16kHz × 16bit → ~13-40 cech/ramkę<br>• <b>Ekstrakcja informacji fonetycznej</b>: - <b>Usunięcie informacji mówcy</b> (częściowo)<br>• <b>Reprezentacja kompaktowa</b>: 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) • <b>Dźwięczne:</b>: pobudzenie okresowe (struny głosowe)<br>• <b>Bezdźwięczne:</b>: 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:<br><br>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? <b>Agent upostaciowiony</b> = agent posiadający fizyczne ciało, osadzony w rzeczywistym środowisku, zdolny do: egzamin_magisterski pyt21 ERPM pytanie_glowne
|
||||
Wyjaśnij: Agent upostaciowiony (Embodied Agent) • <b>Percepcji</b>: poprzez sensory<br>• <b>Działania</b>: poprzez efektory<br>• <b>Interakcji</b>: 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) |<br><br>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. <b>Problem:</b> Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.<br><br>Zdarzenie <b>a</b> happened-before <b>b</b> (a → b) jeśli:<br><br>Jeśli ¬(a → b) ∧ ¬(b → a), to <b>a || b</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. <b>Implementacja:</b> Consensus (Paxos, Raft), single leader<br><br>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!<br><br>Encje: Klient, Zamówienie, Produkt, Kategoria, Dostawca, Płatność<br><br>┌────────────────────────┐ ┌────────────────────────┐ 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}$$<br><br><b>Obserwacja:</b> Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.<br><br>┌─────────────────────────────────────────────────────────────────┐ 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$$<br><br>$$f \text{ wypukła} \Leftrightarrow f(\lambda x + (1-\lambda)y) \leq \lambda f(x) + (1-\lambda) f(y)$$<br><br>$$\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 |<br><br>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)<br><br>| Cecha | Kafka | RabbitMQ | MQTT | Redis Pub/Sub |<br><br>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<String, String> source = builder.stream("input-topic");<br><br>| Cecha | Kafka Streams | Flink | Spark Streaming |<br><br>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. ┌─────────────────────────────────────────────────────────────────┐<br><br>┌─────────────────────────────────────────────────────────────────┐<br><br>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]$$<br><br>$$Q^\pi(s,a) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s, a_0 = a \right]$$<br><br>Q<i>(s,a) = R(s,a) + γ Σ_s' P(s'|s,a) max_a' Q</i>(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 ┌──────────────────┐<br><br>| 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? ┌─────────────────────────────────────────────────────────────────┐<br><br>┌─────────────────────────────────────────────────────────────────┐<br><br>┌─────────────────────────────────────────────────────────────────┐ 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$$<br><br>$$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 <b>"Jaki jest cel Pana pracy magisterskiej i dlaczego wybrano akurat temat porównania silników gier?"</b> egzamin_magisterski pyt45 Ogólne szczegoly
|
||||
Wyjaśnij: Odpowiedź wzorcowa Celem pracy jest <b>kompleksowe porównanie wydajności i możliwości współczesnych silników gier</b> (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
|
||||
1947
pytania/anki_extract.txt
Normal file
1947
pytania/anki_extract.txt
Normal file
File diff suppressed because it is too large
Load Diff
40
pytania/anki_extract_main.txt
Normal file
40
pytania/anki_extract_main.txt
Normal file
@ -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? <b>Automat Skończony (Finite Automaton - FA)</b>: Języki regularne (Typ 3)<br><br><b>Automat ze Stosem (Pushdown Automaton - PDA)</b>: Języki bezkontekstowe (Typ 2)<br><br><b>Maszyna Turinga (Turing Machine - TM)</b>: 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*. <b>Wprowadzenie - problem najkrótszej ścieżki</b>: <b>Warianty problemu:</b> egzamin pyt02 AISDI main
|
||||
Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. <b>Wprowadzenie</b>: 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. <b>Filozofia STL</b>: 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. <b>Wprowadzenie</b>: 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. <b>Architektury agentów</b>: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.<br><br><b>Standardy komunikacji agentów</b>: <b>FIPA-ACL</b> (Agent Communication Language): egzamin pyt13 AASD main
|
||||
Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. <b>Algorytmy negocjacji i aukcji</b>: Manager Contractors<br><br><b>Algorytmy konsensusu</b>: Client ──request──→ Primary<br><br><b>Algorytmy koordynacji</b>: <b>Algorytm Ricarta-Agrawali:</b><br><br><b>Algorytmy uczenia wieloagentowego</b>: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]<br><br><b>Algorytmy dla aktorów</b>: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main
|
||||
Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury. <b>Notacje i języki modelowania</b>: 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. <b>Jak powstają wzorce</b>: 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. <b>Optymalizacja bez ograniczeń</b>: (Gradient zerowy - punkt stacjonarny)<br><br><b>Warunki KKT (Karush-Kuhn-Tucker)</b>: Jeśli $x^*$ jest minimum i spełnione są warunki regularności:<br><br><b>Warunki regularności (Constraint Qualification)</b>: <b>LICQ:</b> $\{\nabla g_i(x^<i>) : g_i(x^</i>) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne<br><br><b>Warunki dostateczne II rzędu</b>: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main
|
||||
Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. <b>Programowanie liniowe (LP)</b>: <b>Złożoność:</b> O(2^n) worst-case, ale praktycznie bardzo szybki<br><br><b>Programowanie kwadratowe (QP)</b>: Gdzie Q jest macierzą symetryczną.<br><br><b>Metody rozwiązywania QP</b>: 1. Zgadnij zbiór aktywnych ograniczeń W<br><br><b>Przypadki szczególne</b>: <b>Rozwiązanie:</b> $(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). <b>Cel parametryzacji mowy</b>: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę<br><br><b>MFCC (Mel-Frequency Cepstral Coefficients)</b>: mel(f) = 2595 · log₁₀(1 + f/700)<br><br><b>LPC (Linear Predictive Coding)</b>: 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. <b>HMM (Hidden Markov Model) - klasyczne podejście</b>: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:<br><br><b>Deep Learning w rozpoznawaniu mowy</b>: Attention-based (Seq2Seq):<br><br><b>Ewolucja wydajności</b>: Rok Model WER egzamin pyt20 EASAR main
|
||||
Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? <b>Agent upostaciowiony (Embodied Agent)</b>: Percepcji: poprzez sensory<br><br><b>Formalny model agenta</b>: Specyfikacja żywotności: egzamin pyt21 ERPM main
|
||||
Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. <b>Języki producentów robotów przemysłowych</b>: ! MoveJ = ruch w przestrzeni złączy (Joint)<br><br><b>Języki uniwersalne i frameworki</b>: rospy.init_node('robot_controller') egzamin pyt22 ERPM main
|
||||
Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. <b>Problem czasu w systemach rozproszonych</b>: <b>Problem:</b> Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.<br><br><b>Zegar Lamporta (Scalar Clock)</b>: 1. Przed każdym zdarzeniem lokalnym:<br><br><b>Zegary wektorowe (Vector Clocks)</b>: 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main
|
||||
Omówić silne i słabe modele spójności danych w środowisku rozproszonym. <b>Silne modele spójności</b>: <b>Implementacja:</b> Consensus (Paxos, Raft), single leader<br><br><b>Słabe modele spójności</b>: <b>Implementacja:</b> 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ść. <b>Definicja MIP (Mixed Integer Programming)</b>: Przypadki szczególne:<br><br><b>Branch and Bound (B&B) - metoda dokładna</b>: 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. <b>Porównanie wydajności (benchmark)</b>: CPLEX ████████████████████████████ 100% egzamin pyt26 MOD main
|
||||
Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. <b>Model konceptualny (Conceptual Data Model)</b>: ┌──────────┐ ┌──────────┐<br><br><b>Model logiczny (Logical Data Model)</b>: ┌────────────────────────┐ ┌────────────────────────┐<br><br><b>Model fizyczny (Physical Data Model)</b>: 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? <b>Prawo Amdahla</b>: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$<br><br><b>Wizualizacja ograniczenia</b>: <b>Obserwacja:</b> Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.<br><br><b>Co osłabia ograniczenie Amdahla?</b>: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n<br><br><b>Czynniki zmniejszające rzeczywiste przyśpieszenie</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Efektywność równoległa</b>: <b>Wniosek:</b> 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. <b>Typowe problemy w modelowaniu</b>: Przykład - planowanie produkcji:<br><br><b>Techniki modelowania</b>: 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. <b>Definicje kluczowe</b>: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$<br><br><b>Liniowość vs nieliniowość</b>: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$<br><br><b>Testowanie wypukłości</b>: 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? <b>Definicje podstawowe</b>: KOMUNIKACJA ASYNCHRONICZNA:<br><br><b>Problem zakleszczenia (Deadlock)</b>: // Proces 0: // Proces 1:<br><br><b>Rozwiązania problemu zakleszczenia</b>: 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. <b>Rozwiązania techniczne</b>: channel.queue_bind(exchange='logs', queue=queue_name) egzamin pyt33 PSD main
|
||||
Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. <b>Modele przetwarzania</b>: Processing: ───●───────●──●──●───────→<br><br><b>Platformy Stream Processing</b>: KStream<String, String> source = builder.stream("input-topic");<br><br><b>Algorytmy strumieniowe</b>: 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. <b>Współpraca agentów w sieci</b>: L = Laplacian grafu komunikacji<br><br><b>Warunki zbieżności consensus</b>: 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. <b>Funkcje wartości</b>: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$<br><br><b>Algorytmy</b>: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main
|
||||
Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. <b>Metody projekcji</b>: P = B · Bᵀ (dla projekcji na U)<br><br><b>Zastosowanie w grupowaniu dokumentów</b>: 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. <b>Metody klasyczne</b>: 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? <b>Metody Deep Learning</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Non-Maximum Suppression (NMS)</b>: Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main
|
||||
Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. <b>Metoda pewnego ekwiwalentu (Certainty Equivalent)</b>: 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? <b>Dominacja stochastyczna pierwszego rzędu (FSD)</b>: $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$<br><br><b>Dominacja stochastyczna drugiego rzędu (SSD)</b>: $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$<br><br><b>Zastosowanie w modelach wyboru</b>: 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. <b>Pole α - Środowisko maszynowe</b>: 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. <b>Model EOQ (Economic Order Quantity)</b>: Ordering cost = K × (D/Q) (D/Q zamówień rocznie) egzamin pyt44 ZBOP main
|
||||
1217
pytania/anki_filter.txt
Normal file
1217
pytania/anki_filter.txt
Normal file
File diff suppressed because it is too large
Load Diff
1883
pytania/anki_filter_extract.txt
Normal file
1883
pytania/anki_filter_extract.txt
Normal file
File diff suppressed because it is too large
Load Diff
28
pytania/anki_filter_extract_main.txt
Normal file
28
pytania/anki_filter_extract_main.txt
Normal file
@ -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? <b>Automat Skończony (Finite Automaton - FA)</b>: Języki regularne (Typ 3)<br><br><b>Automat ze Stosem (Pushdown Automaton - PDA)</b>: Języki bezkontekstowe (Typ 2)<br><br><b>Maszyna Turinga (Turing Machine - TM)</b>: 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. <b>Architektury agentów</b>: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.<br><br><b>Standardy komunikacji agentów</b>: <b>FIPA-ACL</b> (Agent Communication Language): egzamin pyt13 AASD main
|
||||
Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. <b>Algorytmy negocjacji i aukcji</b>: Manager Contractors<br><br><b>Algorytmy konsensusu</b>: Client ──request──→ Primary<br><br><b>Algorytmy koordynacji</b>: <b>Algorytm Ricarta-Agrawali:</b><br><br><b>Algorytmy uczenia wieloagentowego</b>: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]<br><br><b>Algorytmy dla aktorów</b>: // 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. <b>Optymalizacja bez ograniczeń</b>: (Gradient zerowy - punkt stacjonarny)<br><br><b>Warunki KKT (Karush-Kuhn-Tucker)</b>: Jeśli $x^*$ jest minimum i spełnione są warunki regularności:<br><br><b>Warunki regularności (Constraint Qualification)</b>: <b>LICQ:</b> $\{\nabla g_i(x^<i>) : g_i(x^</i>) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne<br><br><b>Warunki dostateczne II rzędu</b>: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main
|
||||
Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. <b>Programowanie liniowe (LP)</b>: <b>Złożoność:</b> O(2^n) worst-case, ale praktycznie bardzo szybki<br><br><b>Programowanie kwadratowe (QP)</b>: Gdzie Q jest macierzą symetryczną.<br><br><b>Metody rozwiązywania QP</b>: 1. Zgadnij zbiór aktywnych ograniczeń W<br><br><b>Przypadki szczególne</b>: <b>Rozwiązanie:</b> $(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). <b>Cel parametryzacji mowy</b>: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę<br><br><b>MFCC (Mel-Frequency Cepstral Coefficients)</b>: mel(f) = 2595 · log₁₀(1 + f/700)<br><br><b>LPC (Linear Predictive Coding)</b>: 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. <b>HMM (Hidden Markov Model) - klasyczne podejście</b>: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:<br><br><b>Deep Learning w rozpoznawaniu mowy</b>: Attention-based (Seq2Seq):<br><br><b>Ewolucja wydajności</b>: Rok Model WER egzamin pyt20 EASAR main
|
||||
Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? <b>Agent upostaciowiony (Embodied Agent)</b>: Percepcji: poprzez sensory<br><br><b>Formalny model agenta</b>: Specyfikacja żywotności: egzamin pyt21 ERPM main
|
||||
Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. <b>Języki producentów robotów przemysłowych</b>: ! MoveJ = ruch w przestrzeni złączy (Joint)<br><br><b>Języki uniwersalne i frameworki</b>: rospy.init_node('robot_controller') egzamin pyt22 ERPM main
|
||||
Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. <b>Problem czasu w systemach rozproszonych</b>: <b>Problem:</b> Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.<br><br><b>Zegar Lamporta (Scalar Clock)</b>: 1. Przed każdym zdarzeniem lokalnym:<br><br><b>Zegary wektorowe (Vector Clocks)</b>: 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main
|
||||
Omówić silne i słabe modele spójności danych w środowisku rozproszonym. <b>Silne modele spójności</b>: <b>Implementacja:</b> Consensus (Paxos, Raft), single leader<br><br><b>Słabe modele spójności</b>: <b>Implementacja:</b> 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ść. <b>Definicja MIP (Mixed Integer Programming)</b>: Przypadki szczególne:<br><br><b>Branch and Bound (B&B) - metoda dokładna</b>: LP relaxation egzamin pyt25 MOD main
|
||||
Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. <b>Model konceptualny (Conceptual Data Model)</b>: ┌──────────┐ ┌──────────┐<br><br><b>Model logiczny (Logical Data Model)</b>: ┌────────────────────────┐ ┌────────────────────────┐<br><br><b>Model fizyczny (Physical Data Model)</b>: 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? <b>Prawo Amdahla</b>: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$<br><br><b>Wizualizacja ograniczenia</b>: <b>Obserwacja:</b> Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.<br><br><b>Co osłabia ograniczenie Amdahla?</b>: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n<br><br><b>Czynniki zmniejszające rzeczywiste przyśpieszenie</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Efektywność równoległa</b>: <b>Wniosek:</b> 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. <b>Typowe problemy w modelowaniu</b>: Przykład - planowanie produkcji:<br><br><b>Techniki modelowania</b>: 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. <b>Definicje kluczowe</b>: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$<br><br><b>Liniowość vs nieliniowość</b>: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$<br><br><b>Testowanie wypukłości</b>: 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? <b>Definicje podstawowe</b>: KOMUNIKACJA ASYNCHRONICZNA:<br><br><b>Problem zakleszczenia (Deadlock)</b>: // Proces 0: // Proces 1:<br><br><b>Rozwiązania problemu zakleszczenia</b>: 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. <b>Modele przetwarzania</b>: Processing: ───●───────●──●──●───────→<br><br><b>Platformy Stream Processing</b>: KStream<String, String> source = builder.stream("input-topic");<br><br><b>Algorytmy strumieniowe</b>: 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. <b>Współpraca agentów w sieci</b>: L = Laplacian grafu komunikacji<br><br><b>Warunki zbieżności consensus</b>: 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. <b>Funkcje wartości</b>: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$<br><br><b>Algorytmy</b>: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main
|
||||
Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. <b>Metody projekcji</b>: P = B · Bᵀ (dla projekcji na U)<br><br><b>Zastosowanie w grupowaniu dokumentów</b>: 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? <b>Metody Deep Learning</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Non-Maximum Suppression (NMS)</b>: 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? <b>Dominacja stochastyczna pierwszego rzędu (FSD)</b>: $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$<br><br><b>Dominacja stochastyczna drugiego rzędu (SSD)</b>: $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$<br><br><b>Zastosowanie w modelach wyboru</b>: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main
|
||||
28
pytania/anki_filter_main.txt
Normal file
28
pytania/anki_filter_main.txt
Normal file
@ -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? <b>Automat Skończony (Finite Automaton - FA)</b>: Języki regularne (Typ 3)<br><br><b>Automat ze Stosem (Pushdown Automaton - PDA)</b>: Języki bezkontekstowe (Typ 2)<br><br><b>Maszyna Turinga (Turing Machine - TM)</b>: 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. <b>Architektury agentów</b>: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.<br><br><b>Standardy komunikacji agentów</b>: <b>FIPA-ACL</b> (Agent Communication Language): egzamin pyt13 AASD main
|
||||
Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. <b>Algorytmy negocjacji i aukcji</b>: Manager Contractors<br><br><b>Algorytmy konsensusu</b>: Client ──request──→ Primary<br><br><b>Algorytmy koordynacji</b>: <b>Algorytm Ricarta-Agrawali:</b><br><br><b>Algorytmy uczenia wieloagentowego</b>: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]<br><br><b>Algorytmy dla aktorów</b>: // 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. <b>Optymalizacja bez ograniczeń</b>: (Gradient zerowy - punkt stacjonarny)<br><br><b>Warunki KKT (Karush-Kuhn-Tucker)</b>: Jeśli $x^*$ jest minimum i spełnione są warunki regularności:<br><br><b>Warunki regularności (Constraint Qualification)</b>: <b>LICQ:</b> $\{\nabla g_i(x^<i>) : g_i(x^</i>) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne<br><br><b>Warunki dostateczne II rzędu</b>: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main
|
||||
Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. <b>Programowanie liniowe (LP)</b>: <b>Złożoność:</b> O(2^n) worst-case, ale praktycznie bardzo szybki<br><br><b>Programowanie kwadratowe (QP)</b>: Gdzie Q jest macierzą symetryczną.<br><br><b>Metody rozwiązywania QP</b>: 1. Zgadnij zbiór aktywnych ograniczeń W<br><br><b>Przypadki szczególne</b>: <b>Rozwiązanie:</b> $(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). <b>Cel parametryzacji mowy</b>: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę<br><br><b>MFCC (Mel-Frequency Cepstral Coefficients)</b>: mel(f) = 2595 · log₁₀(1 + f/700)<br><br><b>LPC (Linear Predictive Coding)</b>: 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. <b>HMM (Hidden Markov Model) - klasyczne podejście</b>: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:<br><br><b>Deep Learning w rozpoznawaniu mowy</b>: Attention-based (Seq2Seq):<br><br><b>Ewolucja wydajności</b>: Rok Model WER egzamin pyt20 EASAR main
|
||||
Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? <b>Agent upostaciowiony (Embodied Agent)</b>: Percepcji: poprzez sensory<br><br><b>Formalny model agenta</b>: Specyfikacja żywotności: egzamin pyt21 ERPM main
|
||||
Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. <b>Języki producentów robotów przemysłowych</b>: ! MoveJ = ruch w przestrzeni złączy (Joint)<br><br><b>Języki uniwersalne i frameworki</b>: rospy.init_node('robot_controller') egzamin pyt22 ERPM main
|
||||
Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. <b>Problem czasu w systemach rozproszonych</b>: <b>Problem:</b> Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.<br><br><b>Zegar Lamporta (Scalar Clock)</b>: 1. Przed każdym zdarzeniem lokalnym:<br><br><b>Zegary wektorowe (Vector Clocks)</b>: 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main
|
||||
Omówić silne i słabe modele spójności danych w środowisku rozproszonym. <b>Silne modele spójności</b>: <b>Implementacja:</b> Consensus (Paxos, Raft), single leader<br><br><b>Słabe modele spójności</b>: <b>Implementacja:</b> 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ść. <b>Definicja MIP (Mixed Integer Programming)</b>: Przypadki szczególne:<br><br><b>Branch and Bound (B&B) - metoda dokładna</b>: LP relaxation egzamin pyt25 MOD main
|
||||
Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. <b>Model konceptualny (Conceptual Data Model)</b>: ┌──────────┐ ┌──────────┐<br><br><b>Model logiczny (Logical Data Model)</b>: ┌────────────────────────┐ ┌────────────────────────┐<br><br><b>Model fizyczny (Physical Data Model)</b>: 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? <b>Prawo Amdahla</b>: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$<br><br><b>Wizualizacja ograniczenia</b>: <b>Obserwacja:</b> Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.<br><br><b>Co osłabia ograniczenie Amdahla?</b>: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n<br><br><b>Czynniki zmniejszające rzeczywiste przyśpieszenie</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Efektywność równoległa</b>: <b>Wniosek:</b> 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. <b>Typowe problemy w modelowaniu</b>: Przykład - planowanie produkcji:<br><br><b>Techniki modelowania</b>: 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. <b>Definicje kluczowe</b>: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$<br><br><b>Liniowość vs nieliniowość</b>: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$<br><br><b>Testowanie wypukłości</b>: 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? <b>Definicje podstawowe</b>: KOMUNIKACJA ASYNCHRONICZNA:<br><br><b>Problem zakleszczenia (Deadlock)</b>: // Proces 0: // Proces 1:<br><br><b>Rozwiązania problemu zakleszczenia</b>: 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. <b>Modele przetwarzania</b>: Processing: ───●───────●──●──●───────→<br><br><b>Platformy Stream Processing</b>: KStream<String, String> source = builder.stream("input-topic");<br><br><b>Algorytmy strumieniowe</b>: 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. <b>Współpraca agentów w sieci</b>: L = Laplacian grafu komunikacji<br><br><b>Warunki zbieżności consensus</b>: 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. <b>Funkcje wartości</b>: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$<br><br><b>Algorytmy</b>: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main
|
||||
Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. <b>Metody projekcji</b>: P = B · Bᵀ (dla projekcji na U)<br><br><b>Zastosowanie w grupowaniu dokumentów</b>: 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? <b>Metody Deep Learning</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Non-Maximum Suppression (NMS)</b>: 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? <b>Dominacja stochastyczna pierwszego rzędu (FSD)</b>: $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$<br><br><b>Dominacja stochastyczna drugiego rzędu (SSD)</b>: $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$<br><br><b>Zastosowanie w modelach wyboru</b>: Dla rozkładów normalnych z E[A] > E[B] i σ[A] < σ[B]: egzamin pyt42 WDWR main
|
||||
331
pytania/anki_generator.py
Normal file
331
pytania/anki_generator.py
Normal file
@ -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'<b>\1</b>', text)
|
||||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', 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"<b>Definicja:</b> {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"• <b>{term}</b>: {desc.strip()}")
|
||||
else:
|
||||
parts.append(f"• <b>{term}</b>")
|
||||
|
||||
# 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"<b>{k.strip()}</b>: {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 '<br>'.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## [^<5E>]|\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 = '<ul>' + ''.join([f'<li>{clean_text(h)}</li>' for h in headers[:6]]) + '</ul>'
|
||||
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## [^<5E>]|\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"<b>{header}</b>: {key_point}")
|
||||
|
||||
if answer_parts:
|
||||
answer = '<br><br>'.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()
|
||||
40
pytania/anki_main.txt
Normal file
40
pytania/anki_main.txt
Normal file
@ -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? <b>Automat Skończony (Finite Automaton - FA)</b>: Języki regularne (Typ 3)<br><br><b>Automat ze Stosem (Pushdown Automaton - PDA)</b>: Języki bezkontekstowe (Typ 2)<br><br><b>Maszyna Turinga (Turing Machine - TM)</b>: 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*. <b>Wprowadzenie - problem najkrótszej ścieżki</b>: <b>Warianty problemu:</b> egzamin pyt02 AISDI main
|
||||
Omówić zagadnienia redundancji i normalizacji w relacyjnej bazie danych oraz wynikające z tego wymagania. <b>Wprowadzenie</b>: 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. <b>Filozofia STL</b>: 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. <b>Wprowadzenie</b>: 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. <b>Architektury agentów</b>: Zachowania niskopoziomowe mogą być "nadpisane" przez wyższe.<br><br><b>Standardy komunikacji agentów</b>: <b>FIPA-ACL</b> (Agent Communication Language): egzamin pyt13 AASD main
|
||||
Wymienić i szczegółowo opisać wybrane algorytmy i metody wykorzystywane w systemach wieloagentowych i aktorowych. <b>Algorytmy negocjacji i aukcji</b>: Manager Contractors<br><br><b>Algorytmy konsensusu</b>: Client ──request──→ Primary<br><br><b>Algorytmy koordynacji</b>: <b>Algorytm Ricarta-Agrawali:</b><br><br><b>Algorytmy uczenia wieloagentowego</b>: Q(s,a) ← Q(s,a) + α[r + γ max Q(s',a') - Q(s,a)]<br><br><b>Algorytmy dla aktorów</b>: // All-for-One: restart wszystkich dzieci egzamin pyt14 AASD main
|
||||
Omówić metody modelowania architektury systemów informatycznych. Przedstawić cele i metody modelowania architektury. <b>Notacje i języki modelowania</b>: 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. <b>Jak powstają wzorce</b>: 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. <b>Optymalizacja bez ograniczeń</b>: (Gradient zerowy - punkt stacjonarny)<br><br><b>Warunki KKT (Karush-Kuhn-Tucker)</b>: Jeśli $x^*$ jest minimum i spełnione są warunki regularności:<br><br><b>Warunki regularności (Constraint Qualification)</b>: <b>LICQ:</b> $\{\nabla g_i(x^<i>) : g_i(x^</i>) = 0\} \cup \{\nabla h_j(x^*)\}$ są liniowo niezależne<br><br><b>Warunki dostateczne II rzędu</b>: dla wszystkich $d \neq 0$ spełniających: egzamin pyt17 AMO main
|
||||
Omówić metody rozwiązywania zadań liniowych i kwadratowych optymalizacji. <b>Programowanie liniowe (LP)</b>: <b>Złożoność:</b> O(2^n) worst-case, ale praktycznie bardzo szybki<br><br><b>Programowanie kwadratowe (QP)</b>: Gdzie Q jest macierzą symetryczną.<br><br><b>Metody rozwiązywania QP</b>: 1. Zgadnij zbiór aktywnych ograniczeń W<br><br><b>Przypadki szczególne</b>: <b>Rozwiązanie:</b> $(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). <b>Cel parametryzacji mowy</b>: Redukcja wymiarowości:: 16kHz × 16bit → ~13-40 cech/ramkę<br><br><b>MFCC (Mel-Frequency Cepstral Coefficients)</b>: mel(f) = 2595 · log₁₀(1 + f/700)<br><br><b>LPC (Linear Predictive Coding)</b>: 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. <b>HMM (Hidden Markov Model) - klasyczne podejście</b>: Każdy stan emituje obserwacje (MFCC) według rozkładu GMM:<br><br><b>Deep Learning w rozpoznawaniu mowy</b>: Attention-based (Seq2Seq):<br><br><b>Ewolucja wydajności</b>: Rok Model WER egzamin pyt20 EASAR main
|
||||
Jak wykorzystuje się agenta upostaciowionego do specyfikacji sterowników robotów? <b>Agent upostaciowiony (Embodied Agent)</b>: Percepcji: poprzez sensory<br><br><b>Formalny model agenta</b>: Specyfikacja żywotności: egzamin pyt21 ERPM main
|
||||
Omówić specjalizowane języki programowania robotów. Uwypuklić ich klasyfikację. <b>Języki producentów robotów przemysłowych</b>: ! MoveJ = ruch w przestrzeni złączy (Joint)<br><br><b>Języki uniwersalne i frameworki</b>: rospy.init_node('robot_controller') egzamin pyt22 ERPM main
|
||||
Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych. <b>Problem czasu w systemach rozproszonych</b>: <b>Problem:</b> Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.<br><br><b>Zegar Lamporta (Scalar Clock)</b>: 1. Przed każdym zdarzeniem lokalnym:<br><br><b>Zegary wektorowe (Vector Clocks)</b>: 1. Przed każdym zdarzeniem lokalnym: egzamin pyt23 ERSMS main
|
||||
Omówić silne i słabe modele spójności danych w środowisku rozproszonym. <b>Silne modele spójności</b>: <b>Implementacja:</b> Consensus (Paxos, Raft), single leader<br><br><b>Słabe modele spójności</b>: <b>Implementacja:</b> 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ść. <b>Definicja MIP (Mixed Integer Programming)</b>: Przypadki szczególne:<br><br><b>Branch and Bound (B&B) - metoda dokładna</b>: 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. <b>Porównanie wydajności (benchmark)</b>: CPLEX ████████████████████████████ 100% egzamin pyt26 MOD main
|
||||
Omówić typowe fazy ewolucji modelu danych i pożądane cechy modelu w każdej z faz. <b>Model konceptualny (Conceptual Data Model)</b>: ┌──────────┐ ┌──────────┐<br><br><b>Model logiczny (Logical Data Model)</b>: ┌────────────────────────┐ ┌────────────────────────┐<br><br><b>Model fizyczny (Physical Data Model)</b>: 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? <b>Prawo Amdahla</b>: $$S(n) = \frac{1}{(1-p) + \frac{p}{n}}$$<br><br><b>Wizualizacja ograniczenia</b>: <b>Obserwacja:</b> Krzywe szybko się spłaszczają - dodawanie procesorów daje coraz mniejszy zysk.<br><br><b>Co osłabia ograniczenie Amdahla?</b>: S_scaled(n) = n - (1-p)(n-1) = 1 - p + p·n<br><br><b>Czynniki zmniejszające rzeczywiste przyśpieszenie</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Efektywność równoległa</b>: <b>Wniosek:</b> 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. <b>Typowe problemy w modelowaniu</b>: Przykład - planowanie produkcji:<br><br><b>Techniki modelowania</b>: 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. <b>Definicje kluczowe</b>: $$S \text{ wypukły} \Leftrightarrow \forall x,y \in S, \forall \lambda \in [0,1]: \lambda x + (1-\lambda)y \in S$$<br><br><b>Liniowość vs nieliniowość</b>: $$\min c^T x \quad \text{s.t.} \quad Ax \leq b, \quad x \geq 0$$<br><br><b>Testowanie wypukłości</b>: 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? <b>Definicje podstawowe</b>: KOMUNIKACJA ASYNCHRONICZNA:<br><br><b>Problem zakleszczenia (Deadlock)</b>: // Proces 0: // Proces 1:<br><br><b>Rozwiązania problemu zakleszczenia</b>: 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. <b>Rozwiązania techniczne</b>: channel.queue_bind(exchange='logs', queue=queue_name) egzamin pyt33 PSD main
|
||||
Scharakteryzować rozwiązania analityczne działające na danych o charakterze strumieniowym. <b>Modele przetwarzania</b>: Processing: ───●───────●──●──●───────→<br><br><b>Platformy Stream Processing</b>: KStream<String, String> source = builder.stream("input-topic");<br><br><b>Algorytmy strumieniowe</b>: 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. <b>Współpraca agentów w sieci</b>: L = Laplacian grafu komunikacji<br><br><b>Warunki zbieżności consensus</b>: 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. <b>Funkcje wartości</b>: $$V^\pi(s) = \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t r_t \mid s_0 = s \right]$$<br><br><b>Algorytmy</b>: ┌─────────────────────────────────────────────────────────────────┐ egzamin pyt36 SIU main
|
||||
Porównać metody projekcji grafów dwudzielnych. Przedstawić ich użyteczność w grupowaniu dokumentów tekstowych. <b>Metody projekcji</b>: P = B · Bᵀ (dla projekcji na U)<br><br><b>Zastosowanie w grupowaniu dokumentów</b>: 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. <b>Metody klasyczne</b>: 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? <b>Metody Deep Learning</b>: ┌─────────────────────────────────────────────────────────────────┐<br><br><b>Non-Maximum Suppression (NMS)</b>: Soft-NMS: Nie usuwa, tylko obniża confidence egzamin pyt40 TWM main
|
||||
Przedstawić metody interaktywne wspomagania decyzji w warunkach ryzyka. <b>Metoda pewnego ekwiwalentu (Certainty Equivalent)</b>: 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? <b>Dominacja stochastyczna pierwszego rzędu (FSD)</b>: $$A \succeq_{FSD} B \Leftrightarrow F_A(x) \leq F_B(x) \quad \forall x$$<br><br><b>Dominacja stochastyczna drugiego rzędu (SSD)</b>: $$A \succeq_{SSD} B \Leftrightarrow \int_{-\infty}^{x} F_A(t) dt \leq \int_{-\infty}^{x} F_B(t) dt \quad \forall x$$<br><br><b>Zastosowanie w modelach wyboru</b>: 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. <b>Pole α - Środowisko maszynowe</b>: 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. <b>Model EOQ (Economic Order Quantity)</b>: Ordering cost = K × (D/Q) (D/Q zamówień rocznie) egzamin pyt44 ZBOP main
|
||||
118
pytania/anki_manual.txt
Normal file
118
pytania/anki_manual.txt
Normal file
@ -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? <b>Automat Skończony (FA)</b> → <b>Języki regularne (Typ 3)</b><br>• Brak pamięci - tylko aktualny stan<br>• Równoważny wyrażeniom regularnym<br>• Przykład: identyfikatory, wzorce tekstu<br>• NIE rozpozna: aⁿbⁿ (wymaga liczenia)<br><br><b>Automat ze Stosem (PDA)</b> → <b>Języki bezkontekstowe (Typ 2)</b><br>• Pamięć: stos LIFO (nieskończony, ale ograniczony dostęp)<br>• Potrafi liczyć pary: aⁿbⁿ ✓<br>• NIE rozpozna: aⁿbⁿcⁿ (wymaga 3 liczników)<br>• UWAGA: DPDA ⊂ NPDA (niedeterministyczny silniejszy!)<br><br><b>Maszyna Turinga (TM)</b> → <b>Języki rekurencyjnie przeliczalne (Typ 0)</b><br>• Pamięć: nieskończona taśma R/W<br>• Rozpoznaje wszystko co obliczalne (teza Churcha-Turinga)<br>• 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 <b>nie ma pamięci</b> poza swoim stanem. Aby rozpoznać aⁿbⁿ, musiałby "zapamiętać" ile było liter 'a', żeby porównać z liczbą 'b'.<br><br>Skończona liczba stanów = skończona "pamięć" = nie może liczyć do dowolnie dużego n.<br><br><b>Dowód formalny:</b> 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? <b>DFA = NFA</b> (równoważne):<br>Każdy NFA można przekształcić w DFA przez konstrukcję podzbiorową (powerset construction). Stany DFA = podzbiory stanów NFA.<br><br><b>DPDA ⊂ NPDA</b> (DPDA słabszy):<br>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.<br><br>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*. <b>Dijkstra</b> (1959) - zachłanny, SSSP<br>• Wymóg: wagi ≥ 0<br>• Złożoność: O(V²) lub O((V+E)log V) z kopcem<br>• Idea: wybieraj wierzchołek o najmniejszej znanej odległości<br><br><b>Bellman-Ford</b> (1958) - programowanie dynamiczne<br>• Działa dla ujemnych wag (wykrywa ujemne cykle)<br>• Złożoność: O(V·E)<br>• Idea: V-1 iteracji relaksacji wszystkich krawędzi<br><br><b>A*</b> (1968) - heurystyczny, single-pair<br>• Wymóg: heurystyka dopuszczalna h(n) ≤ h*(n)<br>• f(n) = g(n) + h(n) (koszt dotarcia + szacowany koszt do celu)<br>• 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.<br><br><b>Problem:</b> Ujemna krawędź może później "poprawić" już zakończony wierzchołek.<br><br><b>Przykład:</b><br>S→C = 2 (Dijkstra ustala jako finalne)<br>S→A→B→C = 1 + (-5) + 1 = -3 < 2<br><br>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? <b>Heurystyka dopuszczalna (admissible):</b> h(n) ≤ h*(n)<br>czyli heurystyka nigdy nie przeszacowuje rzeczywistego kosztu do celu.<br><br><b>Dlaczego ważna:</b><br>• Gwarantuje optymalność - A* znajdzie najkrótszą ścieżkę<br>• Jeśli h(n) > h*(n), A* może pominąć optymalną ścieżkę<br><br><b>Przykłady:</b><br>• Odległość euklidesowa (linia prosta) - zawsze ≤ rzeczywistej trasy<br>• h(n) = 0 → A* = Dijkstra (bezpieczne, ale wolne)<br><br><b>Heurystyka spójna (consistent):</b> 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? <b>Redundancja</b> = ta sama informacja przechowywana w wielu miejscach.<br><br><b>Trzy anomalie:</b><br><br>1. <b>Anomalia wstawiania</b><br>Nie można dodać danych bez innych danych.<br>Przykład: nowy kurs bez studentów<br><br>2. <b>Anomalia usuwania</b><br>Usunięcie danych powoduje utratę innych informacji.<br>Przykład: usunięcie ostatniego studenta kursu = utrata info o kursie<br><br>3. <b>Anomalia modyfikacji</b><br>Zmiana wymaga aktualizacji wielu wierszy.<br>Przykład: zmiana nazwiska prowadzącego = update wielu rekordów<br><br><b>Rozwiązanie:</b> Normalizacja - dekompozycja tabel pyt03 BD2 redundancja anomalie
|
||||
|
||||
Wyjaśnij postacie normalne 1NF, 2NF, 3NF. <b>1NF - Pierwsza Postać Normalna</b><br>• Atomowość wartości (brak list/tablic w komórkach)<br>• Istnieje klucz główny<br><br><b>2NF - Druga Postać Normalna</b><br>• Spełnia 1NF<br>• Brak częściowych zależności (atrybut zależy od CAŁEGO klucza złożonego, nie od części)<br>• Dotyczy tylko tabel z kluczem wielokolumnowym<br><br><b>3NF - Trzecia Postać Normalna</b><br>• Spełnia 2NF<br>• Brak przechodnich zależności (A→B→C, gdzie B nie jest kluczem)<br>• Atrybuty wtórne zależą TYLKO od klucza<br><br><b>Hierarchia:</b> 5NF ⊂ 4NF ⊂ BCNF ⊂ 3NF ⊂ 2NF ⊂ 1NF pyt03 BD2 normalizacja postacie_normalne
|
||||
|
||||
Co to jest BCNF i czym różni się od 3NF? <b>BCNF (Boyce-Codd Normal Form):</b><br>Dla każdej nietrywialnej zależności funkcyjnej X→Y, X musi być nadkluczem.<br><br><b>Różnica od 3NF:</b><br>3NF dopuszcza: X→A gdzie A jest atrybutem pierwszym (należy do klucza)<br>BCNF: NIE dopuszcza - zawsze X musi być nadkluczem<br><br><b>Przykład naruszenia 3NF ale spełnienia BCNF:</b><br>Relacja z kluczami kandydującymi {A,B} i {A,C}<br>Zależność B→C narusza BCNF (B nie jest nadkluczem)<br>ale spełnia 3NF (C jest atrybutem pierwszym)<br><br><b>Praktyka:</b> 3NF zwykle wystarcza, BCNF może utrudnić dekompozycję pyt03 BD2 bcnf normalizacja
|
||||
|
||||
Co oznacza ACID w kontekście transakcji bazodanowych? <b>A - Atomicity (Atomowość)</b><br>Transakcja wykonuje się w całości lub wcale. Brak częściowych zmian.<br><br><b>C - Consistency (Spójność)</b><br>Dane przechodzą z jednego spójnego stanu w drugi. Reguły biznesowe zawsze spełnione.<br><br><b>I - Isolation (Izolacja)</b><br>Równoległe transakcje nie widzą swoich pośrednich zmian. Brak efektów ubocznych.<br><br><b>D - Durability (Trwałość)</b><br>Zatwierdzone zmiany przetrwają awarie systemu.<br><br><b>Przykład - przelew bankowy:</b><br>Bez A: awaria po odjęciu = utrata pieniędzy<br>Bez C: saldo ujemne mimo ograniczenia<br>Bez I: inna transakcja widzi stan pośredni<br>Bez D: po COMMIT dane giną pyt04 BD2 acid transakcje
|
||||
|
||||
Dlaczego baza danych stanowi dobry fundament systemów informatycznych? <b>1. Transakcyjność (ACID)</b><br>Gwarancja spójności i niezawodności operacji<br><br><b>2. Niezależność danych</b><br>• Fizyczna: zmiana indeksów/partycjonowania bez zmiany aplikacji<br>• Logiczna: zmiana schematu z minimalnym wpływem (widoki)<br><br><b>3. Współbieżność</b><br>Wiele aplikacji jednocześnie: blokady, MVCC, poziomy izolacji<br><br><b>4. Integralność</b><br>• Ograniczenia: PK, FK, CHECK, NOT NULL<br>• Wyzwalacze i procedury składowane<br><br><b>5. Optymalizacja</b><br>Automatyczny optymalizator zapytań, indeksy, statystyki<br><br><b>6. Bezpieczeństwo</b><br>Kontrola dostępu, audyt, szyfrowanie pyt04 BD2 bazy_danych fundament
|
||||
|
||||
Jakie są główne kategorie elementów STL i jak są powiązane? <b>4 główne kategorie:</b><br><br>1. <b>KONTENERY</b> - struktury przechowujące dane<br>• Sekwencyjne: vector, list, deque<br>• Asocjacyjne: map, set (drzewo czerwono-czarne)<br>• Nieuporządkowane: unordered_map (hash table)<br><br>2. <b>ITERATORY</b> - abstrakcja wskaźnika<br>• input, output, forward, bidirectional, random access<br>• Łączą kontenery z algorytmami<br><br>3. <b>ALGORYTMY</b> - operacje na danych<br>• sort, find, transform, copy, accumulate<br>• Działają na iteratorach, nie na kontenerach bezpośrednio<br><br>4. <b>FUNKTORY</b> - obiekty wywoływalne<br>• less<T>, greater<T>, plus<T><br>• Lambdy od C++11<br><br><b>Powiązanie:</b> Algorytmy operują na kontenerach PRZEZ iteratory, parametryzowane funktorami pyt05 PROI stl cpp
|
||||
|
||||
Kiedy użyć vector, a kiedy list w STL? <b>std::vector</b> - tablica dynamiczna<br>• Dostęp O(1) przez indeks<br>• Wstawianie na końcu O(1) amortyzowane<br>• Wstawianie w środku O(n) - przesunięcie elementów<br>• Cache-friendly (ciągła pamięć)<br>→ <b>Użyj gdy:</b> częsty dostęp losowy, głównie dodajesz na koniec<br><br><b>std::list</b> - lista dwukierunkowa<br>• Dostęp O(n) - brak indeksowania<br>• Wstawianie/usuwanie O(1) w dowolnym miejscu (po znalezieniu)<br>• Nie invaliduje iteratorów przy modyfikacji<br>→ <b>Użyj gdy:</b> częste wstawianie/usuwanie w środku, iteratory muszą pozostać ważne<br><br><b>Praktyka:</b> vector w 95% przypadków (cache matters!) pyt05 PROI stl vector_list
|
||||
|
||||
Różnica między map a unordered_map w STL? <b>std::map</b> (drzewo czerwono-czarne)<br>• Operacje: O(log n)<br>• Elementy posortowane według klucza<br>• Wymaga operator< dla klucza<br>• Stabilna wydajność<br><br><b>std::unordered_map</b> (tablica haszująca)<br>• Operacje: O(1) średnio, O(n) pesymistycznie<br>• Elementy nieposortowane<br>• Wymaga std::hash dla klucza<br>• Szybsza dla dużych zbiorów z dobrą funkcją hash<br><br><b>Kiedy map:</b><br>• Potrzebujesz posortowanych kluczy<br>• Iterujesz po zakresach<br><br><b>Kiedy unordered_map:</b><br>• Tylko lookup/insert (brak iteracji po kolejności)<br>• Duże zbiory danych pyt05 PROI stl map_unordered
|
||||
|
||||
Jaki jest cel three-way handshake w TCP? <b>Cele:</b><br>1. <b>Nawiązanie połączenia</b> - obie strony zgadzają się komunikować<br>2. <b>Synchronizacja ISN</b> - wymiana początkowych numerów sekwencyjnych<br>3. <b>Uzgodnienie parametrów</b> - MSS, Window Scale, SACK<br><br><b>Przebieg:</b><br>1. <b>Klient → SYN</b>, seq=x (stan: SYN_SENT)<br>2. <b>Serwer → SYN+ACK</b>, seq=y, ack=x+1 (stan: SYN_RECEIVED)<br>3. <b>Klient → ACK</b>, seq=x+1, ack=y+1 (stan: ESTABLISHED)<br><br><b>Dlaczego 3 kroki?</b><br>• 2 kroki: serwer nie wie czy klient otrzymał jego ISN<br>• 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? <b>Sequence Number (SEQ)</b> = numer pierwszego bajtu danych w segmencie.<br><br><b>Interpretacja:</b><br>• SEQ=1000, 500 bajtów danych → następny segment ma SEQ=1500<br>• Umożliwia składanie segmentów w kolejności<br>• Wykrywanie duplikatów i braków<br><br><b>Acknowledgment Number (ACK)</b> = numer NASTĘPNEGO oczekiwanego bajtu.<br>ACK=1500 oznacza: "otrzymałem wszystko do bajtu 1499"<br><br><b>Wartość początkowa (ISN):</b><br>• Losowa (nie 0!) ze względów bezpieczeństwa<br>• Zapobiega atakom typu session hijacking<br>• Historycznie: ISN = (timer * 250) mod 2³²<br>• Współcześnie: kryptograficznie losowy pyt08 SKM tcp seq_ack
|
||||
|
||||
Czym różni się proces od wątku? <b>PROCES</b><br>• Oddzielna przestrzeń adresowa (izolacja)<br>• Własny PCB (Process Control Block)<br>• Komunikacja: IPC (pipe, socket, shared memory)<br>• Przełączanie: kosztowne (zmiana kontekstu MMU)<br>• Awaria jednego nie wpływa na inne<br><br><b>WĄTEK</b><br>• Współdzieli przestrzeń adresową procesu<br>• Własny: stos, rejestry, PC<br>• Wspólne: kod, dane, heap, pliki<br>• Przełączanie: szybkie (bez zmiany tablic stron)<br>• Awaria jednego = awaria całego procesu<br><br><b>Analogia:</b><br>Proces = mieszkanie (własne zasoby)<br>Wątek = współlokator (wspólna kuchnia, łazienka) pyt09 SOI procesy_watki
|
||||
|
||||
Jakie są problemy synchronizacji wątków i jak je rozwiązać? <b>PROBLEMY:</b><br><br>1. <b>Wyścig (Race Condition)</b><br>Wynik zależy od kolejności wykonania<br>→ Rozwiązanie: sekcja krytyczna z mutexem<br><br>2. <b>Zakleszczenie (Deadlock)</b><br>Wątki czekają na siebie nawzajem<br>→ Rozwiązanie: kolejność blokad, timeout, wykrywanie<br><br>3. <b>Zagłodzenie (Starvation)</b><br>Wątek nigdy nie dostaje zasobu<br>→ Rozwiązanie: sprawiedliwe szeregowanie, kolejki<br><br>4. <b>Livelock</b><br>Wątki aktywne, ale nie robią postępu<br>→ Rozwiązanie: losowe opóźnienia<br><br><b>MECHANIZMY:</b><br>• Mutex, Semafor, Monitor<br>• Zmienna warunkowa (condition variable)<br>• Read-write lock<br>• Operacje atomowe pyt09 SOI synchronizacja watki
|
||||
|
||||
Warunki konieczne wystąpienia zakleszczenia (deadlock). <b>4 warunki Coffmana (wszystkie muszą być spełnione):</b><br><br>1. <b>Wzajemne wykluczanie (Mutual Exclusion)</b><br>Zasób może być używany tylko przez jeden proces<br><br>2. <b>Trzymaj i czekaj (Hold and Wait)</b><br>Proces trzyma zasoby czekając na kolejne<br><br>3. <b>Brak wywłaszczania (No Preemption)</b><br>Zasobów nie można odebrać siłą<br><br>4. <b>Cykliczne oczekiwanie (Circular Wait)</b><br>P1→P2→P3→P1 (cykl oczekiwań)<br><br><b>Zapobieganie:</b><br>Złam dowolny warunek:<br>• Ustal globalną kolejność zasobów (łamie 4)<br>• Żądaj wszystkich zasobów naraz (łamie 2)<br>• Pozwól na wywłaszczanie (łamie 3) pyt09 SOI deadlock warunki
|
||||
|
||||
Co to jest stronicowanie i segmentacja? Porównaj. <b>STRONICOWANIE (Paging)</b><br>• Pamięć dzielona na równe ramki (np. 4KB)<br>• Tablica stron: strona → ramka<br>• Fragmentacja wewnętrzna (ostatnia strona)<br>• Niewidoczne dla programisty<br>• Umożliwia pamięć wirtualną (swap)<br><br><b>SEGMENTACJA (Segmentation)</b><br>• Pamięć dzielona logicznie: kod, dane, stos<br>• Segmenty różnej wielkości<br>• Fragmentacja zewnętrzna<br>• Widoczna dla programisty (ochrona, współdzielenie)<br><br><b>PORÓWNANIE:</b><br>| Cecha | Stronic. | Segment. |<br>| Jednostka | Stała | Zmienna |<br>| Fragmentacja | Wewnętrzna | Zewnętrzna |<br>| Widoczność | Ukryta | Jawna |<br><br><b>Praktyka:</b> Często łączone (segmentacja + stronicowanie) pyt10 SOI zarzadzanie_pamiecia stronic_segment
|
||||
|
||||
Jakie standardy służą do modelowania procesów biznesowych? <b>BPMN 2.0</b> (Business Process Model and Notation)<br>• Główny standard dla procesów biznesowych<br>• Wykonywalne diagramy (silniki workflow)<br>• Elementy: zdarzenia (kółka), bramki (romby), czynności (prostokąty), przepływy<br>• Swimlanes = odpowiedzialności<br><br><b>UML</b> (Unified Modeling Language)<br>• Diagram aktywności ≈ flowchart<br>• Diagram przypadków użycia<br>• Głównie dla systemów IT, nie procesów biznesowych<br><br><b>EPC</b> (Event-driven Process Chain)<br>• Metodyka ARIS<br>• Zdarzenia → Funkcje → Zdarzenia<br>• Popularne w SAP<br><br><b>Praktyka:</b> BPMN dla biznesu, UML dla IT pyt11 ISA bpmn modelowanie_procesow
|
||||
|
||||
Czym różnią się bramki XOR, AND i OR w BPMN? <b>XOR (Exclusive Gateway) ◇</b><br>• Dokładnie JEDNA ścieżka wybrana<br>• Rozgałęzienie: warunki wzajemnie wykluczające<br>• Scalenie: czeka na pierwszą (nie synchronizuje)<br>• Przykład: Decyzja tak/nie<br><br><b>AND (Parallel Gateway) ◇+</b><br>• WSZYSTKIE ścieżki aktywowane/wymagane<br>• Rozgałęzienie: równoległe wykonanie<br>• Scalenie: synchronizacja (czeka na wszystkie)<br>• Przykład: Równoległa weryfikacja dokumentów<br><br><b>OR (Inclusive Gateway) ◇○</b><br>• JEDNA LUB WIĘCEJ ścieżek<br>• Rozgałęzienie: aktywuje te, których warunki spełnione<br>• Scalenie: czeka na wszystkie aktywowane<br>• Przykład: Opcjonalne kroki procesu pyt11 ISA bpmn bramki
|
||||
|
||||
Jakie są podstawowe sieciowe modele optymalizacji? <b>1. Najkrótsza ścieżka (Shortest Path)</b><br>min Σ cᵢⱼxᵢⱼ od s do t<br>Algorytmy: Dijkstra, Bellman-Ford, A*<br><br><b>2. Maksymalny przepływ (Max Flow)</b><br>max przepływ od źródła do ujścia<br>Ograniczenie: przepustowość krawędzi<br>Algorytmy: Ford-Fulkerson, Edmonds-Karp<br><br><b>3. Minimalny koszt przepływu (Min Cost Flow)</b><br>Połączenie: przepływ + koszt jednostkowy<br>Zastosowanie: transport, przydział zadań<br><br><b>4. Problem przydziału (Assignment)</b><br>n pracowników → n zadań, min koszt<br>Każdy pracownik = jedno zadanie<br>Algorytm: Metoda węgierska O(n³)<br><br><b>5. Problem komiwojażera (TSP)</b><br>Najkrótsza trasa przez wszystkie miasta<br>NP-trudny! pyt12 WSYZ optymalizacja sieciowa
|
||||
|
||||
Czym różni się system agentowy od systemu aktorów? <b>SYSTEM AGENTOWY</b><br>• Agent = autonomiczny, reaktywny, proaktywny, społeczny<br>• Architektura BDI (Beliefs-Desires-Intentions)<br>• Komunikacja: FIPA-ACL (semantyka, performatywy)<br>• Cel: symulacja, AI, negocjacje<br>• Przykład: JADE, Jason<br><br><b>SYSTEM AKTORÓW</b><br>• Aktor = lekka jednostka obliczeniowa<br>• Komunikacja: asynchroniczne wiadomości (fire-and-forget)<br>• Brak stanu współdzielonego (share nothing)<br>• Cel: współbieżność, skalowalność, fault-tolerance<br>• Przykład: Akka, Erlang/OTP<br><br><b>Kluczowa różnica:</b><br>Agent = inteligentny, autonomiczny, ma cele<br>Aktor = jednostka obliczeniowa, reaktywna, bez "inteligencji" pyt13 ISA agenty_aktorzy
|
||||
|
||||
Co to jest architektura BDI w systemach agentowych? <b>BDI = Beliefs-Desires-Intentions</b><br><br><b>Beliefs (Przekonania)</b><br>Co agent wie o świecie<br>Baza wiedzy, może być niepełna/błędna<br><br><b>Desires (Pragnienia)</b><br>Cele, które agent chce osiągnąć<br>Mogą być sprzeczne ze sobą<br><br><b>Intentions (Intencje)</b><br>Wybrane cele, do których agent się zobowiązał<br>Plany działania<br><br><b>Cykl decyzyjny:</b><br>1. Percepcja → aktualizuj Beliefs<br>2. Generuj opcje (desires)<br>3. Deliberacja → wybierz intentions<br>4. Wykonaj plan<br>5. Powtórz<br><br><b>Zastosowania:</b> robotyka, symulacja zachowań, gry pyt13 ISA bdi agenty
|
||||
|
||||
Jakie są algorytmy koordynacji w systemach wieloagentowych? <b>1. Contract Net Protocol (CNET)</b><br>Manager ogłasza zadanie → Agenty składają oferty → Wybór najlepszej<br>Zastosowanie: alokacja zadań<br><br><b>2. Aukcje wieloagentowe</b><br>• Angielska (rosnąca), holenderska (malejąca)<br>• Vickrey (druga cena) - zachęca do prawdziwych ofert<br>• Kombinatoryczne - pakiety zasobów<br><br><b>3. Protokoły konsensusu</b><br>Agenty uzgadniają wspólną wartość<br>ẋᵢ = Σⱼ aᵢⱼ(xⱼ - xᵢ) → zbieżność do średniej<br><br><b>4. Multi-Agent Reinforcement Learning</b><br>• Independent Q-learning<br>• Cooperative/Competitive<br>• Emergent behavior pyt14 ISA wieloagentowe koordynacja
|
||||
|
||||
Co to jest framework TOGAF w modelowaniu architektury? <b>TOGAF = The Open Group Architecture Framework</b><br><br><b>ADM (Architecture Development Method):</b><br>Cykliczny proces 8 faz:<br>1. Preliminary - przygotowanie<br>2. Vision - wizja architektury<br>3. Business Architecture - procesy biznesowe<br>4. IS Architecture - dane + aplikacje<br>5. Technology Architecture - infrastruktura<br>6. Opportunities & Solutions - planowanie migracji<br>7. Migration Planning - szczegółowy plan<br>8. Governance - zarządzanie zmianami<br><br><b>4 domeny architektury:</b><br>• Business, Data, Application, Technology (BDAT)<br><br><b>Praktyka:</b> Standard korporacyjny, duże organizacje pyt15 ISA togaf architektura
|
||||
|
||||
Porównaj wzorce architektoniczne: Layers, Microservices, Event-Driven. <b>LAYERS (Warstwowa)</b><br>Prezentacja → Logika → Dane<br>✓ Prostota, separacja<br>✗ Monolityczna, trudna skalowalność<br><br><b>MICROSERVICES</b><br>Małe, niezależne serwisy<br>✓ Skalowalność, niezależny deployment<br>✓ Różne technologie<br>✗ Złożoność operacyjna, distributed transactions<br>Wymaga: API Gateway, Service Discovery<br><br><b>EVENT-DRIVEN (EDA)</b><br>Komponenty komunikują się przez zdarzenia<br>✓ Luźne powiązania, reaktywność<br>✓ Skalowalność, CQRS/Event Sourcing<br>✗ Trudne debugowanie, eventual consistency<br>Wymaga: Message Broker (Kafka, RabbitMQ)<br><br><b>Praktyka:</b> Często łączone (microservices + events) pyt16 ISA wzorce_architektoniczne
|
||||
|
||||
Jakie są warunki KKT w optymalizacji nieliniowej? <b>KKT = Karush-Kuhn-Tucker</b><br><br>Dla problemu: min f(x), g(x) ≤ 0, h(x) = 0<br><br><b>Warunki konieczne optimum:</b><br><br>1. <b>Stacjonarność:</b><br>∇f(x*) + Σμᵢ∇gᵢ(x*) + Σλⱼ∇hⱼ(x*) = 0<br><br>2. <b>Dopuszczalność pierwotna:</b><br>g(x*) ≤ 0, h(x*) = 0<br><br>3. <b>Dopuszczalność dualna:</b><br>μᵢ ≥ 0 (dla ograniczeń nierównościowych)<br><br>4. <b>Complementary slackness:</b><br>μᵢ · gᵢ(x*) = 0 (aktywne lub μ=0)<br><br><b>Dla wypukłych:</b> KKT są wystarczające!<br><b>Dla niewypukłych:</b> tylko konieczne (lokalne opt.) pyt17 MOM kkt optymalizacja_nieliniowa
|
||||
|
||||
Czym różni się metoda simpleks od interior point? <b>METODA SIMPLEKS</b><br>• Porusza się po wierzchołkach wielościanu<br>• Iteracja: przejście do lepszego sąsiada<br>• Złożoność: O(2ⁿ) pesymistycznie<br>• W praktyce: bardzo szybka dla większości problemów<br>• Problemy zdegenerowane: cycling<br><br><b>INTERIOR POINT (bariery)</b><br>• Porusza się WEWNĄTRZ wielościanu<br>• Zbliża się do granicy przy optimum<br>• Złożoność: wielomianowa O(n³·L)<br>• Lepsza dla bardzo dużych problemów<br>• Wymaga więcej pamięci<br><br><b>Praktyka:</b><br>Simplex: małe/średnie LP, basis info<br>Interior Point: duże LP, QP, SDP pyt18 MOM simplex lp
|
||||
|
||||
Jak działa parametryzacja MFCC w rozpoznawaniu mowy? <b>MFCC = Mel-Frequency Cepstral Coefficients</b><br><br><b>Pipeline przetwarzania:</b><br>1. <b>Pre-emphasis:</b> y[n] = x[n] - αx[n-1] (wzmocnienie wysokich częstotliwości)<br>2. <b>Ramkowanie:</b> okna 20-40ms z overlap<br>3. <b>FFT:</b> spektrum częstotliwościowe<br>4. <b>Mel filterbank:</b> 26-40 filtrów w skali mel (nieliniowa, jak ucho)<br>5. <b>Log:</b> logarytm energii filtrów<br>6. <b>DCT:</b> 12-13 współczynników cepstralnych<br><br><b>Rozszerzenia:</b><br>• Δ (pierwsza pochodna) - dynamika<br>• ΔΔ (druga pochodna)<br>• Razem: 39 cech (13 + 13 + 13)<br><br><b>Dlaczego mel?</b> 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. <b>HMM (Hidden Markov Model)</b><br>• Stany ukryte → emisje (GMM)<br>• Algorytmy: Viterbi, Forward-Backward, Baum-Welch<br>• Zalety: interpretowalność, mało danych<br>• Wady: założenie Markowa, ręczne features<br><br><b>DNN-HMM (Hybrid)</b><br>• DNN zastępuje GMM do modelowania emisji<br>• HMM nadal modeluje sekwencję<br>• Breakthrough: 2012 (Hinton et al.)<br><br><b>End-to-End Deep Learning</b><br>• CTC (Connectionist Temporal Classification)<br>• Attention/Transformer (Seq2Seq)<br>• Brak alignmentu, brak HMM<br>• Przykłady: DeepSpeech, Whisper<br><br><b>Praktyka 2024:</b> Transformery dominują (Whisper, Wav2Vec) pyt20 RUM hmm deep_learning mowa
|
||||
|
||||
Co to jest agent upostaciowiony (embodied agent)? <b>Embodied Agent = agent z "ciałem" w fizycznym świecie</b><br><br>Różnica od agenta symulowanego:<br>• Interakcja z rzeczywistym środowiskiem<br>• Sensory: kamery, LIDAR, enkodery<br>• Efektory: silniki, chwytaki<br>• Niepewność: szum, opóźnienia, awarie<br><br><b>Architektura (typowa):</b><br>1. Percepcja: sensory → model świata<br>2. Planowanie: cel → sekwencja akcji<br>3. Wykonanie: akcje → efektory<br>4. Feedback: monitorowanie i korekta<br><br><b>Frameworki:</b><br>• ROS (Robot Operating System)<br>• BDI dla robotów (Jason + ROS)<br><br><b>Wyzwania:</b><br>• Real-time constraints<br>• Niepewność percepcji<br>• Bezpieczeństwo (safety-critical) pyt21 SIU embodied_agent roboty
|
||||
|
||||
Jakie są poziomy języków programowania robotów? <b>Hierarchia (od wysokiego do niskiego):</b><br><br>1. <b>Task Level</b> (najwyższy)<br>"Zmontuj produkt A" - planowanie zadań<br>AI, reasoning<br><br>2. <b>Robot Level</b><br>Ruchy w przestrzeni kartezjańskiej<br>Ścieżki, trajektorie end-effector<br><br>3. <b>Motion Level</b><br>Kinematyka, trajektorie stawów<br>Planowanie ruchu (RRT, A*)<br><br>4. <b>Servo Level</b> (najniższy)<br>Sterowanie silnikami<br>PID, kontrola pozycji/prędkości<br><br><b>Języki przemysłowe:</b><br>• RAPID (ABB)<br>• KRL (KUKA)<br>• Karel (FANUC)<br>• URScript (Universal Robots)<br><br><b>Standardy:</b> IEC 61131-3 (PLC), ROS (research) pyt22 SIU jezyki_robotow programowanie
|
||||
|
||||
Jak działają zegary logiczne Lamporta? <b>Problem:</b> Brak globalnego zegara w systemach rozproszonych<br><br><b>Algorytm:</b><br>Każdy proces Pᵢ ma licznik Cᵢ:<br>1. Przed zdarzeniem lokalnym: Cᵢ++<br>2. Wysyłanie msg: Cᵢ++, dołącz timestamp<br>3. Odbiór msg z timestamp t: Cᵢ = max(Cᵢ, t) + 1<br><br><b>Właściwości:</b><br>✓ a → b ⟹ C(a) < C(b) (porządek zachowany)<br>✗ C(a) < C(b) ⟹ a → b (NIE! mogą być współbieżne)<br><br><b>Zegary wektorowe:</b><br>Wektor V[1..N] dla N procesów<br>V[i] = wiedza procesu o wszystkich<br>a → b ⟺ V(a) < V(b) (obustronna implikacja!)<br><br><b>Zastosowanie:</b> Causal ordering, wykrywanie współbieżności pyt23 ERSMS zegary_logiczne lamport
|
||||
|
||||
Czym różni się linearizability od eventual consistency? <b>LINEARIZABILITY (najsilniejsza)</b><br>• Operacja wygląda jakby wykonała się atomowo<br>• "Globalny porządek czasu rzeczywistego"<br>• Wynik natychmiast widoczny wszędzie<br>• Kosztowna: wymaga koordynacji (Paxos, Raft)<br>• Przykład: transakcje bankowe<br><br><b>EVENTUAL CONSISTENCY (najsłabsza)</b><br>• "Ostatecznie wszystkie repliki się zsynchronizują"<br>• Brak gwarancji kiedy<br>• Możliwe stare odczyty<br>• Wysoka dostępność (AP w CAP)<br>• Przykład: DNS, caching, social media feeds<br><br><b>Pomiędzy:</b><br>• Sequential: globalny porządek, nie real-time<br>• Causal: porządek przyczynowy zachowany pyt24 ERSMS spojnosc consistency
|
||||
|
||||
Co to jest Branch and Bound i jak działa? <b>Branch and Bound = metoda dokładna dla MIP</b><br><br><b>Idea:</b><br>1. Relaksacja LP: rozwiąż bez ograniczeń całkowitoliczbowych<br>2. Jeśli rozwiązanie całkowite → STOP<br>3. BRANCH: wybierz zmienną ułamkową xᵢ<br>4. Utwórz 2 podproblemy: xᵢ ≤ ⌊x*ᵢ⌋ i xᵢ ≥ ⌈x*ᵢ⌉<br>5. BOUND: jeśli LP ≤ best known → prune<br><br><b>Przycinanie (pruning):</b><br>• Infeasible: brak rozwiązania LP<br>• Optimality: LP ≤ incumbent<br>• Integrality: znalezione całkowite<br><br><b>Strategie wyboru węzła:</b><br>• Best-first (najlepsze ograniczenie)<br>• Depth-first (mniej pamięci)<br>• Best-estimate (heurystyka) pyt25 MOD branch_and_bound mip
|
||||
|
||||
Jakie są główne narzędzia do optymalizacji dyskretnej? <b>SOLVERY MIP (komercyjne):</b><br>• CPLEX (IBM) - najszybszy<br>• Gurobi - bardzo szybki, dobre API<br><br><b>SOLVERY MIP (open source):</b><br>• SCIP - framework rozszerzalny<br>• CBC (COIN-OR) - dobry darmowy<br>• HiGHS - nowoczesny<br><br><b>CONSTRAINT PROGRAMMING:</b><br>• CP-SAT (Google OR-Tools) - bardzo szybki<br>• Gecode - akademicki<br>• MiniZinc - język modelowania<br><br><b>JĘZYKI MODELOWANIA:</b><br>• Pyomo (Python)<br>• JuMP (Julia)<br>• AMPL, GAMS (komercyjne)<br><br><b>Kiedy CP vs MIP?</b><br>CP: scheduling, alldifferent, kombinatoryczne<br>MIP: silna relaksacja LP, ciągłe zmienne pyt26 MOD solvery narzedzia
|
||||
|
||||
Dlaczego jakość modelu danych jest krytyczna? <b>Model danych = fundament systemu</b><br>Zmiana modelu → kaskadowe zmiany wszędzie<br><br><b>Konsekwencje złego modelu:</b><br><br>1. <b>Wydajność:</b><br>JOIN na stringach vs integer PK/FK<br>Brak indeksów, denormalizacja → full scans<br><br>2. <b>Spójność:</b><br>Redundancja → anomalie (insert, update, delete)<br>Brak constraints → nieprawidłowe dane<br><br>3. <b>Utrzymywalność:</b><br>Niezrozumiałe nazwy (col1, temp_field)<br>Brak dokumentacji ERD<br><br>4. <b>Koszty naprawy:</b><br>Analiza: tanie<br>Design: średnie<br>Implementacja: drogie<br>Produkcja: BARDZO drogie (migracje!) pyt27 MODA model_danych jakosc
|
||||
|
||||
Jakie są fazy ewolucji modelu danych? <b>1. KONCEPTUALNY (CDM)</b><br>• CO przechowujemy (biznes)<br>• Zrozumiały dla nietechnicznych<br>• Encje i relacje (brak atrybutów szczegółowych)<br>• ERD uproszczony<br><br><b>2. LOGICZNY (LDM)</b><br>• JAK strukturyzujemy<br>• Atrybuty, typy logiczne, klucze PK/FK<br>• Normalizacja (min 3NF)<br>• Niezależny od DBMS<br><br><b>3. FIZYCZNY (PDM)</b><br>• JAK implementujemy<br>• Typy danych specyficzne dla DBMS<br>• Indeksy, partycjonowanie, tablespaces<br>• Optymalizacja wydajności<br><br><b>Transformacja:</b><br>CDM → LDM: dodaj atrybuty, normalizuj<br>LDM → PDM: dostosuj do DBMS, zoptymalizuj pyt28 MODA fazy_modelu ewolucja
|
||||
|
||||
Co mówi prawo Amdahla o przyśpieszeniu równoległym? <b>Formuła Amdahla:</b><br>S(n) = 1 / [(1-p) + p/n]<br><br>Gdzie:<br>• p = część równoległa (0-1)<br>• n = liczba procesorów<br>• (1-p) = część sekwencyjna<br><br><b>Maksymalne przyśpieszenie (n→∞):</b><br>S_max = 1/(1-p)<br><br><b>Przykład:</b><br>90% równoległe (p=0.9):<br>S_max = 1/0.1 = 10x<br>Nawet z nieskończoną liczbą CPU!<br><br><b>Wniosek:</b> Część sekwencyjna LIMITUJE przyśpieszenie<br><br><b>Prawo Gustafsona:</b> Skaluj problem, nie przyśpieszenie<br>S_scaled = 1 - p + p·n (liniowe z n!) pyt29 PORR amdahl rownolegle
|
||||
|
||||
Jakie są etapy tworzenia modelu optymalizacyjnego? <b>1. ANALIZA PROBLEMU</b><br>• Zrozum dziedzinę biznesową<br>• Zidentyfikuj decyzje, cele, ograniczenia<br><br><b>2. ZMIENNE DECYZYJNE</b><br>• Co kontrolujemy? (x, y, z...)<br>• Typy: ciągłe, całkowite, binarne<br>• Zmienne muszą być mierzalne i kontrolowalne<br><br><b>3. FUNKCJA CELU</b><br>• min/max f(x)<br>• Co optymalizujemy? (koszt, zysk, czas)<br><br><b>4. OGRANICZENIA</b><br>• g(x) ≤ 0, h(x) = 0<br>• Zasoby, fizyka, logika biznesowa<br><br><b>5. WALIDACJA</b><br>• Extreme cases<br>• Known solutions<br>• Analiza wrażliwości<br><br><b>Problemy:</b> Big-M (słaba relaksacja), symetria pyt30 MOM modelowanie optymalizacja
|
||||
|
||||
Dlaczego wypukłość jest ważna w optymalizacji? <b>Problem wypukły:</b><br>• min f(x) gdzie f wypukła<br>• Ograniczenia definiują zbiór wypukły<br><br><b>Kluczowa właściwość:</b><br>LOKALNE optimum = GLOBALNE optimum<br><br><b>Konsekwencje:</b><br>1. Gwarancja znalezienia najlepszego rozwiązania<br>2. Algorytmy wielomianowe (interior point)<br>3. Silna dualność (zero gap)<br>4. KKT wystarczające (nie tylko konieczne)<br><br><b>Niewypukłe problemy:</b><br>• Wiele minimów lokalnych<br>• NP-trudne<br>• Tylko lokalne optimum (gradient, Newton)<br>• Metaheurystyki: SA, GA (bez gwarancji)<br><br><b>Praktyka:</b> Przekształć w wypukły jeśli możliwe! pyt31 MOM wypuklosc optymalizacja
|
||||
|
||||
Różnica między komunikacją blokującą a nieblokującą w MPI. <b>BLOKUJĄCA</b><br>• MPI_Send, MPI_Recv<br>• Zwraca gdy operacja "zakończona"<br>• Bufor można bezpiecznie użyć ponownie<br>• Ryzyko deadlocka przy złej kolejności<br><br><b>NIEBLOKUJĄCA</b><br>• MPI_Isend, MPI_Irecv<br>• Zwraca natychmiast (request handle)<br>• Operacja w tle<br>• MPI_Wait/MPI_Test do sprawdzenia<br>• Overlapping: obliczenia + komunikacja<br><br><b>Deadlock example:</b><br>P0: Send(to=1); Recv(from=1);<br>P1: Send(to=0); Recv(from=0);<br>→ Oba czekają na recv, nikt nie wysyła<br><br><b>Rozwiązanie:</b> MPI_Sendrecv lub nieblokujące pyt32 PORR mpi blokujace
|
||||
|
||||
Jak działa model Publish-Subscribe? <b>Architektura:</b><br>PUBLISHERS → BROKER → SUBSCRIBERS<br><br><b>Cechy:</b><br>• Luźne powiązanie (publisher nie zna subscriberów)<br>• Asynchroniczność<br>• Skalowalność 1:N, N:M<br><br><b>Typy subskrypcji:</b><br>• Topic-based: subscribe("orders")<br>• Content-based: price > 100<br>• Hierarchical: home/+/temperature (wildcards)<br><br><b>QoS (Quality of Service):</b><br>• QoS 0: at most once (fire-and-forget)<br>• QoS 1: at least once (możliwe duplikaty)<br>• QoS 2: exactly once (4-way handshake)<br><br><b>Implementacje:</b><br>• Apache Kafka (log-based, high throughput)<br>• RabbitMQ (AMQP, flexible routing)<br>• MQTT (IoT, lightweight) pyt33 PSD pub_sub messaging
|
||||
|
||||
Czym charakteryzuje się przetwarzanie danych strumieniowych? <b>Strumień vs Batch:</b><br>• Unbounded (nieskończony)<br>• Ciągłe napływanie danych<br>• Wymagana niska latencja<br>• Brak możliwości przechowania wszystkiego<br><br><b>Windowing (okna czasowe):</b><br>• Tumbling: rozłączne, stała wielkość<br>• Sliding: nakładające się<br>• Session: oparte na aktywności<br>• Global: jedno okno, trigger decyduje<br><br><b>Event Time vs Processing Time:</b><br>• Event time: kiedy zdarzenie nastąpiło<br>• Processing time: kiedy dotarło<br>• Watermark: znacznik postępu event time<br><br><b>Platformy:</b><br>• Apache Flink (stateful, exactly-once)<br>• Kafka Streams (library, Kafka ecosystem)<br>• Apache Spark Streaming (micro-batch) pyt34 PSD streaming analityka
|
||||
|
||||
Co to są systemy cyber-fizyczne (CPS)? <b>CPS = Cyber + Physical w pętli sprzężenia</b><br><br><b>Komponenty:</b><br>• Cyber: obliczenia, komunikacja, sterowanie<br>• Physical: dynamika, fizyka, środowisko<br>• Sensors + Actuators = połączenie<br><br><b>Specyfika modelowania:</b><br>• Hybrid systems: ciągłe ODE + dyskretne automaty<br>• Real-time constraints<br>• Niepewność, szum, opóźnienia<br><br><b>Przykład - termostat:</b><br>Mode OFF: Ṫ = -α(T-Tₑ)<br>Mode ON: Ṫ = β - α(T-Tₑ)<br>Przełączanie: T<Tₗ → ON, T>Tₕ → OFF<br><br><b>Consensus w sieci agentów:</b><br>ẋᵢ = Σⱼ aᵢⱼ(xⱼ - xᵢ) → zbieżność do średniej<br><br><b>Przykłady:</b> autonomiczne pojazdy, smart grid, Industry 4.0 pyt35 SIU cps cyber_fizyczne
|
||||
|
||||
Jakie są elementy uczenia ze wzmocnieniem? <b>Model RL:</b><br>Agent ↔ Environment<br>Agent: akcja aₜ → Environment<br>Environment: stan sₜ₊₁, nagroda rₜ → Agent<br><br><b>Elementy:</b><br>• State (s): obserwacja środowiska<br>• Action (a): decyzja agenta<br>• Reward (r): sygnał zwrotny<br>• Policy π(a|s): strategia<br>• Value V(s), Q(s,a): oczekiwana nagroda<br>• Discount γ: ważność przyszłych nagród<br><br><b>MDP (Markov Decision Process):</b><br>P(sₜ₊₁|sₜ,aₜ) - tylko obecny stan ma znaczenie<br><br><b>Algorytmy:</b><br>• Value-based: Q-learning, DQN<br>• Policy-based: REINFORCE, PPO<br>• Actor-Critic: A2C, A3C, SAC<br><br><b>Cel:</b> max E[Σ γᵗrₜ] pyt36 SIU rl uczenie_wzmocnienie
|
||||
|
||||
Porównaj modele sieci złożonych: ER, Watts-Strogatz, Barabási-Albert. <b>ERDŐS-RÉNYI (Random)</b><br>G(n,p) - krawędź z prawdop. p<br>• Rozkład stopni: Poisson<br>• Niski clustering C=p<br>• Krótka ścieżka L~log(n)<br>• Brak hubów<br><br><b>WATTS-STROGATZ (Small-World)</b><br>Regularna kratka + losowe przepinanie<br>• Wysoki clustering (zachowany)<br>• Krótka ścieżka (dodana)<br>• "6 degrees of separation"<br><br><b>BARABÁSI-ALBERT (Scale-Free)</b><br>Preferential attachment (rich-get-richer)<br>• Rozkład: power-law P(k)~k⁻ᵞ<br>• Huby (węzły o bardzo wysokim stopniu)<br>• Odporność na losowe awarie<br>• Wrażliwość na celowane ataki<br><br><b>Rzeczywiste sieci:</b> cechy BA + WS (huby + clustering) pyt37 TASS sieci_zlozone modele
|
||||
|
||||
Co to jest projekcja grafu dwudzielnego? <b>Graf dwudzielny:</b><br>Dwa rozłączne zbiory U, V<br>Krawędzie tylko między U i V<br>Przykład: dokumenty ↔ słowa<br><br><b>Projekcja:</b><br>Przekształcenie na graf jednomodowy<br>P = B·Bᵀ (projekcja na U)<br>Węzły U połączone jeśli mają wspólnego sąsiada w V<br><br><b>Metody ważenia krawędzi:</b><br>• Simple count: |N(i) ∩ N(j)|<br>• Jaccard: |∩| / |∪|<br>• Cosine: dot product / normy<br>• TF-IDF: rzadkie słowa ważniejsze<br><br><b>Zastosowanie - grupowanie dokumentów:</b><br>1. Graf: dokumenty ↔ słowa<br>2. TF-IDF weights<br>3. Projekcja na dokumenty<br>4. Clustering na projekcji pyt38 TASS projekcje grafy_dwudzielne
|
||||
|
||||
Jakie są metody segmentacji obrazu? <b>KLASYCZNE:</b><br><br>1. <b>Thresholding:</b> Otsu (automatyczny próg)<br>2. <b>Region Growing:</b> seed → ekspansja po podobnych<br>3. <b>Watershed:</b> obraz jako topografia, zalewanie<br>4. <b>Graph-based:</b> Normalized Cuts, Laplacian<br><br><b>DEEP LEARNING:</b><br><br>1. <b>FCN (Fully Convolutional):</b><br>Brak FC layers → dowolny rozmiar wejścia<br><br>2. <b>U-Net:</b><br>Encoder-decoder + skip connections<br>Świetne dla małych datasetów (medycyna)<br><br>3. <b>DeepLab:</b><br>Atrous/dilated convolutions<br>ASPP (multi-scale)<br><br><b>Typy segmentacji:</b><br>• Semantic: klasa dla piksela<br>• Instance: rozróżnia instancje<br>• Panoptic: unified (semantic + instance) pyt39 TWM segmentacja cv
|
||||
|
||||
Jak działa detekcja obiektów (klasyczne vs deep learning)? <b>KLASYCZNE:</b><br><br>1. <b>Sliding Window + HOG/SIFT:</b><br>Przesuwaj okno, klasyfikuj fragment<br>Problem: O(scales × positions) - WOLNE<br><br>2. <b>Viola-Jones (2001):</b><br>Haar features + AdaBoost cascade<br>Integral image → O(1) per feature<br>Real-time face detection<br><br><b>DEEP LEARNING:</b><br><br>1. <b>Two-stage (R-CNN family):</b><br>Region proposals → CNN → classify<br>Faster R-CNN: RPN (learned proposals)<br><br>2. <b>One-stage:</b><br>YOLO: grid cells, predict directly<br>SSD: multi-scale feature maps<br>Szybsze, mniej dokładne<br><br><b>Metryki:</b> mAP (mean Average Precision), IoU pyt40 TWM detekcja_obiektow cv
|
||||
|
||||
Co to jest dominacja stochastyczna pierwszego i drugiego rzędu? <b>FSD (First-order Stochastic Dominance):</b><br>A ≥_FSD B ⟺ F_A(x) ≤ F_B(x) dla wszystkich x<br><br>• A "zawsze lepsze" od B<br>• KAŻDY racjonalny decydent (U'≥0) wybierze A<br>• Najsilniejsza, rzadko występuje<br><br><b>SSD (Second-order):</b><br>A ≥_SSD B ⟺ ∫F_A(t)dt ≤ ∫F_B(t)dt dla wszystkich x<br><br>• Dla decydentów risk-averse (U'≥0, U''≤0)<br>• Słabsza niż FSD, częstsza<br>• CDF mogą się przecinać, ale skumulowane pole - nie<br><br><b>Zastosowanie:</b><br>Porównanie portfeli/loterii BEZ znajomości dokładnej funkcji użyteczności<br>FSD/SSD → eliminacja zdominowanych opcji pyt42 WDWR dominacja_stochastyczna
|
||||
|
||||
Jak klasyfikuje się zadania szeregowania (notacja Grahama)? <b>Notacja: α | β | γ</b><br><br><b>α - Środowisko maszynowe:</b><br>• 1: jedna maszyna<br>• Pm: m maszyn równoległych<br>• Fm: flow shop z m maszynami<br>• Jm: job shop z m maszynami<br><br><b>β - Charakterystyki zadań:</b><br>• rⱼ: release dates<br>• dⱼ: due dates<br>• prec: precedence constraints<br>• pmtn: preemption allowed<br>• pⱼ=1: unit processing times<br><br><b>γ - Kryterium:</b><br>• Cmax: makespan (max completion)<br>• ΣCⱼ: total completion time<br>• Lmax: max lateness<br>• ΣTⱼ: total tardiness<br><br><b>Przykład:</b> 1|rⱼ|Lmax - jedna maszyna, release dates, minimalizuj max spóźnienie pyt43 ZBOP szeregowanie scheduling
|
||||
|
||||
Co to jest efekt byczego bicza (bullwhip effect)? <b>Bullwhip Effect = amplifikacja wahań popytu w górę łańcucha dostaw</b><br><br><b>Mechanizm:</b><br>Mały popyt klienta → większe wahania detalisty → jeszcze większe dystrybutora → ogromne u producenta<br><br><b>Przyczyny:</b><br>1. Prognozowanie popytu (każdy poziom dodaje safety stock)<br>2. Batching zamówień (nie zamawiaj po 1 sztuce)<br>3. Wahania cen (promocje → stockpiling)<br>4. Rationing (przy niedoborze zawyżanie zamówień)<br><br><b>Konsekwencje:</b><br>• Nadmiar zapasów lub stockouts<br>• Nieefektywna produkcja<br>• Wysokie koszty<br><br><b>Rozwiązania:</b><br>• Współdzielenie informacji (VMI, CPFR)<br>• Everyday Low Price (brak promocji)<br>• Smaller batches pyt44 ZBOP bullwhip lancuch_dostaw
|
||||
|
||||
Co to jest model EOQ i jakie ma założenia? <b>EOQ = Economic Order Quantity</b><br><br><b>Formuła:</b><br>Q* = √(2KD/h)<br><br>Gdzie:<br>• K = koszt zamówienia (stały)<br>• D = roczny popyt<br>• h = koszt utrzymania jednostki/rok<br><br><b>Założenia:</b><br>• Popyt stały i znany<br>• Lead time stały i znany<br>• Natychmiastowa dostawa<br>• Brak braków (stockouts)<br>• Brak rabatów ilościowych<br><br><b>Całkowity koszt:</b><br>TC = (K × D/Q) + (h × Q/2)<br>Ordering cost + Holding cost<br><br><b>W praktyce:</b> Punkt bazowy, modyfikowany dla:<br>• Losowy popyt → safety stock<br>• Lead time → reorder point<br>• Rabaty → quantity discounts model pyt44 ZBOP eoq zapasy
|
||||
|
||||
185
pytania/generate_anki.py
Normal file
185
pytania/generate_anki.py
Normal file
@ -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 = "<br>".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 = "<br>".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'<b>\1</b>', text)
|
||||
text = re.sub(r'\*(.+?)\*', r'<i>\1</i>', text)
|
||||
# Handle newlines - convert to <br> for Anki
|
||||
text = text.replace('\n', '<br>')
|
||||
# Remove multiple <br>
|
||||
text = re.sub(r'(<br>)+', '<br>', text)
|
||||
# Remove leading/trailing <br>
|
||||
text = re.sub(r'^<br>|<br>$', '', 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()
|
||||
288
pytania/generate_anki_final.py
Normal file
288
pytania/generate_anki_final.py
Normal file
@ -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'<b>\1</b>', text)
|
||||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', 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"<li>{cleaned}</li>"
|
||||
html += f"</{tag}>"
|
||||
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## [<5B>🎯]|\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 = "<b>Kluczowe zagadnienia:</b>" + 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"<b>{term}</b>: {desc.strip()}")
|
||||
else:
|
||||
answer_parts.append(f"<b>{term}</b>")
|
||||
|
||||
# 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 = "<table><tr><th>Aspekt</th><th>Wartość</th></tr>"
|
||||
for aspect, value in items[:6]:
|
||||
comparison_html += f"<tr><td>{clean_text(aspect)}</td><td>{clean_text(value)}</td></tr>"
|
||||
comparison_html += "</table>"
|
||||
|
||||
# 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', '<br>'),
|
||||
'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()
|
||||
183
pytania/generate_anki_v2.py
Normal file
183
pytania/generate_anki_v2.py
Normal file
@ -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## [^<5E>]|\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'<b>\1</b>', text)
|
||||
text = re.sub(r'\*(.+?)\*', r'<i>\1</i>', text)
|
||||
|
||||
# Clean up special characters
|
||||
text = text.replace('\t', ' ')
|
||||
text = text.replace('"', '"')
|
||||
|
||||
# Handle newlines - convert to <br>
|
||||
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 = "<ul>" + "".join([f"<li>{clean_html(p)}</li>" for p in key_points]) + "</ul>"
|
||||
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()
|
||||
257
pytania/generate_anki_v3.py
Normal file
257
pytania/generate_anki_v3.py
Normal file
@ -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'<b>\1</b>', text)
|
||||
text = re.sub(r'(?<!\*)\*([^*]+)\*(?!\*)', r'<i>\1</i>', 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"<b>{sub_header.strip()}</b>: {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"• <b>{term.strip()}</b>: {desc.strip()}")
|
||||
else:
|
||||
lines.append(f"• <b>{term.strip()}</b>")
|
||||
|
||||
# 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 '<br>'.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"<b>Automat Skończony (FA)</b>: {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"<b>Automat ze Stosem (PDA)</b>: {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"<b>Maszyna Turinga (TM)</b>: {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 = '<br><br>'.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"• <b>{term}</b>: {desc.strip()}" if desc else f"• <b>{term}</b>")
|
||||
|
||||
# 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"• <b>{term}</b>: {desc.strip()}" if desc else f"• <b>{term}</b>")
|
||||
|
||||
# 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 = '<br>'.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': '<br>'.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()
|
||||
Loading…
Reference in New Issue
Block a user