Version 04 als eigenes Repository
Erster Commit des Strangs "Optimierte Entscheidungsfindung mit Python" (Version 04). Die Historie der 71 Commits bis zur Trennung bleibt im uebergeordneten Repository OR_mit_Python liegen, das ab jetzt nur noch Version_03 (eingefroren) verwaltet und Version_04/ ignoriert. Bewusst kein "git subtree split": Der Pfad Version_04/ existiert erst seit der Verzeichnistrennung, ein Split braechte daher nur 7 der 41 einschlaegigen Commits - eine Teilhistorie, die vollstaendig aussieht und es nicht ist. Stand: 5 Teile, 23 Kapitel, 5 Anhaenge, 292 Abschnitte, 703 Querverweise, 325 Indexmarken, 73 Beispielprogramme, 32 SVGs, 4 Plotly-Figuren, 25 Notebooks, PDF mit 715 Seiten. Zusaetzlich in diesem Commit: * pyproject.toml mit Abhaengigkeitsgruppen finance, large-scale, api, figures, dev, empfehlungen. Die abgedruckte requirements.txt bleibt unveraendert daneben bestehen. ortools steht in der Grundausstattung, highspy erst in [large-scale] - so kann der HiGHS-Symbolkonflikt bei der schlanken Installation gar nicht erst auftreten. * Dabei zwei Funde: graphviz wird von erzeuge_architektur_diagramme.py importiert, fehlt aber in requirements.txt (jetzt in [figures]); pymoo steht in requirements.txt, wird aber von keinem Programm importiert, sondern nur im Kapitel Metaheuristiken empfohlen (jetzt in [empfehlungen]). * NEUER_TITEL.md nach Kritik_und_Verbesserungsvorschlaege/ verschoben - es ist die Vorlage des Titelblatts, kein Bestandteil des Werks. Die beiden Fundstellen in PROGRESS.md und erzeuge_titelseite.py nachgezogen. * PROGRESS.md nannte noch den Untertitel der ersten Fassung; auf den tatsaechlichen aus erzeuge_titelseite.py korrigiert. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
dschlueter
commit
b7af2f1d9a
468 changed files with 262141 additions and 0 deletions
299
bilder_04/erzeuge_metaheuristik_landschaft.py
Normal file
299
bilder_04/erzeuge_metaheuristik_landschaft.py
Normal file
|
|
@ -0,0 +1,299 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
# erzeuge_metaheuristik_landschaft.py
|
||||
"""
|
||||
Erzeugt das Suchverlauf-Diagramm zum Kapitel Metaheuristiken:
|
||||
|
||||
bilder_04/kap_metaheuristiken_landschaft.svg statisch, fuer das PDF
|
||||
bilder_04/kap_metaheuristiken_landschaft.png Rasterfassung
|
||||
bilder_04/plotly/kap_metaheuristiken_verlauf.html interaktiv, fuer die Website
|
||||
|
||||
Eine Suchlandschaft laesst sich bei 200 Auftraegen nicht zeichnen - der Raum
|
||||
hat 200! Punkte. Zeichnen laesst sich aber, wie die Suche sie DURCHLAEUFT, und
|
||||
das zeigt dasselbe:
|
||||
|
||||
Links - der Zielwert waehrend der Suche. Bergsteigen faellt monoton und
|
||||
bleibt liegen. Annealing bei T=1 faellt fast genauso, mit winzigen
|
||||
Ausschlaegen nach oben. Bei T=8 irrt die Suche weit ueber den
|
||||
Startwert hinaus und findet nicht zurueck - die Temperatur ist kein
|
||||
Beiwerk.
|
||||
Rechts - das Ergebnis ueber die Starttemperatur. Es gibt ein Optimum, es ist
|
||||
schmal, und jenseits davon wird die Metaheuristik schlechter als die
|
||||
Faustregel, mit der sie gestartet ist.
|
||||
|
||||
Instanz, Zug und Abkuehlplan sind wortgleich zu Simulated_Annealing.py, und
|
||||
gerechnet wird hier erneut - so koennen Diagramm und Buchtext nicht
|
||||
auseinanderlaufen. Der einzige Unterschied: Die Suche zeichnet ihren Verlauf
|
||||
mit, was das Buchprogramm nicht braucht.
|
||||
|
||||
Aufruf (aus dem Repository-Wurzelverzeichnis, dauert rund eine Minute):
|
||||
python3 bilder_04/erzeuge_metaheuristik_landschaft.py
|
||||
|
||||
Die interaktive Fassung traegt im Hover die Groesse, die das statische Bild
|
||||
nicht zeigen kann: die Temperatur an dieser Stelle des Abkuehlplans - und was
|
||||
sie konkret bedeutet, naemlich mit welcher Wahrscheinlichkeit dort ein Zug
|
||||
typischer Groesse (Median 70 Minuten, im Kapitel gemessen) angenommen wuerde.
|
||||
Damit wird an der Kurve ablesbar, warum T0 = 8 so lange braucht, um
|
||||
zurueckzufinden.
|
||||
|
||||
Benoetigt: numpy, matplotlib, plotly
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import math
|
||||
import os
|
||||
|
||||
import matplotlib
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt
|
||||
import numpy as np
|
||||
import plotly.graph_objects as go
|
||||
|
||||
# Reproduzierbare SVG-Ausgabe (siehe erzeuge_titelseite.py)
|
||||
plt.rcParams["svg.hashsalt"] = "or-mit-python-v04"
|
||||
|
||||
BASIS = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
BILDER = os.path.join(BASIS, "bilder_04")
|
||||
PLOTLY_VERZ = os.path.join(BILDER, "plotly")
|
||||
|
||||
INDIGO, CYAN, AMBER, GRAU = "#4338ca", "#0891b2", "#b45309", "#94a3b8"
|
||||
|
||||
N_AUFTRAEGE = 200
|
||||
ZUEGE = 400_000
|
||||
SAAT = 11
|
||||
STUETZSTELLEN = 800 # so viele Punkte je Verlaufskurve
|
||||
MEDIAN_ZUG = 70 # typische Zuggroesse in Minuten (im Kapitel gemessen)
|
||||
|
||||
|
||||
# --- Instanz und Zug: wortgleich zu Simulated_Annealing.py ------------------
|
||||
|
||||
def erzeuge_ruestmatrix(n: int, saat: int = SAAT) -> np.ndarray:
|
||||
rng = np.random.default_rng(saat)
|
||||
familien = max(6, n // 10)
|
||||
zwischen = rng.integers(8, 60, (familien, familien))
|
||||
np.fill_diagonal(zwischen, 2)
|
||||
familie = rng.integers(0, familien, n)
|
||||
farbe = rng.integers(0, 10, n)
|
||||
matrix = np.zeros((n, n), dtype=np.int64)
|
||||
for i in range(n):
|
||||
for j in range(n):
|
||||
if i != j:
|
||||
matrix[i, j] = (zwischen[familie[i], familie[j]]
|
||||
+ max(0, farbe[i] - farbe[j]) * 3)
|
||||
return matrix
|
||||
|
||||
|
||||
def gesamtruestzeit(reihe: list[int], matrix: np.ndarray) -> int:
|
||||
return int(sum(matrix[reihe[k], reihe[k + 1]] for k in range(len(reihe) - 1)))
|
||||
|
||||
|
||||
def faustregel(matrix: np.ndarray) -> list[int]:
|
||||
n = len(matrix)
|
||||
offen = set(range(1, n))
|
||||
reihe = [0]
|
||||
while offen:
|
||||
naechster = min(offen, key=lambda j: matrix[reihe[-1], j])
|
||||
reihe.append(naechster)
|
||||
offen.discard(naechster)
|
||||
return reihe
|
||||
|
||||
|
||||
def delta_verschieben(reihe: list[int], matrix: np.ndarray, von: int, nach: int):
|
||||
n = len(reihe)
|
||||
if von == nach or nach == von + 1:
|
||||
return None
|
||||
heraus = 0
|
||||
if von > 0:
|
||||
heraus += matrix[reihe[von - 1], reihe[von]]
|
||||
if von < n - 1:
|
||||
heraus += matrix[reihe[von], reihe[von + 1]]
|
||||
if 0 < von < n - 1:
|
||||
heraus -= matrix[reihe[von - 1], reihe[von + 1]]
|
||||
rest = reihe[:von] + reihe[von + 1:]
|
||||
stelle = nach if nach < von else nach - 1
|
||||
hinein = 0
|
||||
if stelle > 0:
|
||||
hinein += matrix[rest[stelle - 1], reihe[von]]
|
||||
if stelle < len(rest):
|
||||
hinein += matrix[reihe[von], rest[stelle]]
|
||||
if 0 < stelle < len(rest):
|
||||
hinein -= matrix[rest[stelle - 1], rest[stelle]]
|
||||
return int(hinein - heraus), rest, stelle
|
||||
|
||||
|
||||
# --- Die Suche, um die Verlaufsaufzeichnung ergaenzt ------------------------
|
||||
|
||||
def suche_mit_verlauf(matrix: np.ndarray, start_temperatur: float,
|
||||
saat: int = 1, bergsteigen: bool = False,
|
||||
end_temperatur: float = 0.05):
|
||||
"""Wie suche() im Buchprogramm, protokolliert zusaetzlich den Zielwert.
|
||||
|
||||
Aufgezeichnet wird der AKTUELLE Zustand, nicht der beste. Genau darin liegt
|
||||
die Aussage: Der beste Wert faellt bei jedem Verfahren monoton - was die
|
||||
Verfahren unterscheidet, ist, wie weit sich die Suche unterwegs vom Guten
|
||||
entfernen darf.
|
||||
"""
|
||||
rng = np.random.default_rng(saat)
|
||||
n = len(matrix)
|
||||
reihe = faustregel(matrix)
|
||||
kosten = gesamtruestzeit(reihe, matrix)
|
||||
beste_kosten = kosten
|
||||
takt = max(1, ZUEGE // STUETZSTELLEN)
|
||||
x, y, temperaturen = [0], [kosten], [start_temperatur]
|
||||
|
||||
for zug in range(ZUEGE):
|
||||
temperatur = start_temperatur * (end_temperatur / start_temperatur) \
|
||||
** (zug / ZUEGE)
|
||||
von = int(rng.integers(0, n))
|
||||
nach = int(rng.integers(0, n + 1))
|
||||
ergebnis = delta_verschieben(reihe, matrix, von, nach)
|
||||
if ergebnis is not None:
|
||||
aenderung, rest, stelle = ergebnis
|
||||
if aenderung <= 0:
|
||||
annehmen = True
|
||||
else:
|
||||
annehmen = (not bergsteigen
|
||||
and rng.random() < math.exp(-aenderung / temperatur))
|
||||
if annehmen:
|
||||
reihe = rest[:stelle] + [reihe[von]] + rest[stelle:]
|
||||
kosten += aenderung
|
||||
beste_kosten = min(beste_kosten, kosten)
|
||||
if (zug + 1) % takt == 0:
|
||||
x.append(zug + 1)
|
||||
y.append(kosten)
|
||||
temperaturen.append(temperatur)
|
||||
return x, y, beste_kosten, temperaturen
|
||||
|
||||
|
||||
# --- Zeichnen ---------------------------------------------------------------
|
||||
|
||||
def zeichne(verlaeufe, start, temperaturreihe) -> None:
|
||||
figur, (links, rechts) = plt.subplots(
|
||||
1, 2, figsize=(10.6, 4.4), gridspec_kw={"width_ratios": [1.7, 1]})
|
||||
|
||||
links.axhline(start, color=GRAU, linewidth=1.2, linestyle="--", zorder=1)
|
||||
links.annotate(f"Faustregel: {start:,}".replace(",", "."),
|
||||
(ZUEGE, start), textcoords="offset points", xytext=(-4, 6),
|
||||
ha="right", fontsize=8, color="#475569")
|
||||
|
||||
for (name, farbe, breite), (x, y, bestes, _) in verlaeufe:
|
||||
links.plot(x, y, color=farbe, linewidth=breite, alpha=0.9,
|
||||
label=f"{name} → {bestes:,}".replace(",", "."))
|
||||
|
||||
links.set_xlabel("geprüfte Züge")
|
||||
links.set_ylabel("Rüstzeit des aktuellen Plans (Minuten)")
|
||||
links.set_title("Wie die Suche die Landschaft durchläuft", fontsize=10.5)
|
||||
links.grid(linestyle=":", alpha=0.45)
|
||||
links.legend(fontsize=8, loc="upper right", frameon=False)
|
||||
links.set_xlim(0, ZUEGE)
|
||||
for rand in ("top", "right"):
|
||||
links.spines[rand].set_visible(False)
|
||||
|
||||
temperaturen = [t for t, _ in temperaturreihe]
|
||||
ergebnisse = [e for _, e in temperaturreihe]
|
||||
rechts.axhline(start, color=GRAU, linewidth=1.2, linestyle="--", zorder=1)
|
||||
rechts.plot(temperaturen, ergebnisse, "o-", color=INDIGO, markersize=5,
|
||||
linewidth=1.5, zorder=3)
|
||||
bester = int(np.argmin(ergebnisse))
|
||||
rechts.scatter([temperaturen[bester]], [ergebnisse[bester]], s=140,
|
||||
facecolors="none", edgecolors=AMBER, linewidths=2.2, zorder=4)
|
||||
rechts.annotate(f"bestes T = {temperaturen[bester]:g}",
|
||||
(temperaturen[bester], ergebnisse[bester]),
|
||||
textcoords="offset points", xytext=(10, -2),
|
||||
fontsize=8, color=AMBER)
|
||||
rechts.annotate(f"Faustregel: {start:,}".replace(",", "."),
|
||||
(temperaturen[0], start), textcoords="offset points",
|
||||
xytext=(2, 4), fontsize=8, color="#475569")
|
||||
rechts.annotate("hier ist der ganze\nVorsprung aufgezehrt",
|
||||
(temperaturen[-1], ergebnisse[-1]),
|
||||
textcoords="offset points", xytext=(-8, -4),
|
||||
ha="right", va="top", fontsize=8, color="#475569")
|
||||
rechts.set_ylim(min(ergebnisse) - 8, start + 14)
|
||||
|
||||
rechts.set_xscale("log")
|
||||
rechts.set_xticks(temperaturen)
|
||||
rechts.set_xticklabels([f"{t:g}" for t in temperaturen])
|
||||
rechts.set_xlabel("Starttemperatur $T_0$")
|
||||
rechts.set_ylabel("erreichte Rüstzeit (Minuten)")
|
||||
rechts.set_title("Das Optimum ist schmal", fontsize=10.5)
|
||||
rechts.grid(linestyle=":", alpha=0.45)
|
||||
for rand in ("top", "right"):
|
||||
rechts.spines[rand].set_visible(False)
|
||||
|
||||
figur.tight_layout()
|
||||
os.makedirs(BILDER, exist_ok=True)
|
||||
for endung in ("svg", "png"):
|
||||
pfad = os.path.join(BILDER, f"kap_metaheuristiken_landschaft.{endung}")
|
||||
figur.savefig(pfad, format=endung, dpi=160,
|
||||
metadata={"Date": None} if endung == "svg" else None)
|
||||
print(f"geschrieben: {pfad}")
|
||||
plt.close(figur)
|
||||
|
||||
|
||||
def zeichne_interaktiv(verlaeufe, start) -> None:
|
||||
"""Dieselben Verlaeufe, aber mit der Temperatur im Hover.
|
||||
|
||||
Das ist der Grund fuer die interaktive Fassung: Im statischen Bild sieht
|
||||
man, DASS die T0=8-Kurve lange oben bleibt. Hier laesst sich an jeder
|
||||
Stelle ablesen, WARUM - naemlich wie wahrscheinlich dort ein Zug typischer
|
||||
Groesse noch angenommen wird.
|
||||
"""
|
||||
figur = go.Figure()
|
||||
figur.add_hline(y=start, line=dict(color=GRAU, width=1.2, dash="dash"),
|
||||
annotation_text=f"Faustregel: {start}",
|
||||
annotation_position="bottom right")
|
||||
|
||||
for (name, farbe, breite), (x, y, bestes, temps) in verlaeufe:
|
||||
beschriftung = []
|
||||
for zug, wert, temperatur in zip(x, y, temps):
|
||||
quote = math.exp(-MEDIAN_ZUG / temperatur) if temperatur > 0 else 0.0
|
||||
beschriftung.append(
|
||||
f"<b>{wert} Minuten</b><br>nach {zug:,} Zügen<br>"
|
||||
f"Temperatur {temperatur:.3f}<br>"
|
||||
f"typischer Verschlechterungszug ({MEDIAN_ZUG} min) würde<br>"
|
||||
f"mit {quote:.1e} angenommen<extra></extra>".replace(",", "."))
|
||||
figur.add_trace(go.Scatter(
|
||||
x=x, y=y, mode="lines", name=f"{name} → {bestes}",
|
||||
line=dict(color=farbe, width=breite + 0.4),
|
||||
hovertemplate=beschriftung))
|
||||
|
||||
figur.update_layout(
|
||||
title="Der Suchverlauf — mit der Temperatur im Hover",
|
||||
xaxis=dict(title="geprüfte Züge"),
|
||||
yaxis=dict(title="Rüstzeit des aktuellen Plans (Minuten)"),
|
||||
height=430, margin=dict(l=70, r=20, t=55, b=50),
|
||||
paper_bgcolor="rgba(0,0,0,0)", plot_bgcolor="rgba(0,0,0,0)",
|
||||
legend=dict(orientation="h", y=-0.2),
|
||||
hovermode="closest")
|
||||
|
||||
os.makedirs(PLOTLY_VERZ, exist_ok=True)
|
||||
pfad = os.path.join(PLOTLY_VERZ, "kap_metaheuristiken_verlauf.html")
|
||||
with open(pfad, "w", encoding="utf-8") as datei:
|
||||
datei.write(figur.to_html(full_html=False, include_plotlyjs=False,
|
||||
div_id="kap-metaheuristiken-verlauf"))
|
||||
print(f"geschrieben: {pfad}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
matrix = erzeuge_ruestmatrix(N_AUFTRAEGE)
|
||||
start = gesamtruestzeit(faustregel(matrix), matrix)
|
||||
print(f"Instanz: {N_AUFTRAEGE} Auftraege, Faustregel {start} Minuten")
|
||||
|
||||
verlaeufe = []
|
||||
for beschriftung, kalt, temperatur in (
|
||||
(("Bergsteigen", CYAN, 1.3), True, 1.0),
|
||||
(("Annealing $T_0=1$", INDIGO, 1.3), False, 1.0),
|
||||
(("Annealing $T_0=8$", AMBER, 1.0), False, 8.0)):
|
||||
x, y, bestes, temps = suche_mit_verlauf(matrix, temperatur, bergsteigen=kalt)
|
||||
print(f" {beschriftung[0]:<22} bestes {bestes}")
|
||||
verlaeufe.append((beschriftung, (x, y, bestes, temps)))
|
||||
|
||||
temperaturreihe = []
|
||||
for temperatur in (0.5, 1.0, 2.0, 4.0, 8.0):
|
||||
_, _, bestes, _ = suche_mit_verlauf(matrix, temperatur)
|
||||
temperaturreihe.append((temperatur, bestes))
|
||||
print(f" T0={temperatur:<5} -> {bestes}")
|
||||
|
||||
zeichne(verlaeufe, start, temperaturreihe)
|
||||
zeichne_interaktiv(verlaeufe, start)
|
||||
Loading…
Reference in a new issue