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]

[OSWALD]

6.6.2025
Heute aus dem Bereich der Physik.
Dipolares Nagnetfeld der Erde. Abweichung des Magnet-Pols von der Erdachse.
Gute Zeit OSWALD

Code: Alles auswählen

#                Dipolares ErdMagnetFeld mit 

import sys
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Circle

# define some constants:
B0 = 3.12e-5 # Mean magnitude of the Earth's magnetic field at the equator in T:
RE = 6.370  # Radius of Earth, Mm (10^6 m: mega-metres!)
alpha = np.radians(9.6) # Deviation of magnetic pole from axis

# define the magnetic field vector B(r, theta) in polar coordinates:
def B(r, theta):
    """Return the magnetic field vector at (r, theta)."""
    fac = B0 * (RE / r)**3
    return -2 * fac * np.cos(theta + alpha), -fac * np.sin(theta + alpha)

# grid of x, y points on a Cartesian grid:
nx, ny = 64, 64
XMAX, YMAX = 40, 40
x = np.linspace(-XMAX, XMAX, nx)
y = np.linspace(-YMAX, YMAX, ny)
X, Y = np.meshgrid(x, y)
r, theta = np.hypot(X, Y), np.arctan2(Y, X)

# magnetic field vector, B = (Ex, Ey), as separate components:
Br, Btheta = B(r, theta)

# transform to Cartesian coordinates:
c, s = np.cos(np.pi/2 + theta), np.sin(np.pi/2 + theta)
Bx = -Btheta * s + Br * c
By = Btheta * c + Br * s


# plot:
fig, ax = plt.subplots(figsize=(8, 8))
ax.streamplot(x, y, Bx, By, color="aqua", linewidth=1, cmap=plt.cm.binary,
              density=2, arrowstyle='->', arrowsize=1.5)
ax.add_patch(Circle((1, 1), RE, color='darkgray', zorder=100))      
ax.set_facecolor('green')
# Add Earth's geographic and magnetic pole axis (straight vertical)
ax.plot([0, 0], [-YMAX, YMAX], '-', c="pink",linewidth=3)
x_magnetic = np.array([-YMAX, YMAX])
y_magnetic = x_magnetic * np.tan(np.pi/2-alpha )
ax.plot(x_magnetic, y_magnetic, 'b-', linewidth=3)
ax.set_xlabel('$x$ in 10$^6$ m')
ax.set_ylabel('$y$ in 10$^6$ m')
ax.set_xlim(-XMAX, XMAX)
ax.set_ylim(-YMAX, YMAX)
ax.set_aspect('equal')
plt.tight_layout()

plt.savefig('earths_magnetic_field.png', dpi=300)
plt.title("Bipolares Erd-Magnetfeld(Abweichung  Magnetpol von Erdachse (blau)")
plt.show()

[OSWALD]

6.6.2025
(igrendwo hakt's) Neuer Vewrsuch
hefragt sind heute Python und ein wenig 'Physik'.
Gute Zeit OSWALD[

code]
Elektrisches Feld
import numpy as np
import matplotlib.pyplot as plt
Q = [(-1,1, 1.5)] # Ladung
#Q = [(3,1, 5)]

x1, y1 = -5, -5
x2, y2 = 5, 5
lres = 20
m, n = lres * (y2-y1), lres * (x2-x1)


x, y = np.linspace(x1,x2,n), np.linspace(y1,y2,m)
x, y = np.meshgrid(x,y)
Ex = np.zeros((m,n))
Ey = np.zeros((m,n))

k = 9 * 10**9
for j in range(m):
for i in range(n):
xp, yp = x[j], y[j]
for q in Q:
deltaX = xp - q[0]
deltaY = yp - q[1]

distance = (deltaX**2 + deltaY**2)**0.5

E = (k*q[2])/(distance**2)
Ex[j] += E*(deltaX/distance)
Ey[j] += E*(deltaY/distance)

fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.scatter([q[0] for q in Q], [q[1] for q in Q], c = 'red', s = [abs(q[1])*50 for q in Q], zorder = 1)
for q in Q:
ax.text(q[1]+0.1, q[1]-0.3, '{} unit'.format(q[2]), color = 'black', zorder = 2)
ax.streamplot(x,y,Ex,Ey, linewidth = 0.5, density = 1.5, zorder = 0)

plt.title('Electrostatic Field Simulation')

plt.show()


[/code]

[OSWALD]

7.6.2025
Jetzt hnbe ich eine negative Ladung in das Feld
eingesetzt
Die Feldlinien ' stürzen ' in umgekehrter
Richtung
OSWAL

Code: Alles auswählen

#                                    Elektrisches Feld
import numpy as np
import matplotlib.pyplot as plt
#Q = [(-1,1, -1.5)]                         # Ladung   jetzt negativ 
Q = [(3,1, -5)]

x1, y1 = -5, -5  
x2, y2 = 5, 5   
lres = 100

m, n = lres * (y2-y1), lres * (x2-x1)


x, y = np.linspace(x1,x2,n), np.linspace(y1,y2,m)
x, y = np.meshgrid(x,y)
Ex = np.zeros((m,n)) 
Ey = np.zeros((m,n)) 

k = 9 * 10**9 
for j in range(m):
    for i in range(n):
        xp, yp = x[j][i], y[j][i]
        for q in Q:
            deltaX = xp - q[0]
            deltaY = yp - q[1] 

            distance = (deltaX**2 + deltaY**2)**0.5  

            E = (k*q[2])/(distance**2)     
            Ex[j][i] += E*(deltaX/distance)
            Ey[j][i] += E*(deltaY/distance) 
            
fig, ax = plt.subplots()
ax.set_aspect('equal')
ax.scatter([q[0] for q in Q], [q[1] for q in Q], c = 'blue', s = [abs(q[1])*50 for q in Q], zorder = 1)
for q in Q:
    ax.text(q[1]+0.1, q[1]-0.3, '{} unit'.format(q[2]), color = 'black', zorder = 2)
    ax.streamplot(x,y,Ex,Ey, linewidth = 0.5, density = 1.5, zorder = 0)

plt.title('Electrostatic Field Simulation')
 
plt.show()

[OSWALD]

9.6.2025
Die PyOD Version 2 ist jetzt verfügbar ( Papier ) [ ACQS+24 ] und enthält:
Erweiterte Deep-Learning-Unterstützung : Integriert 12 moderne neuronale Modelle in ein einziges PyTorch-basiertes Framework, wodurch sich die Gesamtzahl der Methoden zur Ausreißererkennung auf 45 erhöht.
Ich habe ein Programm gefunden, in dem diese Bibliothek und auch PCA eingesetzt wird,
Hinzu finde ich zahlreiche neue Begriffe, die ich klären muss.
Mit PYOD muss ich mich intensiv beschäftigen . Ich verspreche mit viel davon.
Gute Zeit OSWALD

Code: Alles auswählen

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Using PyOD
from pyod.utils.data import generate_data, get_outliers_inliers
from pyod.models.pca import PCA
from pyod.utils.data import evaluate_print
from pyod.utils.example import visualize


# Daten generieren
# Start by creating a dataset using generate_data() from pyod
X_train, y_train = generate_data(train_only=True)


#DataFrame erstellen
#Konvertieren Sie die generierten Daten in einen Pandas DataFrame zur einfacheren Handhabung
#und Visualisierung.
#Fügen Sie eine Spalte für die Beschriftungen hinzu.


# Create dataframe from Pandas using the generated data
df_train = pd.DataFrame(X_train)
df_train['y'] = y_train

# Display first few rows
df_train.head()
# Daten visualisieren
#Visualisieren Sie den generierten Datensatz mithilfe des Streudiagramms von Seaborn.
#ie Farbe jedes Punkts stellt seine Bezeichnung dar (Ausreißer oder nicht).

sns.scatterplot(x=0, y=1, hue='y', data=df_train, palette="hls", legend="full")
plt.title('Grund-Wahrheit')
plt.grid()
plt.show() 

 


# PCA-Modell erstellen
#Initialisieren Sie ein PCA-Modell von pyod. PCA (Hauptkomponentenanalyse)
#wird zur Anomalieerkennung verwendet,
#indem Ausreißer basierend auf Hauptkomponenten identifiziert werden.


# Create PCA model
clf = PCA()


# PCA-Modell trainieren
#Trainieren Sie das PCA-Modell mit den generierten Daten.
#Die fitMethode wird zum Trainieren des Modells verwendet.
# Trains PCA model
clf.fit(X_train)


#Vorhersagen speichern
#Speichern Sie die Vorhersagen für Ausreißer und Inlier in Arrays als 0 und 1.
#Das labels_Attribut enthält die vorhergesagten Beschriftungen
#und das decision_scores_Attribut enthält die Anomaliewerte.


# Store predictions for inlier and outlier in array as 0s and 1s
y_train_pred = clf.labels_
y_train_scores = clf.decision_scores_


# Anomaliewerte visualisieren
#Visualisieren Sie die Anomaliewerte mithilfe des Streudiagramms von Seaborn. #
#Die Farbe jedes Punkts stellt seinen Anomaliewert dar.


ax = sns.scatterplot(x=0, y=1, hue=y_train_scores, data=df_train, palette="RdBu_r")

# Using legends, results look bit varied
legend_labels = [f"{score:.2f}" for score in np.unique(y_train_scores)]  # Format scores up to 2 decimal places
ax.legend(title="Anomaly Scores", labels=legend_labels)  # Create legend with title and labels
plt.title('Anomaly Scores by PCA')

#Create PCA model
clf = PCA()


# PCA-Modell trainieren
#Trainieren Sie das PCA-Modell mit den generierten Daten. #
#Die fit - Methode wird zum Trainieren des Modells verwendet.

# Trains PCA model
clf.fit(X_train)

# Vorhersagen speichern
#Speichern Sie die Vorhersagen für Ausreißer und Inlier in Arrays als 0 und 1. Das labels_Attribut enthält die vorhergesagten Beschriftungen und das decision_scores_Attribut enthält die Anomaliewerte.


# Store predictions for inlier and outlier in array as 0s and 1s
y_train_pred = clf.labels_
y_train_scores = clf.decision_scores_


# Anomaliewerte visualisieren
#Visualisieren Sie die Anomaliewerte mithilfe des Streudiagramms von Seaborn. Die Farbe jedes Punkts stellt seinen Anomaliewert dar.


ax = sns.scatterplot(x=0, y=1, hue=y_train_scores, data=df_train, palette="RdBu_r")

# Using legends, results look bit varied
legend_labels = [f"{score:.2f}" for score in np.unique(y_train_scores)]  # Format scores up to 2 decimal places
ax.legend(title="Anomaly Scores", labels=legend_labels)  # Create legend with title and labels
plt.title('Anomaly Scores by PCA')
plt.grid()
plt.show()

[OSWALD]

10.6.2025
Hier nun der erste Versuch einer konkreten Anwendung von PYOD.
Wie immer hat auch hier die Datenerhebung erste Priorität
Auch torch möchte ich hier noch einbeziehen,

OSWALD

Code: Alles auswählen

import numpy as  np
import matplotlib.pyplot  as  plt
from pyod.models.knn import KNN   # kNN detector
from pyod.utils.data import generate_data, get_outliers_inliers
from pyod.models.pca import PCA
from pyod.utils.data import evaluate_print
from pyod.utils.example import visualize


# Daten generieren
# Start by creating a dataset using generate_data() from pyod
X_train, y_train = generate_data(train_only=True)



#Generieren Sie Beispieldaten mit pyod.utils.data.generate_data():

contamination = 0.1  # percentage of outliers
n_train = 200  # number of training points
n_test = 100  # number of testing points

X_train, X_test, y_train, y_test = generate_data(
    n_train=n_train, n_test=n_test, contamination=contamination)
#Initialisieren Sie einen pyod.models.knn.KNNDetektor, passen Sie das Modell an und treffen Sie die Vorhersage.

# train kNN detector
clf_name = 'KNN'
clf = KNN()
clf.fit(X_train)

# get the prediction labels and outlier scores of the training data
y_train_pred = clf.labels_  # binary labels (0: inliers, 1: outliers)
y_train_scores = clf.decision_scores_  # raw outlier scores

# get the prediction on the test data
y_test_pred = clf.predict(X_test)  # outlier labels (0 or 1)
y_test_scores = clf.decision_function(X_test)  # outlier scores

# it is possible to get the prediction confidence as well
y_test_pred, y_test_pred_confidence = clf.predict(X_test, return_confidence=True)
# outlier labels (0 or 1) and confidence in the range of [0,1]
#Bewerten Sie die Vorhersage mithilfe von ROC und Precision @ Rank n pyod.utils.data.evaluate_print().

from pyod.utils.data import evaluate_print
# evaluate and print the results
print("\nOn Training Data:")
evaluate_print(clf_name, y_train, y_train_scores)
print("\nOn Test Data:")
evaluate_print(clf_name, y_test, y_test_scores)
#Sehen Sie sich Beispielausgaben sowohl für Trainings- als auch für Testdaten an.

#On Training Data:
#KNN ROC:1.0, precision @ rank n:1.0

#On Test Data:
#KNN ROC:0.9989, precision @ rank n:0.9
#Generieren Sie die Visualisierungen mit der in allen Beispielen enthaltenen Visualisierungsfunktion.

visualize(clf_name, X_train, y_train, X_test, y_test, y_train_pred,
          y_test_pred, show_figure=True, save_figure=False)

plt.show()

[OSWALD]

12.6.2025
Die Geschichte der Künstlichen Intelligenz (KI) lässt sich in verschiedene Phasen einteilen,
wobei der Beginn mit den theoretischen Grundlagen in den 1930er Jahren und
der ersten Konferenz über KI im Jahr 1956 festzumachen ist.
Fazit: Python ist KI.
Deshalb habe ich mich entschieden , ständig neue Teilaspaekte der KI
zu lernen.
Derzeit bin ich bei Torch. Leider kann ich Toerch und PYOD nicht kombinieren.
Deshalb komme ich auf Torch , Tensoren und Bilder zurück.
Zuesrst zeige ich ein Tool :' Bildformate mit Tork '.
Dann wie kann ich mit Torch Bilder laden.
Gute Zeit OSWALD

Code: Alles auswählen

#               Unterschiedliche     Bildformate      mit Tensoren  erstellen
#                           Vom Ergebnis  mit      _imshow -  direkt zum   'Bild'
import torch
# Create a sample grayscale//color     image tensor with shape (1, H, W, Mehrkanal)
image_tensor = torch.rand(1, 10, 10, 3)              # beliebige Formate wählen 
# Check if image_tensor is a grayscale/ color  image and has a single  or more channels  
if image_tensor.shape[0] == 1:  # Check if single channel
    image_tensor = image_tensor.squeeze(0)  # Remove the channel dimension

print("Shape after squeezing:", image_tensor.shape)
print("Hier das gewählte Bildformat     :", image_tensor   )

################################

#              Laden eines Bildes mit Torchvision

import matplotlib.pyplot as plt
from torchvision import transforms
from PIL import Image
import requests
from io import BytesIO

# URL of the image
image_url = 'https://picsum.photos/200/300'

# Download the image
response = requests.get(image_url)
image = Image.open(BytesIO(response.content))

# Define a transform to convert the image to a tensor
transform = transforms.Compose([
    transforms.ToTensor()
])

# Apply the transform to the image
image_tensor = transform(image)

#Anzeigen des Bildes in Pytorch mit matplotlib
import matplotlib.pyplot as plt

# Convert the tensor to channel-last format
image_np = image_tensor.permute(1, 2, 0).numpy()

# Display the image
plt.imshow(image_np)
plt.axis('off')  # Turn off axis labels
plt.show()

[OSWALD]

12.6.25
damit kann man jedes geladene Bild auch
auch analysieren.
OSWALD
#####################

print("Das ist der Tensor :",image_np)
print("shape ",image_np.shape)
######################

[OSWALD]

13.6.25
Mit diesen 3 Zeilen( 29,30,31 ) im letzten
Code
erhält man weitere Informationen
zum jeweiligen aktuellen Bild.

print("Das ist der Tensor :",image_np)
print("shape : ",image_np.shape)
print("Size : ", image_np.size)

Gute Zeit OSWALD