Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Klassisches ML und PyTorch-Einstieg – logclass

Ziel: Logzeilen mit scikit-learn klassifizieren (TF-IDF, logistische Regression, Train/Test, Metriken), ehrlich bewerten und dieselbe Aufgabe einmal mit einem kleinen PyTorch-Netz lösen · Dauer: ca. 120 min · Voraussetzung: Tag 12

Briefing

  • Nicht jedes Problem braucht ein LLM: Ein Klassifikator mit 500 KB antwortet in Mikrosekunden, offline, deterministisch.
  • Features: TF-IDF macht aus Text Zahlen – Teilstücke, die in einer Zeile häufig, im ganzen Korpus aber selten sind, wiegen schwer.
  • Modell: Logistische Regression lernt pro Klasse Gewichte und liefert Wahrscheinlichkeiten.
  • Train/Test-Split: Bewertet wird nur auf Daten, die das Modell nie gesehen hat – sonst misst du Auswendiglernen.
  • PyTorch ist die Basis moderner Deep-Learning-Modelle: Tensoren, Autograd, Netze. Heute nur der Einstieg, auf der CPU.
data/logs.csv ─split─┬─ 75 % ─> TF-IDF ─> LogisticRegression ─fit─> model.joblib
                     └─ 25 % ────────────────────────────────> Report (Precision/Recall)
neue Zeilen ─> model.joblib ─> Klasse + Wahrscheinlichkeit (unter Schwelle: "unklar")

Drill 1: Projekt und Lab-Datensatz

cd ~/py-lab
uv init -q --package --name logclass tag13-logclass
cd tag13-logclass
uv add -q scikit-learn joblib typer
uv add -q --dev pytest ruff
cat >> pyproject.toml <<'EOF'

[tool.ruff.lint]
extend-select = ["E501", "B", "UP", "SIM"]

[tool.pytest.ini_options]
testpaths = ["tests"]

[[tool.mypy.overrides]]
module = ["sklearn.*", "joblib"]
ignore_missing_imports = true
EOF
uv tree --depth 1 | grep -E 'scikit|joblib'

Erwartet (Versionen können abweichen):

├── joblib v1.6.0
├── scikit-learn v1.9.1

Warum die mypy-Ausnahme? scikit-learn und joblib bringen keine Typ-Informationen mit; ohne ignore_missing_imports bricht mypy --strict ab. Dein eigener Code bleibt streng geprüft.

Echte gelabelte Logs hast du selten. Ein Generator mit festem Seed liefert einen reproduzierbaren Lab-Datensatz:

cat > make_data.py <<'EOF'
"""Erzeugt einen reproduzierbaren Lab-Datensatz mit gelabelten Logzeilen."""

import csv
import random
from pathlib import Path

TEMPLATES = {
    "security": [
        "sshd[{pid}]: Failed password for {user} from {ip} port {port} ssh2",
        "sshd[{pid}]: Invalid user {user} from {ip}",
        "sudo: {user} : 3 incorrect password attempts ; TTY=pts/{n}",
        "pam_unix(sshd:auth): authentication failure; rhost={ip} user={user}",
        "vault: permission denied: path=secret/data/{svc} token={user}",
    ],
    "storage": [
        "kernel: EXT4-fs error (device sda{n}): ext4_find_entry: reading failed",
        "{svc}: write /var/lib/{svc}/data: No space left on device",
        "smartd: Device /dev/sd{x}, {n} Currently unreadable (pending) sectors",
        "kubelet: eviction manager: disk pressure, nodefs available {n}%",
        "postgres[{pid}]: could not extend file base/{port}: disk quota exceeded",
    ],
    "network": [
        "kernel: eth{n}: link down",
        "{svc}: connect() to {ip}:{port} failed (111: Connection refused)",
        "systemd-resolved: lookup {svc}.internal timed out on {ip}",
        "dhclient[{pid}]: DHCPREQUEST on eth{n} to {ip} port 67: timeout",
        "haproxy: backend {svc} has no server available! ({ip}:{port} down)",
    ],
    "app": [
        "{svc}[{pid}]: ERROR NullPointerException in OrderService.java:{port}",
        "{svc}[{pid}]: java.lang.OutOfMemoryError: Java heap space",
        "{svc}[{pid}]: Traceback (most recent call last): KeyError: '{user}'",
        "{svc}[{pid}]: panic: runtime error: index out of range [{n}]",
        "{svc}[{pid}]: ERROR request {port} failed: invalid JSON payload",
    ],
}
USERS = ["root", "admin", "deploy", "thomas", "oracle", "git"]
SERVICES = ["api", "billing", "shop", "auth", "worker", "search"]


def fill(template: str, rng: random.Random) -> str:
    return template.format(
        pid=rng.randint(100, 65000),
        user=rng.choice(USERS),
        ip=f"10.{rng.randint(0, 255)}.{rng.randint(0, 255)}.{rng.randint(1, 254)}",
        port=rng.randint(1024, 65000),
        n=rng.randint(0, 9),
        x=rng.choice("abcd"),
        svc=rng.choice(SERVICES),
    )


def main() -> None:
    rng = random.Random(42)  # fester Seed = jedes Mal derselbe Datensatz
    rows = [
        (label, fill(rng.choice(templates), rng))
        for label, templates in TEMPLATES.items()
        for _ in range(150)
    ]
    rng.shuffle(rows)
    Path("data").mkdir(exist_ok=True)
    with open("data/logs.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["label", "line"])
        writer.writerows(rows)
    print(f"{len(rows)} Zeilen -> data/logs.csv")


if __name__ == "__main__":
    main()
EOF
uv run python make_data.py
head -3 data/logs.csv

Erwartet:

600 Zeilen -> data/logs.csv
label,line
network,dhclient[56107]: DHCPREQUEST on eth2 to 10.127.48.119 port 67: timeout
network,systemd-resolved: lookup auth.internal timed out on 10.184.128.22

Dazu zwölf Zeilen in anderem Format, wie sie aus echten Systemen kämen. Sie dienen nur zur Prüfung, nie zum Training:

cat > data/unseen.csv <<'EOF'
label,line
security,Oct 10 08:12:01 web1 sshd[812]: Failed password for invalid user test
security,auditd: USER_LOGIN acct=admin res=failed addr=192.168.1.20
security,nginx: 403 Forbidden: client denied by server configuration
storage,Oct 10 08:15:22 db1 kernel: XFS (dm-0): Metadata I/O error
storage,mysqld: Disk is full writing './binlog.000042' (Errcode: 28)
storage,zfs: pool tank is DEGRADED: one or more devices has been removed
network,Oct 10 08:20:00 lb1 kernel: bond0: link status definitely down for eth1
network,curl: (28) Connection timed out after 10001 milliseconds
network,ntpd: no servers reachable
app,worker[311]: ZeroDivisionError: division by zero
app,api[9001]: ERROR Unhandled exception: ValueError('bad input')
app,shop[77]: FATAL: segmentation fault in libcart.so
EOF
wc -l data/unseen.csv

Erwartet:

      13 data/unseen.csv

Fortschritt speichern? Kostenlos registrieren

Drill 2: Wie TF-IDF Text in Zahlen verwandelt

uv run python -c "
from sklearn.feature_extraction.text import TfidfVectorizer
v = TfidfVectorizer(analyzer='char_wb', ngram_range=(3, 5))
m = v.fit_transform(['sshd: Failed password', 'disk full'])
print(m.shape, m.nnz)
print(list(v.get_feature_names_out()[:6]))
pairs = zip(v.get_feature_names_out(), m[1].toarray()[0])
print([(f, round(float(w), 2)) for f, w in pairs if w][:4])
"

Erwartet:

(2, 66) 66
[' di', ' dis', ' disk', ' fa', ' fai', ' fail']
[(' di', 0.24), (' dis', 0.24), (' disk', 0.24), (' fu', 0.24)]

Warum Zeichen-n-Gramme (char_wb) statt Wörter? Logs sind voller Varianten: sda1, sdb3, eth0, Failed/failure. Teilstücke von 3–5 Zeichen erkennen die Gemeinsamkeit, ganze Wörter nicht. Die Matrix ist sparse: Von 2 × 66 Werten sind nur 66 belegt – bei 450 Zeilen und zehntausenden Spalten spart das sehr viel Speicher.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Trainieren und bewerten

cat > src/logclass/model.py <<'EOF'
"""TF-IDF + logistische Regression: Logzeilen klassifizieren."""

import csv
from pathlib import Path

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline, make_pipeline


def load_csv(path: Path) -> tuple[list[str], list[str]]:
    """Liest eine CSV mit den Spalten label,line."""
    with path.open(encoding="utf-8", newline="") as f:
        rows = list(csv.DictReader(f))
    return [r["line"] for r in rows], [r["label"] for r in rows]


def build_pipeline() -> Pipeline:
    return make_pipeline(
        # Zeichen-n-Gramme sind robust gegen PIDs, IPs und Tippvarianten.
        TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5), sublinear_tf=True),
        LogisticRegression(max_iter=1000),
    )


def train(lines: list[str], labels: list[str], seed: int = 42) -> tuple[Pipeline, str]:
    """Trainiert auf 75 %, bewertet auf den zurückgehaltenen 25 %."""
    x_train, x_test, y_train, y_test = train_test_split(
        lines, labels, test_size=0.25, random_state=seed, stratify=labels
    )
    model = build_pipeline().fit(x_train, y_train)
    report = classification_report(y_test, model.predict(x_test), digits=3)
    return model, str(report)


def predict(model: Pipeline, lines: list[str]) -> list[tuple[str, float]]:
    """Liefert je Zeile (Klasse, Wahrscheinlichkeit der Klasse)."""
    probs = model.predict_proba(lines)
    return [(str(model.classes_[p.argmax()]), float(p.max())) for p in probs]
EOF
uv run python -c "
from pathlib import Path
from logclass.model import load_csv, train
model, report = train(*load_csv(Path('data/logs.csv')))
print(report)
"

Erwartet:

              precision    recall  f1-score   support

         app      1.000     1.000     1.000        38
     network      1.000     1.000     1.000        37
    security      1.000     1.000     1.000        38
     storage      1.000     1.000     1.000        37

    accuracy                          1.000       150
   macro avg      1.000     1.000     1.000       150
weighted avg      1.000     1.000     1.000       150

Warum stratify=labels? So hat der Testanteil dieselbe Klassenverteilung wie der Datensatz. Precision = von allen „security”-Vorhersagen waren so viele richtig; Recall = von allen echten Security-Zeilen wurden so viele gefunden. 100 % klingt toll – Drill 5 zeigt, warum du misstrauisch sein solltest.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Das CLI

cat > src/logclass/cli.py <<'EOF'
"""logclass – Logzeilen mit klassischem ML klassifizieren."""

import sys
from pathlib import Path
from typing import Annotated

import joblib
import typer

from logclass.model import load_csv, predict, train

app = typer.Typer(add_completion=False, no_args_is_help=True)
ModelOpt = Annotated[Path, typer.Option("--model", "-m")]


@app.command("train")
def train_cmd(data: Path, model: ModelOpt = Path("model.joblib")) -> None:
    """Trainiert auf DATA (CSV label,line) und speichert das Modell."""
    lines, labels = load_csv(data)
    pipeline, report = train(lines, labels)
    joblib.dump(pipeline, model)
    typer.echo(report)
    typer.echo(f"Modell gespeichert: {model} ({model.stat().st_size // 1024} KB)")


@app.command("predict")
def predict_cmd(
    file: Annotated[Path | None, typer.Argument()] = None,
    model: ModelOpt = Path("model.joblib"),
    min_proba: Annotated[float, typer.Option(min=0, max=1)] = 0.5,
) -> None:
    """Klassifiziert jede Zeile aus FILE (Standard: stdin)."""
    text = file.read_text(encoding="utf-8") if file else sys.stdin.read()
    lines = [line for line in text.splitlines() if line.strip()]
    pipeline = joblib.load(model)  # Pickle: nur eigene Modelle laden!
    for line, (label, proba) in zip(lines, predict(pipeline, lines), strict=True):
        shown = label if proba >= min_proba else "unklar"
        typer.echo(f"{shown:9} {proba:.2f}  {line[:60]}")


@app.command("eval")
def eval_cmd(data: Path, model: ModelOpt = Path("model.joblib")) -> None:
    """Misst die Trefferquote auf DATA – idealerweise Zeilen aus echten Logs."""
    lines, labels = load_csv(data)
    results = predict(joblib.load(model), lines)
    for (label, proba), expected, line in zip(results, labels, lines, strict=True):
        mark = "✔" if label == expected else "✘"
        typer.echo(f"{mark} {label:9} {proba:.2f}  {line[:50]}")
    hits = sum(label == exp for (label, _), exp in zip(results, labels, strict=True))
    typer.echo(f"Accuracy: {hits / len(labels):.2f} ({hits}/{len(labels)})")
EOF
cat > src/logclass/__init__.py <<'EOF'
"""logclass – Logzeilen mit klassischem ML klassifizieren."""

from logclass.cli import app


def main() -> None:
    app()
EOF
cat > src/logclass/__main__.py <<'EOF'
from logclass import main

main()
EOF
uv run logclass train data/logs.csv | tail -1
printf '%s\n' 'kernel: nvme0n1: I/O error, dev nvme0n1, sector 1234' \
  'sshd[1]: Accepted publickey for thomas' > neu.log
uv run logclass predict neu.log
cat neu.log | uv run logclass predict --min-proba 0.3

Erwartet:

Modell gespeichert: model.joblib (473 KB)
unklar    0.34  kernel: nvme0n1: I/O error, dev nvme0n1, sector 1234
security  0.72  sshd[1]: Accepted publickey for thomas
network   0.34  kernel: nvme0n1: I/O error, dev nvme0n1, sector 1234
security  0.72  sshd[1]: Accepted publickey for thomas

Warum „unklar”? Unter --min-proba gibt logclass lieber zu, dass es unsicher ist. Senkst du die Schwelle, wird aus dem NVMe-Fehler fälschlich network. Und ein erfolgreicher Login landet bei security, weil das Modell nur vier Klassen kennt – es muss sich für eine entscheiden (Challenge).

Sicherheit: joblib.load ist Pickle: Eine präparierte Modelldatei führt beim Laden beliebigen Code aus. Lade nur Modelle, die du selbst gebaut hast, oder nutze ein sicheres Format wie skops.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Generalisierung – der ehrliche Test

uv run logclass eval data/unseen.csv

Erwartet:

✔ security  0.87  Oct 10 08:12:01 web1 sshd[812]: Failed password fo
✔ security  0.42  auditd: USER_LOGIN acct=admin res=failed addr=192.
✘ network   0.45  nginx: 403 Forbidden: client denied by server conf
✘ network   0.33  Oct 10 08:15:22 db1 kernel: XFS (dm-0): Metadata I
✔ storage   0.54  mysqld: Disk is full writing './binlog.000042' (Er
✔ storage   0.39  zfs: pool tank is DEGRADED: one or more devices ha
✔ network   0.77  Oct 10 08:20:00 lb1 kernel: bond0: link status def
✔ network   0.80  curl: (28) Connection timed out after 10001 millis
✔ network   0.40  ntpd: no servers reachable
✔ app       0.55  worker[311]: ZeroDivisionError: division by zero
✔ app       0.67  api[9001]: ERROR Unhandled exception: ValueError('
✔ app       0.30  shop[77]: FATAL: segmentation fault in libcart.so
Accuracy: 0.83 (10/12)

Warum 0,83 statt 1,00? Testdaten aus demselben Generator sind „zu ähnlich” – das Modell erkennt die Templates wieder. Auf fremden Formaten sinken Trefferquote und Zuversicht (viele Werte unter 0,5). In Produktion trainierst du mit echten, gelabelten Logs aus mehreren Systemen und testest auf einem anderen Zeitraum.

Fortschritt speichern? Kostenlos registrieren

Drill 6: PyTorch-Einstieg

PyTorch ist groß (rund 500 MB) und nur für diesen Drill nötig. uv run --with lädt es in eine temporäre Umgebung, ohne pyproject.toml zu ändern.

cat > torch_demo.py <<'EOF'
"""PyTorch-Einstieg: Tensoren, Autograd und ein kleines Netz auf der CPU."""

from pathlib import Path

import torch
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from torch import nn

from logclass.model import load_csv

torch.manual_seed(0)

# 1) Tensoren rechnen wie numpy – und merken sich, wie ein Wert entstand.
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
(x**2).sum().backward()
print("Gradient von sum(x²):", x.grad.tolist() if x.grad is not None else None)

# 2) Dieselben TF-IDF-Features wie in sklearn, als dichte Float-Tensoren.
lines, labels = load_csv(Path("data/logs.csv"))
classes = sorted(set(labels))
x_tr, x_te, y_tr, y_te = train_test_split(
    lines, labels, test_size=0.25, random_state=42, stratify=labels
)
vec = TfidfVectorizer(analyzer="char_wb", ngram_range=(3, 5), max_features=2000)
vec.fit(x_tr)


def to_tensors(xs: list[str], ys: list[str]) -> tuple[torch.Tensor, torch.Tensor]:
    features = torch.tensor(vec.transform(xs).toarray(), dtype=torch.float32)
    targets = torch.tensor([classes.index(y) for y in ys])
    return features, targets


X_tr, Y_tr = to_tensors(x_tr, y_tr)
X_te, Y_te = to_tensors(x_te, y_te)
print("Trainingsdaten:", tuple(X_tr.shape), X_tr.dtype)

# 3) Ein Netz mit einer versteckten Schicht, trainiert mit Gradientenabstieg.
hidden = 32
model = nn.Sequential(
    nn.Linear(X_tr.shape[1], hidden), nn.ReLU(), nn.Linear(hidden, len(classes))
)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.CrossEntropyLoss()
for epoch in range(1, 31):
    optimizer.zero_grad()
    loss = loss_fn(model(X_tr), Y_tr)
    loss.backward()
    optimizer.step()
    if epoch % 10 == 0:
        print(f"Epoche {epoch:2}: Loss {loss.item():.4f}")

model.eval()
with torch.no_grad():
    acc = (model(X_te).argmax(dim=1) == Y_te).float().mean().item()
    X_un, Y_un = to_tensors(*load_csv(Path("data/unseen.csv")))
    acc_un = (model(X_un).argmax(dim=1) == Y_un).float().mean().item()
params = sum(p.numel() for p in model.parameters())
print(f"Test: {acc:.2f}  Unseen: {acc_un:.2f}  Parameter: {params}")
EOF
uv run --with torch python torch_demo.py

Erwartet (Werte können leicht abweichen):

Gradient von sum(x²): [[2.0, 4.0], [6.0, 8.0]]
Trainingsdaten: (450, 2000) torch.float32
Epoche 10: Loss 0.3387
Epoche 20: Loss 0.0078
Epoche 30: Loss 0.0006
Test: 1.00  Unseen: 0.92  Parameter: 64164

Warum zero_grad, backward, step? Das ist der Trainingszyklus jedes Netzes: alte Gradienten löschen, Fehler (Loss) rückwärts durchs Netz ableiten, Gewichte ein Stück gegen den Gradienten verschieben. model.eval() und torch.no_grad() schalten fürs Vorhersagen Training und Gradienten ab. Das Netz schafft 11 von 12 statt 10 von 12 – bei zwölf Zeilen ist das Zufall, kein Beweis. Für diese Aufgabe ist scikit-learn einfacher, kleiner und schneller.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Tests mit Mini-Datensatz

Tests erzeugen ihre eigenen 60 Zeilen in tmp_path – unabhängig vom Generator und in unter einer Sekunde trainiert.

mkdir -p tests
cat > tests/test_logclass.py <<'EOF'
import csv
from pathlib import Path

import pytest
from typer.testing import CliRunner

from logclass.cli import app
from logclass.model import load_csv, predict, train

EXAMPLES = {
    "security": "sshd[{i}]: Failed password for root from 10.0.0.{i}",
    "storage": "kernel: write error on /dev/sda{i}: No space left on device",
    "network": "eth{i}: link down, connection to 10.1.1.{i} refused",
}


@pytest.fixture
def data_csv(tmp_path: Path) -> Path:
    path = tmp_path / "logs.csv"
    with path.open("w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["label", "line"])
        for label, template in EXAMPLES.items():
            writer.writerows((label, template.format(i=i)) for i in range(20))
    return path


def test_load_csv(data_csv: Path) -> None:
    lines, labels = load_csv(data_csv)
    assert len(lines) == len(labels) == 60
    assert labels[0] == "security"


def test_train_and_predict(data_csv: Path) -> None:
    model, report = train(*load_csv(data_csv))
    assert "accuracy" in report
    [(label, proba)] = predict(model, ["sshd[99]: Failed password for admin"])
    assert label == "security"
    assert 0.0 < proba <= 1.0


def test_cli_roundtrip(data_csv: Path, tmp_path: Path) -> None:
    runner = CliRunner()
    model = tmp_path / "m.joblib"
    assert runner.invoke(app, ["train", str(data_csv), "-m", str(model)]).exit_code == 0
    result = runner.invoke(
        app, ["predict", "-m", str(model)], input="eth7: link down\n\n"
    )
    assert result.exit_code == 0
    assert result.output.split()[0] == "network"
    assert len(result.output.splitlines()) == 1  # Leerzeilen werden übersprungen
EOF
uv run pytest -q
uv run ruff check . && uv run --with mypy mypy --strict src

Erwartet:

...                                                                      [100%]
3 passed in 0.72s
All checks passed!
Success: no issues found in 4 source files

Warum keine Assertion auf eine exakte Wahrscheinlichkeit? Die hängt von Solver und Version ab. Teste Verhalten (richtige Klasse, Wert zwischen 0 und 1), nicht Zufallsdetails.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

uv tool install --editable .
logclass train ~/py-lab/tag13-logclass/data/logs.csv \
  -m ~/py-lab/tag13-logclass/model.joblib | tail -1
cd ~
printf '%s\n' 'sshd[4711]: Failed password for root from 203.0.113.9' \
  'postgres[88]: could not write to file: No space left on device' \
  'api[12]: ERROR request 77 failed: invalid JSON payload' \
  | logclass predict -m ~/py-lab/tag13-logclass/model.joblib

Erwartet:

Modell gespeichert: /Users/thomas/py-lab/tag13-logclass/model.joblib (473 KB)
security  0.86  sshd[4711]: Failed password for root from 203.0.113.9
storage   0.89  postgres[88]: could not write to file: No space left on devi
app       0.88  api[12]: ERROR request 77 failed: invalid JSON payload

Warum so schnell? Kein Netzwerk, kein GPU, kein Prompt: Vorhersagen dauern Mikrosekunden pro Zeile. Damit passt logclass auch in eine Log-Pipeline (z. B. als Vorfilter, bevor teure LLM-Analysen wie ask aus Tag 10 laufen).

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

cd ~/py-lab/tag13-logclass
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "Datensatz da" "test \$(wc -l < data/logs.csv) -eq 601"
check "Tests grün" "uv run pytest -q"
check "ruff sauber" "uv run ruff check ."
check "mypy --strict sauber" "uv run --with mypy mypy --strict src"
check "Modell trainiert" "uv run logclass train data/logs.csv | grep -q '1.000'"
E='Accuracy: 0\.(7[5-9]|[89])'
check "Unseen >= 0.75" "uv run logclass eval data/unseen.csv | grep -qE '$E'"
check "Schwelle greift" "echo 'hallo welt' | uv run logclass predict | grep -q unklar"

Erwartet:

✔ Datensatz da
✔ Tests grün
✔ ruff sauber
✔ mypy --strict sauber
✔ Modell trainiert
✔ Unseen >= 0.75
✔ Schwelle greift

Challenge

Ergänze im Generator eine fünfte Klasse info für normale Ereignisse (erfolgreicher Login, gestarteter Dienst, Cronjob), trainiere neu und prüfe, wohin sshd[1]: Accepted publickey for thomas jetzt fällt – und was mit der Unseen-Accuracy passiert.

Hinweis: Es reicht ein weiterer Eintrag im Dict TEMPLATES; Pipeline, CLI und das Netz in torch_demo.py passen sich über classes_ bzw. len(classes) an.

Lösung

In make_data.py vor der schließenden Klammer von TEMPLATES einfügen:

    "info": [
        "sshd[{pid}]: Accepted publickey for {user} from {ip} port {port} ssh2",
        "systemd[1]: Started {svc}.service - {svc} daemon.",
        "{svc}[{pid}]: INFO request {port} completed in {n}ms",
        "CRON[{pid}]: ({user}) CMD (/usr/local/bin/{svc}-backup.sh)",
        "kubelet: Successfully pulled image {svc}:1.{n} in {port}ms",
    ],

Dann neu erzeugen, trainieren und prüfen:

uv run python make_data.py
uv run logclass train data/logs.csv | grep -E 'info|accuracy'
uv run logclass predict neu.log
uv run logclass eval data/unseen.csv | tail -1

Erwartet:

750 Zeilen -> data/logs.csv
        info      1.000     1.000     1.000        37
    accuracy                          1.000       188
unklar    0.31  kernel: nvme0n1: I/O error, dev nvme0n1, sector 1234
info      0.89  sshd[1]: Accepted publickey for thomas
Accuracy: 0.75 (9/12)

Warum sinkt die Unseen-Accuracy? Eine Klasse mehr heißt eine Verwechslungsmöglichkeit mehr – und die Unseen-Zeilen enthalten keine info-Fälle, von denen das Modell profitieren könnte. Jede Datensatzänderung braucht einen neuen Eval-Lauf; Kontrollpunkt-Schwellen musst du danach bewusst anpassen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Labels sind das teure Gut: Ein Label-Prozess (z. B. aus geschlossenen Incidents) und ein fester, zeitlich getrennter Testdatensatz sind wichtiger als die Modellwahl.
  • Modelle versionieren (Daten-Hash, Code-Commit, Metriken) und nur aus vertrauenswürdigen Quellen laden; Pickle-Dateien wie ausführbaren Code behandeln oder skops/ONNX nutzen.
  • Drift überwachen: Neue Software-Versionen ändern Logformate; sinkende Zuversicht (viele „unklar”) ist ein Frühwarnsignal für Nachtraining.
  • Klassisches ML als Vorfilter vor LLMs: billig, schnell, erklärbar (Gewichte pro n-Gramm) – das LLM nur für die unklaren Fälle.
  • PyTorch in Produktion: CPU-Wheels und Versionen pinnen, Container-Images klein halten; für GPU-Inferenz eigene Builds mit passender CUDA-Version.