kleine Mathe-Spielereien

[OSWALD]

24.5.2025
Hier ein weiteres Beispiel mit zusätzlichen Informationen,
OSWALD

Code: Alles auswählen

#CONVOLUTION
import numpy as np
a = np.array([[1, 2, 0, 0],
              [5, 3, 0, 4],
              [0, 0, 0, 7],
              [9, 3, 0, 0]])
print(a)
print()

k = np.array([[1,1,1],[1,1,0],[1,0,0]])
print(k)


from scipy import ndimage
ndimage.convolve(a, k, mode='constant', cval=0.0)
#array([[11, 10,  7,  4],
#       [10,  3, 11, 11],
 #      [15, 12, 14,  7],
 #      [12,  3,  7,  0]])
#Die Einstellung cval=1.0entspricht dem Auffüllen des äußeren Rands der Eingabe mit 1,0
#(und dem anschließenden Extrahieren nur des ursprünglichen Bereichs des Ergebnisses).

ndimage.convolve(a, k, mode='constant', cval=1.0)
#array([[13, 11,  8,  7],
#       [11,  3, 11, 14],
 #      [16, 12, 14, 10],
 #      [15,  6, 10,  5]])
#Mit mode='reflect'(Standard) werden äußere Werte am Rand der Eingabe reflektiert ,
#um fehlende Werte zu ergänzen.

b = np.array([[2, 0, 0],
              [1, 0, 0],
              [0, 0, 0]])
k = np.array([[0,1,0], [0,1,0], [0,1,0]])
ndimage.convolve(b, k, mode='reflect')
#       [3, 0, 0],
#       [1, 0, 0]])
#Dies gilt auch für die Diagonalen an den Ecken.

k = np.array([[1,0,0],[0,1,0],[0,0,1]])
ndimage.convolve(b, k)
#       [3, 2, 0],
#       [1, 1, 0]])
#Mit wird mode='nearest'der einzelne, einer Kante in der Eingabe am nächsten liegende
#Wert so oft wiederholt, wie nötig, um die überlappenden Gewichte anzupassen .

c = np.array([[2, 0, 1],
              [1, 0, 0],
              [0, 0, 0]])
k = np.array([[0, 1, 0],
              [0, 1, 0],
              [0, 1, 0],
              [0, 1, 0],
              [0, 1, 0]])
ndimage.convolve(c, k, mode='nearest')
#array([[7, 0, 3],
      # [5, 0, 2],
     #  [3, 0, 1]])

[OSWALD]

24.5.2025
Ein weiteres Beispiel.
Mit geeigneter Technik und Torch
könnte man vielleicht schon versuchen,
einem Convolutional Neural Network (CNN)
etwas näher zu kommen.
Gute Zeit OSWALD

Code: Alles auswählen

 
import numpy as np
from scipy.signal import convolve
# 2D Arrays (Bild)
image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("      Bild-Matrix  = :",                  image)
print()
kernel = np.array([[0.1, 0.2, 0.1], [0.2, 0.4, 0.2], [0.1, 0.2, 0.1]])
print("      Kernel-Matrix   = :",kernel )    #       weil  mit zntralem Wert im Mittelpunkt der Matrix
print()
# Hier die   von Bild u.KernelFaltung
result = convolve(image, kernel, mode='full')
print(result)
print() 
#die Visualisierung  von result
import matplotlib.pyplot as plt
import numpy as np

matrix = [[0.5  ,1.  , 0.  , 0. ,  0.  ],
 [0.25, 0.5  ,1. ,  0. ,  0.  ],
 [0. ,  0.25, 0.5 , 1. ,  0.  ],
 [0.  , 0. ,  0.25, 0.5  ,1.  ],
 [0. ,  0.   ,0. ,  0.25, 0.5 ]]
leinwand, diagramm = plt.subplots()

# imshow()-Methode des Axes-Objekt anwenden, Matrix ist Input
diagramm.imshow(matrix)

# Diagramm anzeigen
plt.show()

[OSWALD]

25.5.2025
Hiermit schließe ich das Kapitel Bildverarbeitung'
mit dem Programm 'Gesichtserkennung ' ab.
Das Problem der Gesichtserkennung ließe sich durch das Training von Convolutional Neural Networks
deutlich effektiver lösen, doch diese Modellfamilie liegt außerhalb des Anwendungsbereichs der Scikit-Learn-Bibliothek.
Interessierte Leser sollten stattdessen versuchen, solche Modelle mit PyTorch oder TensorFlow zu implementieren.
Glücklich darf jedoch Jeder sein, der den Inhalt dieser 117 Zeilen halbwegs verstehen kann.
Das Programm zeigt auf jeden Fall , dass Python u.Co ein hervorragendes Leistungsniveau aufweisen.
Denn er ist dann auch in der Lage das gleiche Ergebnis oder gar mehr mit TensorFlow oder PyTorch zu erzielen,
die technischen Voraussetzungen stimmen.
Gute Zeit OSWALD

Code: Alles auswählen

GESICHTSBEHANDKUNG
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
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)

####################
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
#(behandelt als unbeschrifteter Datensatz): unüberwachte Merkmalsextraktion /
#Dimensionsreduktion

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))

#                  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_)
########################
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()

#Qualitative Auswertung der Vorhersagen mit matplotlib

def plot_gallery(images, titles, h, w, n_row=3, n_col=4):
    """Helper function to plot a gallery of portraits"""
    plt.figure(figsize=(1.8 * n_col, 2.4 * n_row))
    plt.subplots_adjust(bottom=0, left=0.01, right=0.99, top=0.90, hspace=0.35)
    for i in range(n_row * n_col):
        plt.subplot(n_row, n_col, i + 1)
        plt.imshow(images[i].reshape((h, w)), cmap=plt.cm.gray)
        plt.title(titles[i], size=12)
        plt.xticks(())
        plt.yticks(())
#Plotten Sie das Ergebnis der Vorhersage auf einem Teil des Testsatzes

def title(y_pred, y_test, target_names, i):
    pred_name = target_names[y_pred[i]].rsplit(" ", 1)[-1]
    true_name = target_names[y_test[i]].rsplit(" ", 1)[-1]
    return "predicted: %s\ntrue:      %s" % (pred_name, true_name)


prediction_titles = [
    title(y_pred, y_test, target_names, i) for i in range(y_pred.shape[0])
]

plot_gallery(X_test, prediction_titles, h, w)

#Zeichnen Sie die Galerie der signifikantesten Eigengesichter

eigenface_titles = ["eigenface %d" % i for i in range(eigenfaces.shape[0])]
plot_gallery(eigenfaces, eigenface_titles, h, w)

plt.show()

[OSWALD]

30.5.2025
Nach wie vor sind Daten im Zentrum der Informatik,
Reduktion der Daten-Dimension zu Dimension 1
Die Hauptkomponentenanalyse (PCA)

ist eine unbeaufsichtigte maschinelle Lerntechnik ,
die Hauptkomponenten (lineare Kombinationen der Prädiktorvariablen) findet,
die einen großen Teil der Variation in einem Datensatz erklären.
Wenn wir eine PCA durchführen, möchten wir wissen,
welcher Prozentsatz der Gesamtvariation im Datensatz
durch jede Hauptkomponente erklärt werden kann.
Ich möchte mich jetzt in dieses umfangreiche und nicht einfache Gebiet einarbeiten.
Es ist sehr erklärungsbedürftig, also zuerst ein einfaches Beispiel.
Die zahlreichen notwenigen Module habe ich mit dem Anaconda - Prompt geladen.
Gute Zeit OSWALD

Code: Alles auswählen

#                                Hauptkomponenten-Analyse
import pandas as pd
from sklearn.preprocessing import StandardScaler

#URL, wo sich der Datensatz befindet definieren
url = "https://raw.githubusercontent.com/JWarmenhoven/ISLR-python/master/Notebooks/Data/USArrests.csv"

#Daten einlesen
data = pd.read_csv(url)
print("Hier ist der Datensatz einer  'Kriminal-Statistik'  : ",)
print(data)
#Spalten zur Verwendung für PCA definieren
df = data.iloc[:, 1:5]

#Scaler definieren
scaler = StandardScaler()

#Kopie des DataFrames erstellen
scaled_df=df.copy()

#skalierte Version des DataFrames
scaled_df=pd.DataFrame(scaler.fit_transform(scaled_df), columns=scaled_df.columns)
from sklearn.decomposition import PCA

#zu verwendendes PCA-Modell definieren
pca = PCA(n_components=4)

# PCA-Modell an Daten anpassen
pca_fit = pca.fit(scaled_df)
#Schritt 3: Erstellen Sie den Screeplot
#Zuletzt berechnen wir den Prozentsatz der Gesamtvarianz, der durch jede Hauptkomponente erklärt wird,
#und verwenden matplotlib, um ein Screeplot zu erstellen:

import matplotlib.pyplot as plt
import numpy as np

PC_values = np.arange(pca.n_components_) + 1
plt.plot(PC_values, pca.explained_variance_ratio_, 'o-', linewidth=2, color='blue')
plt.title('Scree Plot :   Erklärung siehe Wikipedia')
plt.xlabel(' PCA Principal Component Analysis')
plt.ylabel('Varianz der Hauptkomonenten')
plt.show()
#Screeplot in Python

#Die x-Achse zeigt die Hauptkomponente und die y-Achse den Prozentsatz der Gesamtvarianz, der durch jede einzelne Hauptkomponente erklärt wird.

#Wir können auch den folgenden Code verwenden, um den genauen Prozentsatz der Gesamtvarianz anzuzeigen, der durch jede Hauptkomponente erklärt wird:


print(pca.explained_variance_ratio_)

#[0.62006039 0.24744129 0.0891408  0.04335752]
print("Die erste Hauptkomponente  :  62,01 % der Gesamtvariation im Datensatz.")
print("Die zweite Hauptkomponente : 24,74 %  ")
print("Die dritte Hauptkomponente   : 8,91 %  .")
print ("Die vierte Hauptkomponente  : 4,34 %  .")
print("Die Summe der Prozentsätze  ergibt  100%.")

[OSWALD]

31.5.2025
Hier ein weiteres Programm zur Illustrierung
der Zusammenhänge inn der PCA
Gute Zeit OSWALD

Code: Alles auswählen

[

mport numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
import seaborn as sns

iris = load_iris()
X = iris.data
print("                         X-Achse(Datensatz)  : ",X)
y = iris.target
print("                         y-Achse                     : ",y)
feature_names = iris.feature_names

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
#Schritt 2: PCA anwenden
#In diesem Schritt wird die Hauptkomponentenanalyse (PCA) angewendet,
#um die Dimensionalität des Datensatzes von 4 auf 2 Merkmale zu reduzieren
#und gleichzeitig so viele wichtige Informationen (Varianzen) wie möglich
#aus dem ursprünglichen Datensatz zu erhalten.

#fit() : Die Methode fit() berechnet die Hauptkomponenten, indem sie die Richtungen (Achsen) ermittelt, in denen die Varianz maximal ist.
#transform() : Sobald die Komponenten gefunden sind, projiziert die transform()-Methode die Originaldaten auf die neuen Hauptkomponenten. Dadurch wird der Datensatz von 4 auf 2 Dimensionen reduziert.
#Der transformierte Datensatz wird in der Variable X_pca gespeichert . Er enthält nur zwei statt vier Merkmale (PC1 und PC2), was den Datensatz vereinfacht, ohne dass viele Informationen verloren gehen.

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
print(X_pca)
print("Shape of Original Dataset:", X_scaled.shape)
print("Shape after PCA:", X_pca.shape)
#Schritt 3: Feature-Ladungen berechnen und visualisieren
#n diesem Schritt werden die Merkmalsladungen berechnet und visualisiert, um zu verstehen, wie viel jedes ursprüngliche Merkmal zu den Hauptkomponenten beiträgt.

#Ladungen: Matrix zur Visualisierung

#annot=true:            #Zeigt die Zahlen in jeder Zelle an
cmap='coolwarm'  
#    Legt die Farbkarte fest, d. h. Rot für hohe Wichtigkeit und Blau für niedrige Wichtigkeit
#xticklabels =['PC1' , 'PC2']
#print(xticklabels)
#: Beschriftungen für die x-Achse (Hauptkomponenten)
#yticklabels-feature_names
#: Beschriftungen für die Y-Achse (Originalfunktionen)

loadings = pca.components_.T * np.sqrt(pca.explained_variance_)
print("Gewichtung der Variable in einer Hauptkomponente ")
print(loadings)

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 8))
sns.heatmap(loadings, annot=True, cmap='coolwarm', xticklabels=['PC1', 'PC2'], yticklabels=feature_names)
plt.title('Feature Importance in Principal Components')
plt.show()
 

#Schritt 4: Biplot-Visualisierung
#Nach dem Laden der Merkmale erstellen wir ein Biplot, um beides visuell darzustellen:

#Der reduzierte Datensatz nach Anwendung der PCA.
#Die Richtung und Bedeutung ursprünglicher Merkmale im neuen Hauptkomponentenraum.

def biplot(score, coeff, labels=None):
    xs = score[:, 0]
    ys = score[:, 1]
    plt.figure(figsize=(10, 8))
    plt.scatter(xs, ys, c=y, cmap='viridis')

    for i in range(len(coeff)):
        plt.arrow(0, 0, coeff[i, 0], coeff[i, 1], color='r', alpha=0.5)
        plt.text(coeff[i, 0] * 1.2, coeff[i, 1] * 1.2, labels[i], color='g')

    plt.xlabel("PC1")
    plt.ylabel("PC2")
    plt.title('''Biplot: Beziehungen zwischen Variablen und Beobachtungen zeigen''')
    plt.show()

biplot(X_pca, pca.components_.T, feature_names)


/code]