360912dbfa
Drei Aufraeumarbeiten - und zwei Funde, die dabei auffielen.
1. DIE PNG-ZWEITFASSUNGEN SIND WEG. Jedes Diagramm lag doppelt vor, als SVG
und als PNG, und kein einziges src=/href= in der Website zeigte je auf ein
PNG. Der Build kopierte sie trotzdem mit: 3,3 MB im Repository plus 3,3 MB,
die bei jeder Veroeffentlichung auf den Webserver gingen. Die 15 Generatoren
schreiben jetzt nur noch SVG, die Docstrings sind mitgezogen. Vor dem
Loeschen geprueft: Jedes PNG hatte sein gleichnamiges SVG, alle 33 waren
versioniert.
FUND 1: erzeuge_kap06_gantt.py folgte als einziger Generator nicht der
Konvention - weder svg.hashsalt noch metadata={"Date": None}. Sein SVG trug
einen echten Zeitstempel und bei jedem Lauf andere clip-path-IDs, war also
nie byteidentisch reproduzierbar, obwohl CLAUDE.md genau das fuer alle
Generatoren festhaelt. Aufgefallen nur, weil nach der PNG-Umstellung 32 von
33 SVGs bitgleich blieben und eines nicht. Jetzt byteidentisch ueber zwei
Laeufe.
FUND 2: spiegle_bilder() legte leere Verzeichnisse auf dem Webserver an. Der
Dateifilter arbeitete korrekt, aber os.walk durchlief auch __pycache__/, und
os.makedirs() erzeugte es am Ziel. Die Verzeichnisliste wird jetzt vorher
gefiltert. Gegengetestet.
2. BAU-UEBERBLEIBSEL entfernt (alle ignoriert und neu erzeugbar):
svg-inkscape/, build_v04.log, .pytest_cache/, Programme/output/, vier
__pycache__/ und die Excel-Mappen. Arbeitsbaum 36 -> 33 MB, danach null
ignorierte Ueberbleibsel.
3. Excel_Bruecke.py SCHREIBT NEBEN DAS SKRIPT statt ins
Arbeitsverzeichnis. Es benutzte blanke relative Namen; wer es aus der
Repository-Wurzel startete, verstreute dort produktionsmix.xlsx und
produktionsmix_ergebnis.xlsx. Jetzt wie die vier anderen schreibenden
Programme ueber os.path.dirname(os.path.abspath(__file__)). Nachgemessen:
Lauf aus der Wurzel legt dort null Dateien ab.
Ausserdem git gc: 653 lose Objekte gepackt, .git von 71 MB auf 28 MB -
reines Repacken, kein Inhalt beruehrt.
Geprueft: alle 33 im Buch referenzierten SVGs vorhanden, in Quelle und
Website; 16 Generatoren fehlerfrei; keine fehlenden Bilder im LaTeX-Lauf;
33 pytest-Tests; PDF unveraendert 760 Seiten.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
207 lines
7.5 KiB
Python
207 lines
7.5 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# erzeuge_pareto_front.py
|
|
"""
|
|
Erzeugt das Pareto-Front-Diagramm zum Mehrziel-Kapitel in zwei Fassungen:
|
|
|
|
bilder_04/kap_mehrziel_pareto.svg statisch, fuer das PDF
|
|
bilder_04/plotly/kap_mehrziel_pareto.html interaktiv, fuer die Website
|
|
|
|
Die Instanz ist identisch mit Mehrziel_Pareto.py, und gerechnet wird hier
|
|
erneut - so koennen Diagramm und Buchtext nicht auseinanderlaufen.
|
|
|
|
Das Diagramm zeigt genau die Aussage des Kapitels: Die untere konvexe Huelle
|
|
(gestrichelt) ist alles, was eine gewichtete Summe je erreichen kann. Die
|
|
Punkte darueber sind Pareto-optimal und trotzdem fuer kein Gewicht zu haben.
|
|
|
|
Aufruf (aus dem Repository-Wurzelverzeichnis):
|
|
python3 bilder_04/erzeuge_pareto_front.py
|
|
|
|
Benoetigt: numpy, scipy, matplotlib, plotly
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
|
|
import matplotlib
|
|
matplotlib.use("Agg")
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
import plotly.graph_objects as go
|
|
from scipy.optimize import linprog
|
|
|
|
# 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 = "#4338ca", "#0891b2", "#b45309"
|
|
BAHN_TRASSEN = 5
|
|
|
|
|
|
# --- Instanz und Modell: wortgleich zu Mehrziel_Pareto.py -------------------
|
|
|
|
def erzeuge_sendungen(anzahl: int = 12, saat: int = 5):
|
|
rng = np.random.default_rng(saat)
|
|
kosten = np.zeros((anzahl, 3))
|
|
co2 = np.zeros((anzahl, 3))
|
|
for i in range(anzahl):
|
|
grund_kosten = rng.integers(600, 2400)
|
|
grund_co2 = rng.integers(400, 1800)
|
|
kosten[i] = [grund_kosten,
|
|
grund_kosten * rng.uniform(0.55, 0.85),
|
|
grund_kosten * rng.uniform(0.70, 1.00)]
|
|
co2[i] = [grund_co2,
|
|
grund_co2 * rng.uniform(0.15, 0.35),
|
|
grund_co2 * rng.uniform(0.40, 0.70)]
|
|
return np.round(kosten).astype(int), np.round(co2).astype(int)
|
|
|
|
|
|
KOSTEN, CO2 = erzeuge_sendungen()
|
|
N = len(KOSTEN)
|
|
|
|
|
|
def plane(ziel, co2_grenze=None):
|
|
gleichungen = np.zeros((N, N * 3))
|
|
for i in range(N):
|
|
gleichungen[i, i * 3:(i + 1) * 3] = 1.0
|
|
ungleichungen = [[1.0 if j == 1 else 0.0 for _ in range(N) for j in range(3)]]
|
|
grenzen = [float(BAHN_TRASSEN)]
|
|
if co2_grenze is not None:
|
|
ungleichungen.append(CO2.reshape(-1).astype(float))
|
|
grenzen.append(float(co2_grenze))
|
|
ergebnis = linprog(ziel.reshape(-1).astype(float),
|
|
A_ub=ungleichungen, b_ub=grenzen,
|
|
A_eq=gleichungen, b_eq=np.ones(N),
|
|
bounds=(0, 1), integrality=1, method="highs")
|
|
if not ergebnis.success:
|
|
return None
|
|
plan = np.round(ergebnis.x).astype(int)
|
|
return int(KOSTEN.reshape(-1) @ plan), int(CO2.reshape(-1) @ plan)
|
|
|
|
|
|
def pareto_front():
|
|
front = []
|
|
grenze = plane(KOSTEN)[1]
|
|
while True:
|
|
ergebnis = plane(KOSTEN, co2_grenze=grenze)
|
|
if ergebnis is None:
|
|
return front
|
|
front.append(ergebnis)
|
|
grenze = ergebnis[1] - 1
|
|
|
|
|
|
def untere_huelle(punkte):
|
|
huelle = []
|
|
for punkt in sorted(punkte):
|
|
while len(huelle) >= 2:
|
|
(x1, y1), (x2, y2) = huelle[-2], huelle[-1]
|
|
if (x2 - x1) * (punkt[1] - y1) - (y2 - y1) * (punkt[0] - x1) <= 0:
|
|
huelle.pop()
|
|
else:
|
|
break
|
|
huelle.append(punkt)
|
|
return huelle
|
|
|
|
|
|
# --- Statische Fassung ------------------------------------------------------
|
|
|
|
def zeichne_statisch(front, huelle) -> None:
|
|
unerreichbar = [p for p in front if p not in huelle]
|
|
figur, achse = plt.subplots(figsize=(7.2, 4.4))
|
|
|
|
hx, hy = zip(*huelle)
|
|
achse.plot(hx, hy, linestyle="--", color=INDIGO, linewidth=1.4, zorder=1,
|
|
label="untere konvexe Hülle")
|
|
achse.scatter(hx, hy, s=70, color=INDIGO, zorder=3,
|
|
label=f"von Gewichten erreichbar ({len(huelle)})")
|
|
if unerreichbar:
|
|
ux, uy = zip(*unerreichbar)
|
|
achse.scatter(ux, uy, s=90, facecolors="none", edgecolors=AMBER,
|
|
linewidths=2.0, zorder=4,
|
|
label=f"Pareto-optimal, aber unerreichbar ({len(unerreichbar)})")
|
|
|
|
for x, y in front:
|
|
achse.annotate(f"{y:,} kg".replace(",", "."), (x, y),
|
|
textcoords="offset points", xytext=(6, 6), fontsize=7,
|
|
color="#475569")
|
|
|
|
achse.set_xlabel("Transportkosten (EUR)")
|
|
achse.set_ylabel("CO₂-Ausstoß (kg)")
|
|
achse.set_title("Pareto-Front: Kosten gegen CO₂", fontsize=11)
|
|
achse.grid(linestyle=":", alpha=0.5)
|
|
for rand in ("top", "right"):
|
|
achse.spines[rand].set_visible(False)
|
|
achse.legend(fontsize=8, loc="upper right", frameon=False)
|
|
figur.tight_layout()
|
|
|
|
os.makedirs(BILDER, exist_ok=True)
|
|
for endung in ("svg",):
|
|
pfad = os.path.join(BILDER, f"kap_mehrziel_pareto.{endung}")
|
|
figur.savefig(pfad, format=endung, dpi=160,
|
|
metadata={"Date": None} if endung == "svg" else None)
|
|
print(f"geschrieben: {pfad}")
|
|
plt.close(figur)
|
|
|
|
|
|
# --- Interaktive Fassung ----------------------------------------------------
|
|
|
|
def zeichne_interaktiv(front, huelle) -> None:
|
|
unerreichbar = [p for p in front if p not in huelle]
|
|
guenstigst = front[0]
|
|
figur = go.Figure()
|
|
|
|
hx, hy = zip(*huelle)
|
|
figur.add_trace(go.Scatter(
|
|
x=hx, y=hy, mode="lines", line=dict(color=INDIGO, dash="dash", width=1.5),
|
|
name="untere konvexe Hülle", hoverinfo="skip"))
|
|
|
|
def beschriftung(punkt):
|
|
aufpreis = punkt[0] - guenstigst[0]
|
|
ersparnis = guenstigst[1] - punkt[1]
|
|
preis = f"{aufpreis / ersparnis:.2f} EUR je kg" if ersparnis else "Kostenminimum"
|
|
return (f"<b>{punkt[0]:,} EUR</b><br>{punkt[1]:,} kg CO₂<br>"
|
|
f"Aufpreis {aufpreis:,} EUR<br>"
|
|
f"Ersparnis {ersparnis:,} kg<br>{preis}<extra></extra>")
|
|
|
|
figur.add_trace(go.Scatter(
|
|
x=hx, y=hy, mode="markers", marker=dict(size=11, color=INDIGO),
|
|
name=f"von Gewichten erreichbar ({len(huelle)})",
|
|
hovertemplate=[beschriftung(p) for p in huelle]))
|
|
|
|
if unerreichbar:
|
|
ux, uy = zip(*unerreichbar)
|
|
figur.add_trace(go.Scatter(
|
|
x=ux, y=uy, mode="markers",
|
|
marker=dict(size=13, color="rgba(0,0,0,0)",
|
|
line=dict(color=AMBER, width=2.5)),
|
|
name=f"Pareto-optimal, aber unerreichbar ({len(unerreichbar)})",
|
|
hovertemplate=[beschriftung(p) for p in unerreichbar]))
|
|
|
|
figur.update_layout(
|
|
title="Pareto-Front: Kosten gegen CO₂",
|
|
xaxis=dict(title="Transportkosten (EUR)"),
|
|
yaxis=dict(title="CO₂-Ausstoß (kg)"),
|
|
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_mehrziel_pareto.html")
|
|
with open(pfad, "w", encoding="utf-8") as datei:
|
|
datei.write(figur.to_html(full_html=False, include_plotlyjs=False,
|
|
div_id="kap-mehrziel-pareto"))
|
|
print(f"geschrieben: {pfad}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
front = pareto_front()
|
|
huelle = untere_huelle(front)
|
|
print(f"Pareto-Punkte: {len(front)}, davon gestuetzt: {len(huelle)}, "
|
|
f"unerreichbar: {len(front) - len(huelle)}")
|
|
zeichne_statisch(front, huelle)
|
|
zeichne_interaktiv(front, huelle)
|