kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

17.6.2024
Es hat lange gedauert, bis ich sicher war, diese
Thematik in etwa verstanden zu haben.
Insgesamt ist dieses Thema sehr um fangreich und kompliziert.
Für mich als Anfänger nur ein Scgnupperkurs.
Hier eine Darsllung der confusion matrix
als Ereignisbaum.
OSWALD

Code: Alles auswählen



from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

#Laden des Iris-Datensatzes
iris = load_iris()
X = iris.data 

y = iris.target

#Aufteilung der Daten in Trainings- und Testsets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=1)

#Erstellen des Entscheidungsbaum-Klassifikators
clf = DecisionTreeClassifier(criterion='gini', max_depth=None, random_state=1)

#Trainieren des Modells
clf.fit(X_train, y_train)

#Vorhersagen auf dem Testset
y_pred = clf.predict(X_test)

#Bewertung der Modellleistung
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

#Ausgabe der Confusion Matrix und des Klassifikationsberichts
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))
print("Classification Report:")
print(classification_report(y_test, y_pred))

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree

# Visualisierung des Entscheidungsbaums
plt.figure(figsize=(15, 10))
plot_tree(clf, feature_names=iris.feature_names, class_names=iris.target_names, filled=True, rounded=True)
plt.show()

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

19.6.2024
Abschliessend zum Thema noch ein Beispiel , bei dem ich
" etwas hinter die Kulissen geschaut" habe.
Insgesamt ist diese Thematik sehr kompliziert.
Gute Zeit OSWALD

Code: Alles auswählen


rom sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
import matplotlib.pyplot as plt

#       breast cancer Datenatz  laden
bc = datasets.load_breast_cancer()
print()
print("      Das ist der 'breast_cancer' Datensatz")
print(bc)
X = bc.data
y = bc.target
print(bc.target)
#
#      Trainieren #
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=1, stratify=y)
#0.3
#      Pipeline trainieren  
#
pipeline = make_pipeline(StandardScaler(),
RandomForestClassifier(n_estimators=10, max_features=5, max_depth=2, random_state=1))
 
#    Pipeline - Schätzer     fitten
pipeline.fit(X_train, y_train)
  
from sklearn.metrics import confusion_matrix
#
#      Vorhersagen
#
y_pred = pipeline.predict(X_test)

#  Confusion Matrix berechnen
conf_matrix = confusion_matrix(y_true=y_test, y_pred=y_pred)
# Visualisierung mit Matplotlib
#
fig, ax = plt.subplots(figsize=(7.5, 7.5))
ax.matshow(conf_matrix, cmap=plt.cm.Reds, alpha=0.4)  # matshow(() : Anzeige des Arrays  als  C-Matrix 2D . Farben

print("aktualierte Confusions-Matrix   : "  ,conf_matrix)       #      Aktualisierte    2D -  Confusions-Matrix  

for i in range(conf_matrix.shape[0]):
    for j in range(conf_matrix.shape[1]):
        ax.text(x=j, y=i,s=conf_matrix[i, j], va='center', ha='center', size='xx-large')

plt.xlabel('  Vorhersage      ', fontsize=18)
plt.ylabel('  Aktuell             '  , fontsize=18)
plt.title('Confusion Matrix',fontsize = 18)
plt.show()

#Extract the true positive, true negative, false positive, and false negative values from the confusion matrix
tn, fp, fn, tp = conf_matrix.ravel()
 
# Print the true positive, true negative, false positive, and false negative values
print("True Positive (TP): ", tp)
print("True Negative (TN): ", tn)
print("False Positive (FP): ", fp)
print("False Negative (FN): ", fn)
 
# Calculate accuracy
accuracy = (tp + tn) / (tp + tn + fp + fn)
 
# Calculate precision
precision = tp / (tp + fp)
 
# Calculate recall
recall = tp / (tp + fn)
 
# Calculate F1-score
f1_score = 2 * (precision * recall) / (precision + recall)
 
# Print the formulas for accuracy, precision, recall, and F1-score
print("\n\nFormulas:")
print("Accuracy: (TP + TN) / (TP + TN + FP + FN)")
print("Precision: TP / (TP + FP)")
print("Recall: TP / (TP + FN)")
print("F1-score: 2 * (Precision * Recall) / (Precision + Recall)")
 
# Print the accuracy, precision, recall, and F1-score
print("\n\nMetrics:")
print("Genauigkeit: ", round(accuracy, 2))
print("Präcision: ", round(precision, 2))    #   tatsächlich erkrankte Patienten
print("Recall: ", round(recall, 2))               #   alle als krank erkannte  ""
print("F1-score: ", round(f1_score, 2))     #   harmon.-Mittel aus Präcision und recall

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

20.6.2024
Die Confusion Matrix findet oft Anwendung
zur Qualitätskontrolle in machine learn. z.B.
in der Gesichtserkennung.
Inndem komplizierten Code finden sich die bekannten
Funktionen(trainieren,testen,optimieren,klassifizieren, normslisieren) usw.
Die einfache 2D Matrix reicht aber dafür nicht mehr aus, wie das Beispiel
zeigt. Gute Zeit OSWALD

Code: Alles auswählen

from time import time
import matplotlib.pyplot as plt
from scipy.stats import loguniform

from sklearn.datasets import fetch_lfw_people
from sklearn.decomposition import PCA
from sklearn.metrics import ConfusionMatrixDisplay, classification_report
from sklearn.model_selection import RandomizedSearchCV, train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
#Laden Sie die Daten herunter, falls sie nicht bereits auf der Festplatte sind,
#und laden Sie sie als Numpy-Arrays

lfw_people = fetch_lfw_people(min_faces_per_person=70, resize=0.4)

# introspect the images arrays to find the shapes (for plotting)
n_samples, h, w = lfw_people.images.shape

# for machine learning we use the 2 data directly (as relative pixel
# positions info is ignored by this model)
X = lfw_people.data
n_features = X.shape[1]

# the label to predict is the id of the person
y = lfw_people.target
target_names = lfw_people.target_names
n_classes = target_names.shape[0]

print("Total dataset size:")
print("n_samples: %d" % n_samples)
print("n_features: %d" % n_features)
print("n_classes: %d" % n_classes)
#Total dataset size:
n_samples: 1288
n_features: 1850
n_classes: 7
#Teilen Sie es in einen Trainingssatz und einen Test auf #
#und behalten Sie 25 % der Daten zum Testen.

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
#Berechnen Sie eine PCA (Eigengesichter) auf dem Gesichtsdatensatz (der als unbeschrifteter Datensatz behandelt wird): unüberwachte Merkmalsextraktion / Dimensionsreduzierung

n_components = 150

print(
    "Extracting the top %d eigenfaces from %d faces" % (n_components, X_train.shape[0])
)
t0 = time()
pca = PCA(n_components=n_components, svd_solver="randomized", whiten=True).fit(X_train)
print("done in %0.3fs" % (time() - t0))

eigenfaces = pca.components_.reshape((n_components, h, w))

print("Projecting the input data on the eigenfaces orthonormal basis")
t0 = time()
X_train_pca = pca.transform(X_train)
X_test_pca = pca.transform(X_test)
print("done in %0.3fs" % (time() - t0))
#Extracting the top 150 eigenfaces from 966 faces
#done in 0.089s
#Projecting the input data on the eigenfaces orthonormal basis
#done in 0.006s
#Trainieren eines SVM-Klassifizierungsmodells

print("Fitting the classifier to the training set")
t0 = time()
param_grid = {
    "C": loguniform(1e3, 1e5),
    "gamma": loguniform(1e-4, 1e-1),
}
clf = RandomizedSearchCV(
    SVC(kernel="rbf", class_weight="balanced"), param_grid, n_iter=10
)
clf = clf.fit(X_train_pca, y_train)
print("done in %0.3fs" % (time() - t0))
print("Best estimator found by grid search:")
print(clf.best_estimator_)
#Fitting the classifier to the training set
#done in 5.388s
#Best estimator found by grid search:
SVC(C=76823.03433306456, class_weight='balanced', gamma=0.0034189458230957995)
#Quantitative Bewertung der Modellqualität am Testset

print("Predicting people's names on the test set")
t0 = time()
y_pred = clf.predict(X_test_pca)
print("done in %0.3fs" % (time() - t0))

print(classification_report(y_test, y_pred, target_names=target_names))
ConfusionMatrixDisplay.from_estimator(
    clf, X_test_pca, y_test, display_labels=target_names, xticks_rotation="vertical"
)
plt.tight_layout()
plt.show()

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

21.6.2024
Wenn ich ein Thema wirklich verstehen will,
muss ich mich mit vielen unterschiedlichen Aspekten
vertraut machen. Deshalb ein weiteres Bespiel aus der
sehr umfanreichen Materie. OSWALD

Code: Alles auswählen


###        Grafische Darstellung der Leistungsfähigkeit eines binären Klassifizierungsmodels.
###        für alle Klassifizierungs-Schwellenwerte  (treshold)

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
import matplotlib.pyplot as plt


#   Logistisches        Regressionsmodell anpassen

url = "https://raw.githubusercontent.com/Statology/Python-Guides/main/default.csv"
data = pd.read_csv(url)
print("Hier die vorliegenden   Daten  anschauen ; ")
print( data)
#    Prädiktorvariablen und die Antwortvariable  voreinstellen
X = data[['student', 'balance', 'income']]  
y = data[['default']]

#     Datensatz in Trainings- (70 %) und Testsätze (30 %) aufteilen
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.5,random_state=0) 

#     Modell  instanziieren
log_regression =      LogisticRegression()

#     Modell mithilfe der Trainingsdaten an
log_regression.fit(X_train,y_train)

#   : Zeichnen Sie die ROC-Kurve
#      TP  Richtig-Positiv-Rate und
#       FP Falsch-Positiv-Rate und erstellen eine ROC-Kurve
#       Metriken definieren
y_pred_proba = log_regression.predict_proba(X_test)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred_proba)
print()
print(fpr)
print()
print(tpr)

#        ROC-Kurve erstellen
plt.plot(fpr,tpr)
plt.ylabel(' TP  True  Positiver Anteil')
plt.xlabel(' FP  False Positiver Anteil')
plt.title("ROC -Kurve  (=Grenzwertoptimierungskurve)")
plt.show()

#  Berechnen der AUC 
#    Je näher AUC    (von 0.5 >  1)   an 1 liegt, desto besser ist das Modell.
     
 
y_pred_proba = log_regression.predict_proba(X_test)[::,1]
fpr, tpr, _ = metrics.roc_curve(y_test,  y_pred_proba)
auc = metrics.roc_auc_score(y_test, y_pred_proba)

#       ROC-Kurve erstellen
plt.plot(fpr,tpr,label="         AUC   Fläche unter der Kurve="+str(auc))
plt.ylabel(' TP  True Positive Anteil')
plt.xlabel('  FP False Positive Anteil')
plt.legend(loc=6)
           
plt.title("ROC-Kurve  = [Receiver Operating Characteristic].")
plt.show()


OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

11.7.2024
In den letzten Wochen habe ich mich intensiv
mit folgendem Themenkreis befasst:
Scipy. Numpy,
Matrizen, inversen Matrizen, Determinanten
Matrizenrechnung, Lösung von Gleichungen
etwas Algebra , insgesamt ein riesiges Pensum.
Für alles was ich verstanden habe , versuche ich Beispiele
zu bringen. Mal sehen.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

11.7.2024
Zur Bearbeitung von Matrizen stellt Python zwei Bibliotheken
Verfügung: scipy und numpy
scipy.linalg enthält alle Funktionen die auch in numpy.linalg enthalten sind ,
sowie einige andere, erweiterte Funktionen, die nicht in numpy.linalg. enthalten sind .
Es gibt also zwei Klassen : scipy.linalg und numpy.linalg ,

Mit deren Anwendung aber hat man die schwierige und sehr umfangreiche Thematik noch
lange nicht verstanden. Ein erstes kleines Programm soll das zeigen.
OSWALD

Code: Alles auswählen

 

import numpy as np
print("Das ist eine  quadratische Matrix   ") 
  
a = np.array([[1, 2], [0, 4]])
print(a)
print("Berechnung der Determinanten :   a*d - b*c ") 
np.linalg.det(a)
print(np.linalg.det(a))

a = np.array([[1, 2], [0, 4]])
print(a)
print("Berechnung der Determinanten :   a*d - b*c ") 
np.linalg.det(a)
print(np.linalg.det(a))


print("Das ist  ein Stapel  von Matrizen   ") 
b = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])

print("mit drei Determinanten",np.linalg.det(b))
print("shape :"   ,b.shape)

 
OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

12.7.2024
Hier zeige ich die beiden Matrix-Klassen
an Beispielen
Oswald

# Unterschied np.ARRAY und np.MATRIX
# NumPy-Matrizen simd streng 2-dimensional
# NumPy-Arrays arrays v sind n-dimensional.



# X und Y zwei np.Matrizen , dann X * Y = Matrixmultiplikation.
# X und Y zwei np.ARRAYS , dann X * Y = Komponentenweise Multiplikation.


import numpy as np

x = np.array( ((2,3), (3, 5)) )
y = np.array( ((1,2), (5, -1)) )
x * y
print(x*y)

print()

x = np.matrix( ((2,3), (3, 5)) )
y = np.matrix( ((1,2), (5, -1)) )
print(x * y)
OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

12..7.2024
So kann man eine Matrix invertieren
anschließend der Test.
Alle Beispiele zunächst zur ersten Orientierung
Oswald

Code: Alles auswählen

import numpy as np

a = np.array([[1, 2, 3], [1, 3, 3], [1, 2, 4]])
print("Original-Matrix    :",a)
ainv = np.linalg.inv(a)
print("Matrix invertiert  :"  ,ainv)
print()
print(ainv)
print() 
print("überprüft",np.allclose(np.dot(ainv, a), np.eye(3)))

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

12.7.2024
Die Multiplikation von Matrizen ist eine sehr wichtige Methode
beim Rechnen mit Matrizen, z.B. beim Lösen von Gleichungen etc
OSWALD

Code: Alles auswählen


######	Multiplikation von 3*4 und 4*3 Matritzen

import numpy as np
A = np.array([[11, 12, 13, 14], 
                      [21, 22, 23, 24], 
                      [31, 32, 33, 34]])
print(A)


B = np.array([[5, 4, 2], 
                      [1, 0, 2], 
                      [3, 8, 2], 
                      [24, 12, 57]])

print(np.dot(A ,B))
#[[ 442  316  870]
# [ 772  556 1500]
# [1102  796 2130]]
#   N E U: Jetzt gibt es für das dot-Produkt auch einen    Infix-Operator, und zwar @:

print(A @ B) 
#[[ 442  316  870]
# [ 772  556 1500]
 #[1102  796 2130]]
#   Damit die Matrizenmultiplikation (also dot)
#   für zwei Matrizen A und B im zweidimensionalen Fall funktionieren kann, muss gelten:

A.shape[-1] == B.shape[-2]

# zur Kontrolle 
print(A.shape[-1] == B.shape[-2]) 
True

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

12.7.2024
Die Normalisierung von Daten für Matrizen ist unerlässlich
für Berechnungen mit Matrizen und darüber hinaus.
Oswald

Code: Alles auswählen


#                      Matrix normalisieren mit  sklearn und / oder   numpy    

from sklearn.preprocessing import normalize
import numpy 

matrix = numpy.arange(0,27,3).reshape(3,3).astype(numpy.float64)
normed_matrix = normalize(matrix, axis=1, norm='l1')
print("Matrix original  :",matrix)
print()
print("Matrix normalisiert :",normed_matrix)
print()
#########################

print("Matrix normalisieren mit   numpy")
import numpy as np
 
def normalize_2d(matrix):
    # Only this is changed to use 2-norm put 2 instead of 1
    norm = np.linalg.norm(matrix, 1)
    # normalized matrix
    matrix = matrix/norm  
    return matrix
 
# gives and array starting from -2 and ending at 13
array = np.arange(16) - 2 
# converts 1d array to a matrix
matrix = array.reshape(4, 4)  
print("Original  Matrix \n", matrix)
normalized_matrix = normalize_2d(matrix)
print("Normalisierte  Matrix ", normalized_matrix)

OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

12.7.2024
Im folgenden Beispiel
habe ich zunächst eine 3x3 Matrix erstellt.
von dieser die Determinante bestimmt, dann die
matrix invertiert und dann wiederum davon auch die
Determinante bestimmt.
Beim Versuch , drei unbekannte Variablen in einem
lLGS mit numpy.linalg zu errechnen gescheitert.
mit inverser Matrix ist das sehr gut möglich,
hier aber nicht darstellbar.
Mit sympy ginge es wohl auch
.Oswald
OSWALD
User
Beiträge: 396
Registriert: Freitag 18. März 2022, 17:32

es ging irgendwie verloren
OSWALD

Code: Alles auswählen


import numpy as np
from scipy import linalg
A = np.array([[1,3,5],[2,5,1],[2,3,8]])
print(A)
print(np.linalg.det(A)) 
B =np. linalg.inv(A)

print("Inverse Matrix   :" ,np. linalg.inv(B))
print()
print("Determinante   "  ,np.linalg.det(B))           
print(np.linalg.det(B)) 









Antworten