Spickzettel (A4)

Ultra-kompakte Formel- und Faktensammlung fuer die EKI-Klausur - gedacht zum dichten Abschreiben auf ein beidseitig handbeschriebenes DIN-A4-Blatt (das einzige zugelassene Hilfsmittel).

EKI00 - Einführung

  • KI = Maschinen/Software, die menschliches Verhalten zeigen: Wahrnehmen, Lernen/Wissen/Nachdenken, Kommunizieren, Handeln.
  • KI-Landkarte: Achse Acquiring vs. Applying; Paradigmen non-symbolic (ML) vs. symbolic (wissensbasiert).
  • 6 Bereiche: Perceiving (CV), Communicating (NLP), Reasoning (CEP), Acting, Learning (ML), Knowing (Wissensrepr.).
  • Hype-Zyklus (Gartner): Trigger -> Peak -> Trough (= KI-Winter) -> Slope -> Plateau.
  • Geschichte: Turing (Turing-Test), Dartmouth 1956 (Begriff "AI", McCarthy/Minsky).

EKI02 - Klassifikation

  • ML = Modell aus Training erzeugen + fuer Vorhersage nutzen; nicht explizit programmiert.
  • Kategorien: Supervised (Klassifikation, Regression), Unsupervised (Clustering...), Reinforcement.
  • Klassifikation = Kategorie; Regression = Zahl.
  • Features = X (Matrix, Gross), Label = y (Vektor, klein).
  • Entscheidungsbaum: Klassen = Blaetter, Entscheidungen = innere Knoten, Werte = Kanten.
  • Entropie: H(M)=∑i−cilog⁡2(ci)H(M) = \sum_i -c_i \log_2(c_i), ∑ci=1\sum c_i = 1; max bei 50/50, 0 bei reiner Klasse.
    • Bsp: −310log⁡2310−710log⁡2710=0,881-\tfrac{3}{10}\log_2\tfrac{3}{10} - \tfrac{7}{10}\log_2\tfrac{7}{10} = 0{,}881.
  • Information Gain: H(T)−∣Tlow∣∣T∣H(Tlow)−∣Tup∣∣T∣H(Tup)H(T) - \tfrac{|T_{low}|}{|T|}H(T_{low}) - \tfrac{|T_{up}|}{|T|}H(T_{up}); Split mit groesstem Gewinn.
  • Workflow: read_csv -> vorverarbeiten -> DecisionTreeClassifier() -> fit(X,y) -> predict(X_test) -> to_csv.
  • Vorverarbeitung: fillna(wert), SimpleImputer(strategy='mean'); Test wie Train vorverarbeiten.

EKI03 - Regression + Validierung

  • Konfusionsmatrix (Zeile=Vorhersage, Spalte=Wahrheit): TP, FP (Type I), FN (Type II), TN.
  • Beispiel: TP=1, FP=1, FN=8, TN=90.
  • Accuracy=TP+TNTP+TN+FP+FN=0,91\text{Accuracy} = \frac{TP+TN}{TP+TN+FP+FN} = 0{,}91
  • Precision=TPTP+FP=0,5\text{Precision} = \frac{TP}{TP+FP} = 0{,}5
  • Recall=TPTP+FN=0,111\text{Recall} = \frac{TP}{TP+FN} = 0{,}111
  • F-Score=2⋅P⋅RP+R=0,181F\text{-Score} = 2\cdot\frac{P\cdot R}{P+R} = 0{,}181 (harmonisches Mittel).
  • Accuracy versagt bei unausgewogenen Daten -> F-Score nehmen.
  • Regressionsmasse: MAE=1n∑∣f^i−yi∣MAE=\frac{1}{n}\sum|\hat f_i - y_i|, MSE=1n∑(f^i−yi)2MSE=\frac{1}{n}\sum(\hat f_i - y_i)^2, RMSE=MSERMSE=\sqrt{MSE} (MSE bestraft grosse Fehler, RMSE = Einheit der Zielgroesse).
  • Warnung: gute Kennzahl (R2=0,99R^2=0{,}99) allein reicht nicht (Scheinkorrelation/Overfitting).
  • k-fold CV: in kk Folds splitten, kk-mal 1 Fold Test / Rest Train, Mittelwert; Default cross_val_score: accuracy, k=5.
  • Regression: SVR(); Score scoring='neg_root_mean_squared_error'.

EKI04 - Wissensrepräsentation

  • Wissensgraph = gerichteter Graph: Knoten (Objekte/Klassen/Werte), benannte Kanten (Beziehungen).
  • 3 Bausteine: Objekte/Instanzen, Klassen, Beziehungen.
  • RDF = W3C-Sprache fuer Wissensgraphen; Notation Turtle. Resource per URI (@base/PREFIX kuerzt).
  • Tripel = Subjekt + Praedikat + Objekt. Subj/Praed = Resource, Objekt = Resource oder Wert. . beendet, ; verkettet, a = rdf:type.
  • SPARQL (W3C 1.1): PREFIX + SELECT ?v + WHERE { muster }; Variablen mit ?.
  • Ergebnis = Tabelle: 1 Spalte pro Query-Variable, 1 Zeile pro passender Zuweisung.
  • Join = dieselbe Variable mehrfach (erzwingt gleichen Wert); DISTINCT gegen Duplikate.
  • Weitere: ASK, COUNT, FILTER, OPTIONAL, ORDER BY, GROUP BY, CONSTRUCT.
  • Tools: Apache Jena/Fuseki (localhost:3030), rdflib (Python).

EKI05 - Complex Event Processing

  • CEP = Verarbeiten eines Ereignisstroms + Ableiten von Schluessen daraus (Bereich Reasoning).
  • Ereignis (etwas Passiertes) / Ereignisobjekt (Datensatz dazu) / Ereignistyp (Struktur: Attribute+Typen).
  • DBMS: persistente Daten + volatile Query. CEP: persistente Regel + fliessender Strom (Umkehrung!).
  • Iteratives CEP: low-level -> high-level Ereignisse durch Rueckkopplung.
  • Sliding/rolling window: nn = Dauer, mm = Haeufigkeit/Versatz; pandas rolling(window=...).
  • Anwendungen: Betrugserkennung, Predictive Maintenance, Logistik, Wertpapierhandel, COVID-Monitoring.
  • Technologien: Kafka, Flink, Spark, Drools Fusion, Azure/Oracle Stream Analytics, Apama, SAP/SAS ESP, TIBCO.

EKI06 - Computer Vision

  • Bild = Zahlenmatrix; MNIST 28x28 = 784 Werte, Datensatz [55000,784], Form (28,28,1).
  • Neuron: sum=∑iiniwisum = \sum_i in_i w_i (Bias: in0=1in_0=1); Sigmoid out=11+e−sumout=\frac{1}{1+e^{-sum}}, f′=f(1−f)f'=f(1-f).
  • ANN: Eingabe-/Zwischen-/Ausgabeschicht; feed-forward vs. recurrent.
  • Kostenfunktion: Cost=∑i(target−out)2Cost=\sum_i(target-out)^2.
  • Gradientenabstieg: Update Richtung −η ∇Cost-\eta\,\nabla Cost, η\eta = Lernrate.
  • Backpropagation (Rumelhart/Hinton/Williams), 5 Schritte: vorwaerts -> Fehler -> Δ\Delta letzte Schicht -> Δ\Delta rueckwaerts -> Gewichte.
    • Δi=f′(sumi)(targeti−outi)\Delta_i = f'(sum_i)(target_i - out_i) (letzte); Δi=f′(sumi)∑jwi,jΔj\Delta_i = f'(sum_i)\sum_j w_{i,j}\Delta_j (innere).
    • Update: wj,i=wj,i+η Δi outjw_{j,i} = w_{j,i} + \eta\,\Delta_i\,out_j.
  • Deep Learning: viele Schichten, low (Pixel) -> medium (Formen) -> high (Klassen).
  • CNN: Convolution (Kernel, erhaelt Nachbarschaft, O=N−F+1O=N-F+1 bei stride 1) -> Pooling (Max/Avg/Sum, z.B. 2x2) -> Fully Connected (Ausgabeneuronen = Klassen).
  • Keras: Sequential([Conv2D, MaxPooling2D, ..., Flatten, Dense(10,'softmax')]); compile(optimizer,loss,metrics) -> fit(batch_size,epochs).
  • Vorverarbeitung: /255 normalisieren, One-Hot (10 Klassen), reshape (28,28,1); Vorhersage np.argmax.

EKI07 - NLP

  • 6 Bereiche: Information Retrieval, Textklassifikation, Information Extraction, Question Answering, Maschinelles Uebersetzen, Texterzeugung.
  • Bag of Words: Text = Multi-Set von Worten + Haeufigkeiten, ohne Grammatik/Reihenfolge -> Feature-Vektoren.
    • Bsp: "John likes to watch movies. Mary likes movies too." -> likes:2, movies:2, ...
  • tf-idf: tfidf=tf⋅idf\text{tfidf}=\text{tf}\cdot\text{idf}, idf=log⁡(N/df)\text{idf}=\log(N/df); haeufige Fuellwoerter abwerten (idf("the")=log⁡(100/100)=0\log(100/100)=0).
  • tf = Haeufigkeit im Text; df = Anzahl Dokumente mit dem Wort.
  • n-Gramm: NN aufeinanderfolgende Worte; erfasst Kontext, mit tf-idf kombinierbar.
  • Pipeline: CountVectorizer -> TfidfTransformer -> MultinomialNB; Guete via cross_val_score.
  • spaCy: Tokenization, POS-Tagging, Dependency Parsing, Lemmatization, SBD, NER, Entity Linking, Similarity (Wortvektoren), Text Classification, Rule-based Matching.
  • Einfaches QA: neue Frage mit FAQ-Fragen vergleichen -> Antwort der aehnlichsten Frage.

EKI08 - Ethik

  • Leitfrage: "Wer soll entscheiden, Mensch oder Maschine?"
  • Hype = Hyperbel (Uebertreibung); Fehlprognosen Minsky 1967/1970, Kurzweil 2005.
  • Cyborg = technisch erweiterter Mensch (Antenne, Prothese, Hoergeraet, Herzschrittmacher).
  • Bias: ML lernt aus historischen Daten -> projiziert Vorurteile in die Zukunft (ProPublica/COMPAS: Prater vs. Borden).
  • Arbeitsplatzverlust (Frey & Osborne, z.B. Versicherungspruefer 99 %); autonome Entscheidungen: HFT/Flash Crash, autonome Waffen ("dritte Revolution der Kriegsfuehrung").

EKI09 - Unsupervised Learning

  • Kein Label; Ziele: Ausreissererkennung, Clustering, Dimensionsreduktion, Datengenerierung.
  • Curse of Dimensionality (Bellman): Vn=1V_n=1, Diagonale dn=nd_n=\sqrt{n}; Volumen V([0,2]n)=2nV([0,2]^n)=2^n.
  • Dimensionsreduktion ϕ:Rp→Rd\phi:\mathbb{R}^p\to\mathbb{R}^d, d<pd<p. Einfach: Weglassen, Zufallsprojektion (ϕ(x)=Rx\phi(x)=Rx), Feature Engineering (min/max), gelernt (PCA/Autoencoder).
  • PCA (5 Schritte): 1. zentrieren (Mittelwert 0), 2. Kovarianzmatrix (n×nn\times n), 3. Eigenvektoren/-werte Mx=λxMx=\lambda x, 4. nach Eigenwert sortieren, 5. PCs als Linearkombination.
    • PC1=a1f1+⋯+anfnPC_1=a_1f_1+\dots+a_nf_n (groesster Eigenwert). Erklaerte Varianz; PC1+PC2 fuer 2D-Plot. PCA(n_components=2).fit_transform(X).
  • Varianz: 1n−1∑(xi−xˉ)2\frac{1}{n-1}\sum(x_i-\bar x)^2.
  • Autoencoder: Encoder -> Latent Space (Flaschenhals) -> Decoder -> x^\hat x; nichtlinear; Noise Reduction, Outlier Detection, Datengenerierung.
  • k-Means: 1. kk zufaellige Zentren, 2. Zuordnung (min. euklid. Abstand), 3. Update mi=1∣Ci∣∑Xj∈CiXjm_i=\frac{1}{|C_i|}\sum_{X_j\in C_i}X_j, 4. bis Konvergenz.
    • Distanz: d(x,y)=∑i(xi−yi)2d(x,y)=\sqrt{\sum_i (x_i-y_i)^2}.
    • Vor k-Means Min-Max normalisieren: x′=x−xmin⁡xmax⁡−xmin⁡x'=\frac{x-x_{\min}}{x_{\max}-x_{\min}} (sonst dominiert grosses Feature).
  • Varianten: k-means++ (Init ∝D2(X)\propto D^2(X)), k-medians (Median), k-medoids (Zentrum = Datenpunkt).