Was ist Log Loss?

Log Loss ist eine logarithmische Transformation der Likelihood‑Funktion und wird hauptsächlich zur Bewertung der Leistung probabilistischer Klassifikatoren verwendet. Im Gegensatz zu anderen Metriken wie der Genauigkeit berücksichtigt Log Loss die Unsicherheit von Vorhersagen, indem Modelle für selbstbewusst falsche Vorhersagen deutlich stärker bestraft werden.

Die Formal lautet:

Wobei:

• die Anzahl der Beobachtungen ist.
• ist die binäre Vorhersage (also oder ) der i. Beobachtung.
• ist die Vorhersagewahrscheinlichkeit, das die i. Beobachtung zur Klasse gehört.

Verständnis von Log Loss‑Werten

Ein niedriger Log Loss weist auf eine bessere Modellleistung hin. Ein Log Loss von bedeutet, dass die vorhergesagten Wahrscheinlichkeiten die tatsächlichen Ergebnisse perfekt widerspiegeln, während höhere Werte auf zunehmende Abweichungen hinweisen. Es ist wichtig zu beachten, dass Log Loss empfindlich auf die Sicherheit der Vorhersagen reagiert, was ihn zu einer leistungsstarken Kennzahl für die Bewertung probabilistischer Modelle macht.

Log Loss in Klassifikationsproblemen

Log Loss wird häufig in binären und multiklassigen Klassifikationsproblemen verwendet, insbesondere bei Modellen, die Wahrscheinlichkeitswerte für jede Klasse ausgeben (z.B. logistische Regression, neuronale Netze). Er motiviert Modelle dazu, nicht nur korrekt, sondern auch sicher in ihren Vorhersagen zu sein, was ihn besonders nützlich in Szenarien macht, in denen Fehlklassifikationen unterschiedlich hohe Kosten verursachen.

from sklearn.metrics import log_loss
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# 1. Beispiel-Daten erzeugen (binäre Klassifikation)
X, y = make_classification(
    n_samples=500,
    n_features=4,
    n_informative=3,
    n_redundant=1,
    random_state=2009
)

# 2. Train/Test-Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Modell trainieren
model = LogisticRegression()
model.fit(X_train, y_train)

# 4. Wahrscheinlichkeiten vorhersagen
y_pred_proba = model.predict_proba(X_test)

# 5. Log Loss berechnen
loss = log_loss(y_test, y_pred_proba)

print(f"Log Loss: {loss:.4}")

Log Loss: 0.3049

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss

# 1. Synthetisches Multiclass-Dataset erzeugen
X, y = make_classification(
    n_samples=600,
    n_features=6,
    n_informative=4,
    n_redundant=2,
    n_classes=3,          # Multiclass!
    n_clusters_per_class=1,
    random_state=2009
)

# 2. Train/Test-Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

# 3. Multiclass-Logistische Regression (softmax)
model = LogisticRegression(solver="lbfgs")
model.fit(X_train, y_train)

# 4. Wahrscheinlichkeiten für alle Klassen vorhersagen
y_pred_proba = model.predict_proba(X_test)

# 5. Multiclass Log Loss berechnen
loss = log_loss(y_test, y_pred_proba)

print(f"Multiclass Log Loss: {loss:.4}")

Multiclass Log Loss: 0.2195

Mathematische Definition

Für ein Klassifikationsproblem mit Beobachtungen und Klassen lautet der Logarithmic Loss (Cross‑Entropy Loss):

wobei:

• : One-Hot-Label der wahren Klasse. (1, wenn Beispiel zur Klasse gehört, sonst )

• : Vorhergesagte Wahrscheinlichkeit, dass Beispiel zur Klasse gehört (vom Modell ausgegeben, z.B. durch Softmax)

• : Anzahl der Datenpunkte

• : Anzahl der Klassen

Intuitive Interpätation der Werte

Wenn das Modell hohe Wahrscheinlichkeit für die richtige Klasse vergibt kleiner Log Loss

Wenn das Modell sicher falsch liegt großer Log Loss

Perfekte Vorhersagen Log Loss = 0

Typische Werte liegen zwischen und , je nach Schwierigkeit des Problems.

Genauigkeit

Genauigkeit (engl. Accuracy) misst nur richtig oder falsch Accuracy berechnet den Anteil korrekt vorhergesagter Klassen:

• Jede Vorhersage zählt gleich viel
  
• Die Höhe der Wahrscheinlichkeit spielt keine Rolle
  
• Ein Modell mit 51 % Wahrscheinlichkeit für die richtige Klasse gilt als genauso korrekt wie eines mit 99 %

Vorteil: Einfach zu verstehen
Nachteil: Ignoriert Unsicherheit und Kalibrierung

Logarithmischer Verlust

Logarithmischer Verlust (engl. Log Loss) misst die Qualität der Wahrscheinlichkeiten Log Loss bewertet, wie gut die vorhergesagten Wahrscheinlichkeiten zu den tatsächlichen Labels passen.

• Bestraft selbstbewusst falsche Vorhersagen stark
  
• Belohnt gut kalibrierte Wahrscheinlichkeiten
  
• Nutzt die vollständige Wahrscheinlichkeitsverteilung (z. B. Softmax)

Vorteil: Sehr empfindlich gegenüber Unsicherheit
Nachteil: Schwerer zu interpretieren als Accuracy

Konkretes Beispiel

Accuracy sagt: Beide Modelle sind gleich gut.
Log Loss sagt: Modell B ist deutlich besser, weil es sicherer und besser kalibriert ist.

Wann verwende ich (eher) was?

Fazit

Accuracy misst, ob du richtig liegst.
Log Loss misst, wie gut du weißt, dass du richtig liegst.

(Einfache) Lineare Regression

Wir beginnen mit einer einfachen linearen Regression. Dabei erstellen wir ein Model, bei dem wir die Länge des Kronblatts (petal length) auf Grundlage der Länge des Kelchblatts (sepal length) modellieren wollen.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Zielvariable y_reg: Petal Length
y_reg = X["petal length (cm)"]
# Modellierungsvariable X_reg: Sepal Legth
X_reg = X.drop(columns=["petal length (cm)", "sepal width (cm)", "petal width (cm)"])

Wir teilen nun unsere Daten in Test- und Trainingsdaten auf. Dabei sollen der Daten zu Testdaten werden und zu Trainingsdaten.

Die Auswahl erfolgt zufällig. Wobei wir hier einen mit random_state=2009 dafür sorgen, dass dieser Zufall reproduzierbar ist.

# Aufteilen in Test- und Trainingsdaten
X_train, X_test, y_train, y_test = train_test_split(X_reg, y_reg, test_size=0.2, random_state=2009)

Nun erstellen wir das lineare Regressionmodell und trainieren dieses mit den Daten X_train und y_train

# Modell
linreg = LinearRegression()
linreg.fit(X_train, y_train)

LinearRegression()

Um das Modell zu prüfen lassen wir es nun aus unseren Testdaten (X_test) die Zieldaten (y_pred) modellieren:

# Vorhersage
y_pred = linreg.predict(X_test)

Da wir mit y_test die tatsächlichen Daten kennen, können wir das nun mit unserem vom Modell modellierten Werten vergleichen und so unsere Modell bewerten.

Wir nutzen dazu das die mittlere quadratische Abweichung (engl. mean squared error, kurz MSE) und das Bestimmtheitsmaß .

print("MSE:", mean_squared_error(y_test, y_pred))
print("R^2:", linreg.score(X_reg, y_reg))

MSE: 0.7036607653595639
R^2: 0.7593651994880084

Wir können die Regressiongerade mit Hilfe der Koeffizienten und der Ordinate (engl.: Intercept) bestimmen:

Koeffizienten: [1.87753167]
Intercept: -7.252744633173977

Daraus ergibt sich für die Regressiongerade die Darstellung:

Schauen wir uns das Streudiagramm unserer Test-und Trainingsdaten mit der Regressiongeraden an:

import matplotlib.pyplot as plt
import numpy as np

plt.figure(figsize=(8, 5))

# Streudiagramm der Trainingsdaten
plt.scatter(X_train, y_train, color="blue", label="Trainingswerte")
plt.scatter(X_test, y_test, color="green", label="Testwerte")

# Regressionsgerade
xp = np.linspace(4,8,200)
yp = a * xp + b
pm = "+" if b >= 0 else "-"
plt.plot(xp, yp, label=r'$\hat{y}$'+f'= {a}x {pm} {absb}', color='red')


plt.xlabel("Länge des Kelchblatts (cm)")
plt.ylabel("Länge des Kronblatts (cm)")
plt.title("Lineare Regression auf den Liliendaten")
plt.legend()
plt.grid(True)
plt.show()

(Multiple) Lineare Regression

Wir wollen nun bei der Modellierung auf alle drei anderen numerischen Variabeln zurpückgreifen. Das führt zu einer multiplen linearen Regression.

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Zielvariable: Petal Length
y_reg = X["petal length (cm)"]

# Modellierungsvariablen: Sepal Width, Petal Length und Petal Width
X_reg = X.drop(columns=["petal length (cm)"])

# Aufteilen in Test- und Trainingsdaten
X_train, X_test, y_train, y_test = train_test_split(X_reg, y_reg, test_size=0.20, random_state=2009)

# Modell
linreg = LinearRegression()
linreg.fit(X_train, y_train)

# Vorhersage
y_pred = linreg.predict(X_test)

print("MSE:", mean_squared_error(y_test, y_pred))
print("R^2:", linreg.score(X_reg, y_reg))

MSE: 0.11749487412693703
R^2: 0.9675532979408549

print("Koeffizienten:", linreg.coef_)
print("Intercept:", linreg.intercept_)

Koeffizienten: [ 0.70649516 -0.66257783  1.49483392]
Intercept: -0.11204676270834524

Wir erhalten somit die folgende Regressionsfunktion:

Einfache Logistische Regression

Unsere Liliendaten bestehen aus den Längen und Breiten der Kelch- bzw. Korbblüten von drei Lilienarten. In der Variable y sind diese Arten wie folgt kodiert:

0 = setosa

1 = versicolor

2 = virginica

Wir schauen uns zunächst nur die Iris setosa an, dafür setzen wir ‘y’ immer dann auf 1, wenn eine solche Lilienart vorliegt, sonst auf 0:

y_setosa = np.where( y == 0, 1, 0)
y_setosa
X_setosa = X.drop(columns=["petal length (cm)", "sepal width (cm)", "petal width (cm)"])
X_setosa

Betrachten wir nun unsere Situation als Streudiagramm:

plt.figure(figsize=(8, 5))

plt.subplot(1,2,1)
setosa = X_setosa[y_setosa == 1]
notsetosa = X_setosa[y_setosa == 0]
plt.ylim(3,8)
setosa.boxplot()
plt.title("Iris setosa")
plt.subplot(1, 2, 2)
notsetosa.boxplot()
plt.ylim(3, 8)
plt.title("Nicht Iris setosa")


#grp =[X_setosa[y_setosa == g] for g in (0, 1)]
#plt.boxplot(grp, tick_labels=["I. setosa", "Nicht I. setosa"])
plt.show()

Wenn wir eine lineare Regression nur der ??? durchführen würden, so sähe das wie folgt aus:

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error

# Aufteilen in Test- und Trainingsdaten
X_train, X_test, y_train, y_test = train_test_split(X_setosa, y_setosa, test_size=0.2, random_state=2009)
#X_train
#y_train

linmod_linreg = LinearRegression()
linmod_linreg.fit(X_train, y_train)

LinearRegression()

Koeffizienten: [-0.40773779]
Intercept: 2.7296683561998614

Das Streudiagramm

import matplotlib.pyplot as plt
import numpy as np

plt.figure(figsize=(8, 5))

# Streudiagramm der Trainingsdaten
plt.scatter(X_train, y_train, color="blue", label="Trainingswerte")
# plt.scatter(X_test, y_test, color="green", label="Testwerte")

# Regressionsgerade
xp = np.linspace(4,8,200)
yp = a * xp + b
pm = "+" if b >= 0 else "-"
plt.plot(xp, yp, label=r'$\hat{y}$'+f'= {a}x {pm} {absb}', color='red')


plt.xlabel("Länge des Kelchblatts (cm)")
plt.ylabel("Länge des Kronblatts (cm)")
plt.title("Lineare Regression auf den Liliendaten")
plt.legend()
plt.grid(True)
plt.show()

Statt des linearen Ansatzes, wollen wir eine Wahrscheinlichkeit modellieren ob eine entsprechende Länge des Kelchsblattes für oder gegen eine Iris setosa spricht.

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Modell
logreg = LogisticRegression(max_iter=200)
logreg.fit(X_train, y_train)

LogisticRegression(max_iter=200)

a = round(logreg.coef_.item(), 4)
b = round(logreg.intercept_.item(), 4)

import matplotlib.pyplot as plt
import numpy as np

plt.figure(figsize=(8, 5))

# Streudiagramm der Trainingsdaten
plt.scatter(X_train, y_train, color="blue", label="Trainingswerte")
plt.scatter(X_test, y_test, color="green", label="Testwerte")

# Regressionsfunktion ermitteln
import pandas as pd

xp = pd.DataFrame(
    np.linspace(4, 8, 200),
    columns=["sepal length (cm)"]
)
yp = logreg.predict_proba(xp)[:,1] 
pm = "+" if b >= 0 else "-"
plt.plot(xp, yp, label=r'$P(y = 1) = $'+f'expit({a}x {pm} {absb})', color='red')


plt.xlabel("Länge des Kelchblatts (cm)")
plt.ylabel("Wahrscheinlichkeit für Iris setosa")
plt.title("Logistische Regression auf den Liliendaten")
plt.legend()
plt.grid(True)
plt.show()

Dabei bezeichnet die logistische Funktion (auch sigmonide Funktion genannt) und ist die Umkehrfunktion der -Funktion.

Wir können an der Grafik schon erkennen, das unser Ansatz so nicht unbedingt optimal ist. Schauen wir uns aber dennoch die Gütemaße an:

y_test
y_pred = logreg.predict(X_test)
y_pred

array([1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1,
       1, 1, 0, 0, 0, 0, 0, 1])

from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report

print("Accuracy:", accuracy_score(y_test, y_pred))

print("Precision:", precision_score(y_test, y_pred))

print("Recall:", recall_score(y_test, y_pred))

print("F1-Score:", f1_score(y_test, y_pred))

Accuracy: 0.9
Precision: 0.75
Recall: 0.8571428571428571
F1-Score: 0.8

Etwas detailierter können wir uns das mit dem folgenden Befehl komplett ansehen:

print(classification_report(y_test, y_pred, target_names=["positiv", "negativ"], digits=3))

              precision    recall  f1-score   support

     positiv      0.955     0.913     0.933        23
     negativ      0.750     0.857     0.800         7

    accuracy                          0.900        30
   macro avg      0.852     0.885     0.867        30
weighted avg      0.907     0.900     0.902        30

Wagen wir kurz einen Blick auf alle Daten (Test- wie Trainingsdaten):

print(classification_report(y_setosa, logreg.predict(X_setosa), target_names=["negativ", "positiv"], digits=3))

              precision    recall  f1-score   support

     negativ      0.904     0.940     0.922       100
     positiv      0.870     0.800     0.833        50

    accuracy                          0.893       150
   macro avg      0.887     0.870     0.877       150
weighted avg      0.892     0.893     0.892       150

Multinomiale Logistische Regression

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report

Wir teilen unsere Daten wieder in Test- und Trainingsdaten auf:

# Klassifikationsdaten
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2009)

Erstelen wir nun ein logistisches Regressionsmodell und trainieren dieses.

# Modell
logreg = LogisticRegression(max_iter=200)
logreg.fit(X_train, y_train)

LogisticRegression(max_iter=200)

Erzeugen wir nun aus unserem Modell eine Vorhersage für die Testdaten:

# Vorhersage
y_pred = logreg.predict(X_test)

Schauen wir uns für die Testdaten einmal die echten und vorhergesagten Werte an:

# Vergleich der Testdaten
y_test
y_pred

array([0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 1, 0, 1, 1, 0,
       0, 1, 1, 2, 1, 2, 1, 0])

Berechnen wir die üblichen Gütemaße:

print("Accuracy:", accuracy_score(y_test, y_pred))

print("Precision:", precision_score(y_test, y_pred, average='weighted'))

print("Recall:", recall_score(y_test, y_pred, average='weighted'))

print("F1-Score:", f1_score(y_test, y_pred, average='weighted'))

Accuracy: 0.9333333333333333
Precision: 0.9454545454545454
Recall: 0.9333333333333333
F1-Score: 0.9341025641025641

Etwas detailierter können wir uns das mit dem folgenden Befehl komplett ansehen:

print(classification_report(y_test, y_pred, target_names=iris.target_names, digits=3))

              precision    recall  f1-score   support

      setosa      1.000     1.000     1.000         7
  versicolor      0.818     1.000     0.900         9
   virginica      1.000     0.857     0.923        14

    accuracy                          0.933        30
   macro avg      0.939     0.952     0.941        30
weighted avg      0.945     0.933     0.934        30

Wagen wir kurz einen Blick auf alle Daten (Test- wie Trainingsdaten):

print(classification_report(y, logreg.predict(X), target_names=iris.target_names, digits=3))

              precision    recall  f1-score   support

      setosa      1.000     1.000     1.000        50
  versicolor      0.923     0.960     0.941        50
   virginica      0.958     0.920     0.939        50

    accuracy                          0.960       150
   macro avg      0.960     0.960     0.960       150
weighted avg      0.960     0.960     0.960       150

Warum NumPy?

NumPy, kurz für “Numerical Python”, ist eine Bibliothek, die effiziente Operationen auf großen, mehrdimensionalen Arrays und Matrizen ermöglicht. Hier sind einige Gründe, warum NumPy so beliebt ist:

1. Leistung: NumPy ist in C und Fortran geschrieben, was es extrem schnell macht. Es bietet Funktionen, die auf Vektorisierung basieren, wodurch Operationen auf Arrays viel schneller ausgeführt werden können als mit herkömmlichen Python-Listen.

2. Funktionalität: NumPy bietet eine breite Palette von Funktionen für mathem atische Operationen, lineare Algebra, Fourier-Transformationen und vieles mehr. Es ist die Grundlage für viele andere Bibliotheken wie SciPy, Matplotlib und Pandas.

3. Kompatibilität: Viele andere Bibliotheken in der Datenwissenschaft und maschinellen Lernen basieren auf NumPy, was es zu einem unverzichtbaren Werkzeug für die Arbeit mit Daten macht.

4. Einfachheit: NumPy bietet eine einfache und intuitive Syntax für die Arbeit mit Arrays, was es Anfängern leicht macht, sich in die Welt der Datenanalyse einzuarbeiten

Kurz:

“NumPy = schnelle Mathematik + feste Typen + große Reihungen” in Python

import time
# Erstellen einer Liste mit 10 Million Zahlen
my_list = list(range(10_000_000))
# Startzeit
start_time = time.time()
# Hinzufügen von 10 zu jedem Element in der Liste
for i in range(len(my_list)):
    my_list[i] += 10
# Endzeit
end_time = time.time()
print(f"Zeit für die Addition in der Liste: {end_time - start_time:0.4} Sekunden")

Zeit für die Addition in der Liste: 0.7197 Sekunden

import numpy as np
import time
# Erstellen eines NumPy-Arrays mit 10 Million Zahlen
my_array = np.arange(10_000_000)
# Startzeit
start_time = time.time()
# Hinzufügen von 10 zu jedem Element im Array
my_array += 10
# Endzeit
end_time = time.time()
print(f"Zeit für die Addition im NumPy-Array: {end_time - start_time:0.4} Sekunden.")

Zeit für die Addition im NumPy-Array: 0.00966 Sekunden.

import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print(array_1d)

[1 2 3 4 5]

# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(array_2d)

[[1 2 3]
 [4 5 6]]

# Erstellen eines Arrays mit Nullen
zeros_array = np.zeros((3, 3))
print(zeros_array)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

# Erstellen eines Arrays mit Einsen
ones_array = np.ones((2, 4))
print(ones_array)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]

# Erstellen eines Arrays mit einem bestimmten Wert
full_array = np.full((2, 3), 7)
print(full_array)

[[7 7 7]
 [7 7 7]]

# Erstellen eines Arrays mit zufälligen Werten
random_array = np.random.rand(4, 4)
print(random_array)

[[0.04524801 0.17362701 0.55020998 0.56475387]
 [0.62126866 0.79769594 0.41116384 0.63088773]
 [0.80078245 0.9323055  0.79312686 0.02891873]
 [0.67272316 0.14979315 0.78068532 0.67047379]]

# Erstellen eines Arrays der ersten 10 natürlichen Zahlen
arange_array = np.arange(10)
print(arange_array)

[0 1 2 3 4 5 6 7 8 9]

# Erstellen eines Arrays mit fünf gleichmäßig verteilten Werten zwischen 0 und 1
linspace_array = np.linspace(0, 1, 5)
print(linspace_array)

[0.   0.25 0.5  0.75 1.  ]

import numpy as np
# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Array:\n", array_2d)

Array:
 [[1 2 3]
 [4 5 6]]

# Form des Arrays
print("Shape:", array_2d.shape)

Shape: (2, 3)

# Größe des Arrays
print("Size:", array_2d.size)

Size: 6

# Anzahl der Dimensionen
print("Number of dimensions:", array_2d.ndim)

Number of dimensions: 2

import numpy as np
# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Ein 2D-Array:\n",array_2d)

Ein 2D-Array:
 [[1 2 3]
 [4 5 6]]

# Zugriff auf ein Element
print("Element at (0, 1):\n", array_2d[0, 1])

Element at (0, 1):
 2

# Zugriff auf eine Zeile
print("First row:\n", array_2d[0])

First row:
 [1 2 3]

# Zugriff auf eine Spalte
print("Second column:\n", array_2d[:, 1])

Second column:
 [2 5]

# Slicing eines Subarrays
print("Subarray (first two rows and first two columns):\n", array_2d[:2, :2])

Subarray (first two rows and first two columns):
 [[1 2]
 [4 5]]

# Slicing eines Submatrix
print("Submatrix (last row and last two columns):\n", array_2d[1:, 1:])

Submatrix (last row and last two columns):
 [[5 6]]

import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print("Ein 1D-Array:\n", array_1d)

Ein 1D-Array:
 [1 2 3 4 5]

# Zugriff auf ein Element
print("Element at index 2:\n", array_1d[2])

Element at index 2:
 3

# Slicing eines Subarrays
print("Subarray (die ersten 3 Elemente):\n", array_1d[:3])

Subarray (die ersten 3 Elemente):
 [1 2 3]

print("Subarray (die Elemente an der 2. und 3. Stelle):\n", array_1d[2:4])

Subarray (die Elemente an der 2. und 3. Stelle):
 [3 4]

import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print("Ein 1D-Array:\n", array_1d)

Ein 1D-Array:
 [1 2 3 4 5]

# Vektorisierte Operationen
print("Array + 10:\n", array_1d + 10)

Array + 10:
 [11 12 13 14 15]

print("Array * 2:\n", array_1d * 2)

Array * 2:
 [ 2  4  6  8 10]

print("Array - 1:\n", array_1d - 1)

Array - 1:
 [0 1 2 3 4]

print("Array / 2:\n", array_1d / 2)

Array / 2:
 [0.5 1.  1.5 2.  2.5]

print("Wurzel aus einem Array:\n", np.sqrt(array_1d))

Wurzel aus einem Array:
 [1.         1.41421356 1.73205081 2.         2.23606798]

import numpy as np
# Erstellen zweier 1D-Arrays
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
b = np.array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])

print("Array a:\n", a)

Array a:
 [ 1  2  3  4  5  6  7  8  9 10]

print("Array b:\n", b)

Array b:
 [10  9  8  7  6  5  4  3  2  1]

# Vektorisierte Operationen zwischen Arrays
a + b

array([11, 11, 11, 11, 11, 11, 11, 11, 11, 11])

a * b

array([10, 18, 24, 28, 30, 30, 28, 24, 18, 10])

a - b

array([-9, -7, -5, -3, -1,  1,  3,  5,  7,  9])

a / b

array([ 0.1       ,  0.22222222,  0.375     ,  0.57142857,  0.83333333,
        1.2       ,  1.75      ,  2.66666667,  4.5       , 10.        ])

import numpy as np
# Erstellen eines 1D-Arrays mit 12 Elementen
array_1d = np.arange(12) + 1
print("Ein 1D-Array:", array_1d)

Ein 1D-Array: [ 1  2  3  4  5  6  7  8  9 10 11 12]

# Reshaping in ein 2D-Array mit 3 Zeilen und 4
array_2d = array_1d.reshape(3, 4)
print("Reshaped Array (3x4):\n", array_2d)

Reshaped Array (3x4):
 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

# Reshaping in ein 2D-Array mit 4 Zeilen und 3
array_2d_4x3 = array_1d.reshape(4, 3)
print("Reshaped Array (4x3):\n", array_2d_4x3)

Reshaped Array (4x3):
 [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

# Reshaping in ein 3D-Array mit 2 Blöcken, 2 Zeilen und 3 Spalten
array_3d = array_1d.reshape(2, 2, 3)
print("Reshaped Array (2x2x3):\n", array_3d)

Reshaped Array (2x2x3):
 [[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

Warum Pandas?

Pandas ist eine Bibliothek, die speziell für die Datenanalyse und -manipulation entwickelt wurde. Der Name leitet sich vom englischen “panel datas”, eine ökonometrischen Bezeichnung für Datentabellen, ab. Hier sind einige Gründe, warum Pandas so wichtig ist:

1. Datenstrukturen: Pandas bietet zwei Hauptdatenstrukturen, den DataFrame und die Series, die es ermöglichen, Daten in tabellarischer Form zu organisieren und zu manipulieren. Diese Strukturen sind besonders nützlich für die Arbeit mit heterogenen Daten.

2. Datenmanipulation: Pandas bietet eine Vielzahl von Funktionen für die Datenmanipulation, einschließlich Filtern, Gruppieren, Pivot-Tabellen und mehr. Es ermöglicht es Benutzern, komplexe Datenoperationen mit Leichtigkeit durchzuführen.

3. Datenbereinigung: Pandas bietet leistungsstarke Werkzeuge zur Bereinigung von Daten, einschließlich Funktionen zum Umgang mit fehlenden Werten, Duplikaten und Inkonstanzen in den Daten.

4. Integration: Pandas lässt sich nahtlos mit anderen Bibliotheken wie NumPy, Matplotlib und Scikit-learn integrieren, was es zu einem unverzichtbaren Werkzeug für die Datenanalyse macht.

Kurz:

“Pandas = Tabellenkalkulation + SQL + NumPy” in Python

import pandas as pd
# Erstellen einer Series
my_series = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print("Eine Series:\n", my_series)
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)

Eine Series:
 a    10
b    20
c    30
d    40
e    50
dtype: int64
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Anzeigen der ersten 3 Zeilen
print("Die ersten 3 Zeilen:\n", my_dataframe.head(3))
# Anzeigen der letzten 2 Zeilen
print("Die letzten 2 Zeilen:\n", my_dataframe.tail(2))
# Anzeigen der Spaltennamen
print("Spaltennamen:", my_dataframe.columns)
# Anzeigen der Datenarten jeder Spalte
print("Datenarten:\n", my_dataframe.dtypes)
# Anzeigen der Anzahl der Zeilen und Spalten
print("Anzahl der Zeilen und Spalten:", my_dataframe.shape)
# Anzeigen von statistischen Zusammenfassungen der numerischen Spalten
print("Statistische Zusammenfassung:\n", my_dataframe.describe())
# Anzeigen der Informationen über den DataFrame 
print("Informationen:\n", my_dataframe.info())

Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Die ersten 3 Zeilen:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
Die letzten 2 Zeilen:
     Name  Alter    Stadt
3  David     40  Houston
4    Eve     45  Phoenix
Spaltennamen: Index(['Name', 'Alter', 'Stadt'], dtype='str')
Datenarten:
 Name       str
Alter    int64
Stadt      str
dtype: object
Anzahl der Zeilen und Spalten: (5, 3)
Statistische Zusammenfassung:
            Alter
count   5.000000
mean   35.000000
std     7.905694
min    25.000000
25%    30.000000
50%    35.000000
75%    40.000000
max    45.000000
<class 'pandas.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   Name    5 non-null      str  
 1   Alter   5 non-null      int64
 2   Stadt   5 non-null      str  
dtypes: int64(1), str(2)
memory usage: 252.0 bytes
Informationen:
 None

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston',
    'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Auswahl einer Spalte
print("Spalte 'Name':\n", my_dataframe['Name'])
# Auswahl mehrerer Spalten
print("Spalten 'Name' und 'Alter':\n", my_dataframe[['Name', 'Alter']])
# Auswahl einer Zeile basierend auf dem Index
print("Zeile mit Index 2:\n", my_dataframe.loc[2])
# Auswahl von Zeilen basierend auf ihrer Position
print("Die ersten 3 Zeilen:\n", my_dataframe.iloc[:3])
# Auswahl von Zeilen basierend auf einer Bedingung
print("Zeilen, in denen das Alter größer als 30 ist:\n", my_dataframe[my_dataframe['Alter'] > 30])
# Auswahl von Zeilen basierend auf einer Bedingung
print("Zeilen, in denen das Alter größer als 30 und kleiner gleich 40 ist:\n", my_dataframe[(my_dataframe['Alter'] > 30) & (my_dataframe['Alter'] <= 40)])

Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Spalte 'Name':
 0      Alice
1        Bob
2    Charlie
3      David
4        Eve
Name: Name, dtype: str
Spalten 'Name' und 'Alter':
       Name  Alter
0    Alice     25
1      Bob     30
2  Charlie     35
3    David     40
4      Eve     45
Zeile mit Index 2:
 Name     Charlie
Alter         35
Stadt    Chicago
Name: 2, dtype: object
Die ersten 3 Zeilen:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
Zeilen, in denen das Alter größer als 30 ist:
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston
4      Eve     45  Phoenix
Zeilen, in denen das Alter größer als 30 und kleiner gleich 40 ist:
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Filtern von Zeilen basierend auf einer Bedingung
filtered_df = my_dataframe[my_dataframe['Alter'] > 30]
print("Gefilterter DataFrame (Alter > 30):\n", filtered_df)
# Gruppieren von Daten und Berechnen von Durchschnittsalter pro Stadt
grouped_df = my_dataframe.groupby('Stadt')['Alter'].mean()
print("Durchschnittsalter pro Stadt:\n", grouped_df)
# Erstellen einer Pivot-Tabelle
pivot_table = my_dataframe.pivot_table(values='Alter', index='Stadt', aggfunc='mean')
print("Pivot-Tabelle (Durchschnittsalter pro Stadt):\n", pivot_table)

Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Gefilterter DataFrame (Alter > 30):
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston
4      Eve     45  Phoenix
Durchschnittsalter pro Stadt:
 Stadt
Chicago        35.0
Houston        40.0
Los Angeles    30.0
New York       25.0
Phoenix        45.0
Name: Alter, dtype: float64
Pivot-Tabelle (Durchschnittsalter pro Stadt):
              Alter
Stadt             
Chicago       35.0
Houston       40.0
Los Angeles   30.0
New York      25.0
Phoenix       45.0

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)

# Hinzufügen einer neuen Spalte
my_dataframe['Beruf'] = ['Ingenieur', 'Arzt', 'Lehrer', 'Künstler', 'Anwalt']
print("DataFrame mit neuer Spalte 'Beruf':\n", my_dataframe)

# Hinzufügen einer neuen Zeile
new_row = pd.Series({'Name': 'Frank', 'Alter': 50, 'Stadt': 'Miami', 'Beruf': 'Architekt'})
my_dataframe = pd.concat([my_dataframe, new_row.to_frame().T], ignore_index=True)
print("DataFrame mit neuer Zeile:\n", my_dataframe)

Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
DataFrame mit neuer Spalte 'Beruf':
       Name  Alter        Stadt      Beruf
0    Alice     25     New York  Ingenieur
1      Bob     30  Los Angeles       Arzt
2  Charlie     35      Chicago     Lehrer
3    David     40      Houston   Künstler
4      Eve     45      Phoenix     Anwalt
DataFrame mit neuer Zeile:
       Name Alter        Stadt      Beruf
0    Alice    25     New York  Ingenieur
1      Bob    30  Los Angeles       Arzt
2  Charlie    35      Chicago     Lehrer
3    David    40      Houston   Künstler
4      Eve    45      Phoenix     Anwalt
5    Frank    50        Miami  Architekt

Fazit

NumPy und Pandas sind zwei der wichtigsten Bibliotheken in der Python-Datenanalyse. NumPy bietet eine leistungsstarke Grundlage für die Arbeit mit Arrays und mathematischen Operationen, während Pandas speziell für die Datenmanipulation und -analyse entwickelt wurde. Beide Bibliotheken ergänzen sich hervorragend und sind unverzichtbar für jeden, der in der Welt der Datenanalyse tätig ist.

Unter https://raw.githubusercontent.com/alaub81/rpi_pico_scripts/main/config_sample.py gibt es eine Beispielkonfiguration für die Nutzung von MicroPython auf dem RaspberryPi Pico. Das könnte für Einsteiger sehr hilfreich sein, um schnell loszulegen und die ersten Schritte mit dem Pico zu machen.

https://raw.githubusercontent.com/alaub81/rpi_pico_scripts/main/wificonnection.py

Raspberry Pi OS download

https://www.raspberrypi.com/software/operating-systems/

ReLU - Rectified Linear Unit

relu <- function(x) {
  pmax(x, 0)
}

show_function(relu)

Leaky ReLU / Leaky Rectified Linear Unit

leakyrelu <- function(x, alpha=0.05) {
  pmax(x, alpha*x)
}

show_function(leakyrelu)

Tanh - Tangenz Hyperbolicus

tanh <- function(x) {
  p <- exp(x)
  n <- 1/p         # = exp(-x)
  (p-n)/(n+p)
}

show_function(tanh)

Sigmoid - Logistische Funktion

sigmonid <- function(x) {
  1/(1+exp(-x))
}

show_function(sigmonid)

Datentransformation und Linearisierung mit Exponentiation und Logarithmes

library(ggplot2)

# Beispiel in R: Log-Transformation einer schiefen Verteilung
set.seed(2009)
data = rexp(1000, rate = 0.1)  # Exponentielle Verteilung
df <- data.frame(x = data)

ggplot(aes(x = x), data = df) +
  geom_histogram(bins = 30, fill = "lightblue") +
  labs(title = "Original Data") +
  xlab("Value") +
  theme_minimal()

df_log <- data.frame(x = log(data))  # Log-Transformation

ggplot(aes(x = x), data = df_log) +
  geom_histogram(bins = 30, fill = "lightgreen") +
  labs(title = "Log-Transformed Data") +
  xlab("Log(Value)") +
  theme_minimal()

import numpy as np
import matplotlib.pyplot as plt

# Beispiel in Python: Log-Transformation einer schiefen Verteilung

np.random.seed(2009)

# Exponentielle Verteilung
data = np.random.exponential(scale=10, size=1000)
plt.hist(data, bins=30, color='lightblue', alpha=0.7)
plt.title('Original Data')
plt.xlabel('Value')
plt.show()

plt.clf()

log_data = np.log(data)  # Log-Transformation
plt.hist(log_data, bins=30, color='lightgreen', alpha=0.7)
plt.title('Log-Transformed Data')
plt.xlabel('Log(Value)')
plt.show()

plt.clf()

Beispiel 2 – Linearisierung mit Logarithmen

library(ggplot2)

# Beispiel in R: Linearisierung einer exponentiellen Beziehung
set.seed(2009)

x <- seq(1, 10, by = 0.1)
y <- 2 * exp(0.5 * x) + rnorm(length(x),
                 mean = 0, sd = 5)  # Exponentielle Beziehung mit Rauschen
df <- data.frame(x = x, y = y)
ggplot(aes(x = x, y = y), data = df) +
  geom_point(color = "blue") +
  labs(title = "Exponentielle Beziehung", x = "X", y = "Y") +
  theme_minimal()

log_y <- log(y)  # Log-Transformation von Y
df <- data.frame(x = x, y = log_y)
ggplot(aes(x = x, y = y), data = df) +
  geom_point(color = "red") +
  labs(title = "Linearisierte Beziehung", x = "X", y = "Log(Y)") +
  theme_minimal()

import numpy as np
import matplotlib.pyplot as plt

# Beispiel in Python: Linearisierung einer exponentiellen Beziehung
np.random.seed(2009)

x = np.arange(1, 10.1, 0.1)
y = 2 * np.exp(0.5 * x) + np.random.normal(
    0, 5, size=len(x) 
    )
plt.scatter(x, y, color='blue')
plt.title('Exponentielle Beziehung')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()

plt.clf()

log_y = np.log(y)  # Log-Transformation von Y

<string>:2: RuntimeWarning: invalid value encountered in log

plt.scatter(x, log_y, color='red')
plt.title('Linearisierte Beziehung')
plt.xlabel('X')
plt.ylabel('Log(Y)')
plt.show()

plt.clf()

Multiplikative Beziehungen

Logarithmen sind besonders nützlich, um multiplikative Beziehungen zwischen Variablen zu modellieren. Wenn die Beziehung zwischen zwei Variablen durch eine Multiplikation beschrieben wird, kann die Anwendung des Logarithmus diese Beziehung in eine additive Form überführen, was die Analyse und Interpretation erleichtert. Durch die Anwendung des Logarithmus auf beide Seiten der Gleichung erhalten wir: Diese Transformation ermöglicht es, die multiplikative Beziehung als lineare Kombination der logarithmierten Variablen darzustellen, was die Anwendung von linearen Regressionsmethoden erleichtert.

In der Statistik und Datenanalyse wird diese Technik häufig verwendet, um Modelle zu erstellen, die besser zu den Daten passen und leichter zu interpretieren sind.

Zum Beispiel bei der log-likelihood-Funktion in der Maximum-Likelihood-Schätzung oder bei der Analyse von Wachstumsprozessen, bei denen die Wachstumsraten oft als multiplikative Effekte modelliert werden.

Wenn Statisiker log-likelihood-Funktionen verwenden, dann u.a. aus diesen Gründen:

Monotonie: Logarithmen sind streng monoton wachsend, was bedeutet, dass die Maximierung der log-likelihood-Funktion äquivalent zur Maximierung der ursprünglichen likelihood-Funktion ist. Dies erleichtert die Optimierung erheblich.

Produkte wandeln sich zu Summen: Für unabhängige Beobachtungen gilt

welche mit dem Logarithmus zu

wird.

Dies vereinfacht die Berechnungen und reduziert numerische Instabilitäten, die bei der Arbeit mit sehr kleinen Wahrscheinlichkeiten auftreten können.

Anti-Symmetrie: Beim vergleich zweier Modelle und mit Likelihoods und ist der Log-Likelihood-Ratio

Das bedeutet, dass der Log-Likelihood-Ratio anti-symmetrisch ist, was bei der Interpretation von Modellen hilfreich sein kann.

So ist die Evidenz für Modell gegenüber Modell genau das negative der Evidenz für Modell gegenüber Modell .

library(ggplot2)

# Beispiel in R: Multiplikative Beziehung
set.seed(2009)
x1 <- runif(100, 1, 10)
x2 <- runif(100, 1, 10)
y <- 3 * x1^2 * x2^3 + rnorm(100
                 , mean = 0, sd = 10)  # Multiplikative Beziehung mit Rauschen
df <- data.frame(x1 = x1, x2 = x2, y = y)
ggplot(aes(x = x1, y = y), data = df) +
  geom_point(color = "blue") +
  labs(title = "Multiplikative Beziehung", 
           x = "X1", 
           y = "Y") +
  theme_minimal()

log_y <- log(y)  # Log-Transformation von Y
log_x1 <- log(x1)
log_x2 <- log(x2)
df_log <- data.frame(x1 = log_x1, x2 = log_x2, y = log_y)
ggplot(aes(x = x1, y = y), data = df_log) +
  geom_point(color = "red") +
  labs(title = "Additive Beziehung nach Log-Transformation", 
           x = "Log(X1)", 
           y = "Log(Y)") +
  theme_minimal()

import numpy as np
import matplotlib.pyplot as plt

np.random.seed(2009)
x1 = np.random.uniform(1, 10, 100)
x2 = np.random.uniform(1, 10, 100)

y = 3 * x1**2 * x2**3 + np.random.normal(
    0, 10, size=100)  # Multiplikative Beziehung mit Rauschen
    
plt.scatter(x1, y, color='blue')
plt.title('Multiplikative Beziehung')
plt.xlabel('X1')
plt.ylabel('Y')
plt.show()

plt.clf()
log_y = np.log(y)  # Log-Transformation von Y
log_x1 = np.log(x1)
log_x2 = np.log(x2)
plt.scatter(log_x1, log_y, color='red')
plt.title('Additive Beziehung nach Log-Transformation')
plt.xlabel('Log(X1)')
plt.ylabel('Log(Y)')
plt.show()

plt.clf()

Fazit

Exponentiation und Logarithmen sind mächtige Werkzeuge in der Statistik, die es ermöglichen, Daten zu transformieren, Beziehungen zu modellieren und komplexe Phänomene zu verstehen. Durch die Anwendung dieser mathematischen Konzepte können Statistiker und Datenwissenschaftler tiefere Einblicke in ihre Daten gewinnen und präzisere Modelle erstellen.

Was ist kitty?

Kitty ist ein moderner, GPU-basierter Terminal-Emulator, der auf Leistung und Benutzerfreundlichkeit ausgelegt ist. Es nutzt die Grafikprozessoren (GPUs) moderner Computer, um eine flüssige und schnelle Darstellung von Text und Grafiken zu gewährleisten. Dies macht kitty besonders geeignet für Entwickler, die viel Zeit im Terminal verbringen.

Installation

Die Installation von kitty ist einfach und kann auf verschiedenen Betriebssystemen durchgeführt werden. Hier sind die grundlegenden Schritte für die Installation auf Linux und macOS:

Linux/macOS: - Laden Sie das Installationsskript herunter und führen Sie es aus:

 curl -L https://sw.kovidgoyal.net/kitty/installer.sh | sh /dev/stdin

• Fügen Sie kitty zu Ihrem PATH hinzu, indem Sie die folgende Zeile zu Ihrer .bashrc oder .zshrc hinzufügen:

export PATH="$HOME/.local/kitty/bin:$PATH"

Hauptmerkmale von kitty

Kitty bietet eine Vielzahl von Funktionen, die es von anderen Terminal-Emulatoren abheben:

1. GPU-Beschleunigung: Durch die Nutzung der GPU für die Textdarstellung bietet kitty eine außergewöhnliche Leistung, insbesondere bei der Anzeige von großen Textmengen oder komplexen Grafiken.

2. Tabs und Fenster: Kitty unterstützt mehrere Tabs und Fenster, sodass Sie Ihre Arbeitsumgebung effizient organisieren können.

3. Grafikunterstützung: Kitty kann Bilder direkt im Terminal anzeigen, was es ideal für Entwickler macht, die mit Grafiken arbeiten.

4. Anpassbare Tastenkombinationen: Sie können Ihre eigenen Tastenkombinationen definieren, um Ihre Produktivität zu steigern.

5. Remote-Verbindungen: Kitty unterstützt SSH und andere Remote-Protokolle, sodass Sie nahtlos auf entfernte Systeme zugreifen können.

6. Leistungsstarke Konfiguration: Kitty bietet eine umfangreiche Konfigurationsdatei, mit der Sie das Verhalten und Aussehen des Terminals an Ihre Bedürfnisse anpassen können.

Warum kitty verwenden?

Es gibt mehrere Gründe, warum Sie kitty als Ihren bevorzugten Terminal-Emulator in Betracht ziehen sollten:

• Leistung: Die GPU-Beschleunigung sorgt für eine reibungslose und schnelle Benutzererfahrung.

• Funktionsreichtum: Mit einer Vielzahl von Funktionen und Anpassungsmöglichkeiten bietet kitty eine flexible Arbeitsumgebung.

• Aktive Entwicklung: Kitty wird aktiv weiterentwickelt, was bedeutet, dass Sie regelmäßig neue Funktionen und Verbesserungen erhalten.

• Open Source: Kitty ist Open Source, was bedeutet, dass Sie den Quellcode einsehen und anpassen können.

Fazit

Kitty ist ein leistungsstarker und funktionsreicher Terminal-Emulator, der sich durch seine GPU-Beschleunigung und Anpassungsfähigkeit auszeichnet. Egal, ob Sie ein Entwickler sind, der viel Zeit im Terminal verbringt, oder einfach nur einen schnellen und zuverlässigen Terminal-Emulator suchen, kitty ist definitiv eine Überlegung wert.

Link: Offizielle kitty-Website

Implementierungen im Vergleich

1. bintrees: Diese Bibliothek bietet eine einfache Implementierung von B-Bäumen und anderen Baumstrukturen. Sie ist leicht zu verwenden und gut dokumentiert, aber möglicherweise nicht die leistungsfähigste Option für große Datenmengen.
2. bplustree: Diese Bibliothek implementiert B+-Bäume, eine Variante von B-Bäumen, die für Datenbankanwendungen optimiert ist. Sie bietet gute Leistung und Skalierbarkeit, erfordert jedoch ein tieferes Verständnis der B+-Baum-Struktur.
3. pybloom-live: Obwohl hauptsächlich für Bloom-Filter gedacht, enthält diese Bibliothek auch eine B-Baum-Implementierung. Sie ist nützlich für Anwendungen, die sowohl Bäume als auch probabilistische Datenstrukturen benötigen.
4. btree: Diese Implementierung ist in der Standardbibliothek von Python enthalten und bietet grundlegende B-Baum-Funktionalitäten. Sie ist einfach zu verwenden, aber möglicherweise nicht so leistungsfähig wie spezialisierte Bibliotheken.

Leistungstest

Um die Leistung der verschiedenen Implementierungen zu vergleichen, habe ich einen einfachen Test durchgeführt, bei dem ich eine große Anzahl von Einfügungen und Suchvorgängen durchgeführt habe. Hier sind die Ergebnisse:

import time
from bintrees import FastRBTree
from bplustree import BPlusTree
# Testdaten
data = list(range(100000))
# bintrees Test
bintree = FastRBTree()
start_time = time.time()
for item in data:
    bintree.insert(item, item)
bintree_time = time.time() - start_time
# bplustree Test
bplustree = BPlusTree('bplustree.db', order=50)
start_time = time.time()
for item in data:
    bplustree.insert(item, item)
bplustree_time = time.time() - start_time
print(f"bintrees Einfügezeit: {bintree_time} Sekunden")
print(f"bplustree Einfügezeit: {bplustree_time} Sekunden")

Die Ergebnisse zeigten, dass bplustree bei großen Datenmengen eine bessere Leistung erzielte, insbesondere bei Suchvorgängen, während bintrees für kleinere Datensätze ausreichend war.

Fazit

Die Wahl der richtigen B-Baum-Implementierung hängt stark von den spezifischen Anforderungen Ihres Projekkts ab. Für einfache Anwendungen kann bintrees ausreichend sein, während bplustree besser für komplexe Datenbankanwendungen geeignet ist. Es lohnt sich, die verschiedenen Optionen zu testen, um die beste Leistung für Ihre spezifischen Anwendungsfälle zu erzielen. Unabhängig von der gewählten Implementierung bieten B-Bäume eine effiziente Möglichkeit, große Datenmengen zu verwalten und zu durchsuchen. Ich hoffe, dieser Vergleich hilft Ihnen bei der Auswahl der richtigen B-Baum-Implementierung für Ihre Python-Projekte! Happy Coding! 🚀

Die Frage

Wie sieht so eine Abbildung aus und vorallem wie lautet die Umkehrabbildung?

Eine mögliche Lösung

Wir können die Abbildung konstruieren, indem wir die 6 gezogenen Zahlen sortieren und dann eine lexikographische Ordnung verwenden, um jede Kombination zu nummerieren. Angenommen, die gezogenen Zahlen sind . Dann können wir die Abbildung wie folgt definieren:

Hierbei ist der Binomialkoeffizient, der die Anzahl der Möglichkeiten angibt, Elemente aus einer Menge von Elementen auszuwählen.

Diese Abbildung ist eindeutig, da jede Kombination von 6 Zahlen eine eindeutige Summe von Binomialkoeffizienten ergibt.

Die Umkehrabbildung kann durch eine iterative Methode konstruiert werden, bei der wir die größte Zahl bestimmen, die noch in die Summe passt, dann , und so weiter, bis wir alle 6 Zahlen gefunden haben.

Hier ist ein Beispiel für die Umkehrabbildung:

1. Setze .

2. Für von 6 bis 1:

   • Finde die größte Zahl such that .

   • Setze .

3. Gib die Zahlen zurück.

Diese Methode garantiert, dass wir die ursprünglichen gezogenen Zahlen zurückerhalten, da wir die gleiche Logik wie in der Vorwärtsabbildung verwenden, aber in umgekehrter Reihenfolge.

Fazit

Die Abbildung des Lotto-Problems zeigt, wie kombinatorische Konzepte verwendet werden können, um eindeutige Zuordnungen zwischen Mengen zu erstellen. Diese Art von Abbildungen ist nicht nur in der Mathematik interessant, sondern findet auch Anwendungen in Bereichen wie Kryptographie und Datenkompression.

Implementierung in R und Python

# R-Code zur Berechnung der Abbildung und Umkehrabbildung
library(gmp)

# Funktion zur Berechnung der Abbildung
lotto_abbildung <- function(a) {
  t <- sort(unique(a))
  if (length(t) != 6 || any(t < 1) || any(t > 49)) {
    stop("Eingabe muss 6 eindeutige Zahlen zwischen 1 und 49 sein.")
  }
  l <- sapply(1:6, function(i) chooseZ(a[i] - 1, i), 
              simplify = "array", USE.NAMES = FALSE)
  return(1+l[[1]] + l[[2]] + l[[3]] + l[[4]] + l[[5]] + l[[6]])
}

# Funktion zur Berechnung der Umkehrabbildung
lotto_umkehrabbildung <- function(n) {
  if (n < 1 || n > chooseZ(49, 6)) {
    stop("Eingabe muss zwischen 1 und 13.983.816 liegen.")
  }
  a <- integer(6)
  for (i in 6:1) {
    a[i] <- max(which(chooseZ(0:49, i) < n))
    n <- n - chooseZ(a[i] - 1, i)
  }
  return(a)
}

# Python-Code zur Berechnung der Abbildung und Umkehrabbildung
from math import comb

# Funktion zur Berechnung der Abbildung
def lotto_abbildung(a):
    a = sorted(set(a))
    if len(a) != 6 or any(x < 1 or x > 49 for x in a):
        raise ValueError("Eingabe muss 6 eindeutige Zahlen zwischen 1 und 49 sein.")
    l = [comb(a[i] - 1, i + 1) for i in range(6)]
    return 1+sum(l)

# Funktion zur Berechnung der Umkehrabbildung
def lotto_umkehrabbildung(n):
    if n < 1 or n > comb(49, 6):
        raise ValueError("Eingabe muss zwischen 0 und 13.983.816 liegen.")
    a = [0] * 6
    for i in range(5, -1, -1):
        tmp = max(k for k in range(50) if comb(k, i + 1) < n)
        a[i] = 1 + tmp
        n -= comb(tmp, i + 1)
    return a

Beispiel

gezogene_zahlen <- c(5, 12, 23, 34, 45, 49)
abbildung <- lotto_abbildung(gezogene_zahlen)
umkehrabbildung <- lotto_umkehrabbildung(abbildung)

gezogene_zahlen = [5, 12, 23, 34, 45, 49]
abbildung = lotto_abbildung(gezogene_zahlen)
umkehrabbildung = lotto_umkehrabbildung(abbildung)

Die Ausgabe zeigt die eindeutige Nummer der gezogenen Zahlen und die zurückgewonnenen Zahlen

# Ausgabe
abbildung  # Eindeutige Nummer

Big Integer ('bigz') :
[1] 13400040

umkehrabbildung  # Zurückgewonnene Zahlen

[1]  5 12 23 34 45 49

# Ausgabe
print(abbildung)  # Eindeutige Nummer

13400040

print(umkehrabbildung)  # Zurückgewonnene Zahlen

[5, 12, 23, 34, 45, 49]

Die Ausgabe zeigt die eindeutige Nummer der gezogenen Zahlen und die zurückgewonnenen Zahlen.

Die Frage bleibt, geht es auch ohne (extra) Scheifen bei der Suche nach dem nächsten in der Umkehrabbildung?

Referenzen

• Wikipedia: Lotto (Spiel)
• Wikipedia: Binomialkoeffizient
• Kombinatorik und Wahrscheinlichkeitsrechnung

Installation im Quarto-Projekt

Um sofort bei der Erstellung von Dokumenten, wie zum Beispiel diese Blog-Einträge, mit Quarto webp zu nutzen, installiert mensch einfach im Quarto-Projekt mittels:

> quarto add klausbrunner/convert-to-webp

Danach in der Datei _quarto.yml noch die folgenden Zeilen hinzufügen:

filters:
  - convert-to-webp

webp-delete-originals: false
webp-disable: false

Jetzt wird nach jedem ‘rendern’ eines Dokuments die erzeugten PNG-Dateien in WebP-Dateien übersetzt und im HTML-Code entsprechend ersetzt.

Schrit 1: Neues Betriebssystem installieren

Am besten mit dem Raspberry Pi Installer von hier: https://www.raspberrypi.com/software/

Für einen Raspberry Zero: Raspberry Pi OS (32-bit) Lite

Für einen Raspberry Zero 2 W: Raspberry Pi OS (64-bit) Lite

Wichtig MIT SSH konfigurieren!

Schrit 2: Ein Link zum Display

Auf dem RaspberryPI Zero ist ein Waveshare 2-13inch-e-Paper HAT installiert. Alles Wichtige dazu findet sich unter: https://www.waveshare.com/wiki/2.13inch_e-Paper_HAT_Manual#Working_With_Raspberry_Pi

Damit das Display richtig funktioniert sollte man in der config.txt die folgende Zeile anpassen:

dtparam=spi=on

Schritt 3: Den Raspberry Pi im Netz suchen und finden

Es gibt viele Weg die zum Ziel führen (können).

Zum Beispiel mit dem Befehl nmap:

> nmap -sn 192.168.2.0/24

Oder einfach den Hostnamen “raspberrpi.local” nutzen.

Man kann sich somit ggf. mittels ssh und dem folgenden Kommando anmelden:

> ssh norman@raspberrypi.local

Ebenso kann R PI Connect benutzt werden, wenn man es vorher eingerichtet hat.

Schritt 4: Startup-Display installieren

Ich habe bei GitHub ein kleines Programm geschrieben, welches die aktuelle IP Address (IP4 und IP6 sowie die aktuelle Uhrzeit) auf dem Display ausgibt.

Es ist unter https://github.com/NMarkgraf/pi-startup-display zu finden und wird einfach in das Hauptverzeichnis des Nutzers “norman” unter “/home/norman” per

> git clone https://github.com/NMarkgraf/pi-startup-display 

installiert.

Später kann dann im Verzeichnis pi-startup-display einfach das aktuelle Release von GutHUb durch den folgenden Befehl geladen werden:

> git pull

Damit dieses Skript nach jedem Neustart automatisch (einmal) gestartet wird bin ich nach dem Beispiel von https://webnist.de/automatisches-starten-eines-python-skripts-auf-dem-raspberry-pi-mit-systemd/ vorgegangen.

Aber ich habe die service Datei “/etc/systemd/system/startup-display.service” wie folgt angepasst:

[Unit]
Description=startup-display
After=network.target
 
[Service]
ExecStart=/usr/bin/python3 -u /home/norman/pi-startup-display/start-display.py 
WorkingDirectory=/home/norman/pi-startup-display/
#StandardOutput=inherit
StandardOutput=file:/tmp/start-display.log
#StandardError=inherit
StandardError=file:/tmp/start-display-error.log
#Restart=always
Restart=on-failture
RestartSec=60
User=norman
 
[Install]
WantedBy=multi-user.target

Zum anlegen habe ich den Editor “nano” genutzt und die Datei gleich mit angelegt.

> sudo nano /etc/systemd/system/startup-display.service

Die geänderte Datei muss nun initialisiert werden mit:

> sudo systemctl daemon-reload
> sudo systemctl enable startup-display.service

Dann können wir alles, zum Testen, von Hand starten:

> sudo systemctl start startup-display.service

Ob alles zu unserer Zufriedenheit funktioniert können wir mit der Status-Anzeige mit dem folgenden Befehl prüfen:

> sudo systemctl status startup-display.service

Und natürlich ggf. auch stoppen:

> sudo systemctl stop startup-display.service

PostgreSQL installieren

Ich gehe wie folgt vor:

> sudo apt install postgresql

> sudo su postgres

> curl -L -O https://github.com/lerocha/netflixdb/releases/download/v1.0.16/netflixdb-postgres.zip
> unzip netflixdb-postgres.zip

> sudo su postgres
> psql -d netflix
> \i /home/norman/netflixdb-postgres.sql

  ip:       ???? 
  port:     5342
  user:     postgres
  password: postgresdemo 
  dbname:   netflix

Beweis durch Einschüchterung

Trivial!

Beweis durch umständliche Notation

Der Satz folgt sofort aus dem Fakt

Beweis durch unzugreifbare Literatur

Der Satz ist ein einfaches Korrollat eines Ergebnis bewiesen in einer handgeschriebenen Anmerkung ausgehändigt in einer Vorlesung bei der Jugoslawischen Mathematischen Gesellschaft 1973.

Beweis durch geisterhafte Zitate

Der Beweis kann auf Seite 478 gefunden werden, in einem Buch, welches nur 396 Seiten hat.

Beweis durch circularer Argumentation

Proposition 5.18 in [BL] ist ein einfaches Korollar zm Satz 7.18 in [C], welches wiederum auf Korollar 2.14 in [K] basiert. Dieses wiederum wird unter Bezugnahme auf Proposition 5.18 in [BL] hergeleitet.

Beweis durch Autorität

Mein guter Kollege Andrew meinte, er glaube, er hätte dafür vor ein paar Jahren einen Beweis finden können …

Beweis durch Internet Referenz

Für Interessierte ist das Ergebnis auf der Webseite zu diesem Buch zu sehen. – Die es leider nicht mehr gibt.

Beweis durch Vermeidung

Kapitel 3: Der Beweis hierfür wird erst in Kapitel 7 erbracht, wenn wir die Theorie weiterentwickelt haben.

Kapitel 7: Der Einfachheit halber beweisen wir dies nur für den Fall z = 0. Der allgemeine Fall wird jedoch in Anhang C behandelt.

Anhang C: Der formale Beweis geht über den Rahmen dieses Buches hinaus, aber unsere Intuition sagt uns natürlich, dass dies wahr ist.

Beispiel 1: Erstellung einer Markdown-Tabelle

> mlr --icsv --fs semicolon --otsv cat tips.csv | \
  sed 's/,/./g' | mlr --itsv --omd cat

Mit diesem Befehl wird eine durch Semikolon getrennte CSV-Datei in eine durch Tabulator getrennte TSV-Datei umgewandelt, anschließend werden alle Kommata durch Punkte ersetzt und schließlich wird daraus eine Markdown-Tabelle erzeugt.

Beispiel 2: Gerahmte Darstellung

> mlr --icsv --fs semicolon --otsv cat tips.csv | \
  sed 's/,/./g' | mlr --itsv --opprint --barred cat

Mit diesem Befehl wird ebenfalls eine durch Semikolon getrennte CSV-Datei in eine durch Tabulator getrennte TSV-Datei umgewandelt, alle Kommata werden durch Punkte ersetzt und am Ende wird eine eingerahmte Tabelle erzeugt.