kleine Mathe-Spielereien

[OSWALD]

20.4.2025
Das Thema Datengewinnung ist immer noch hochaktuell.
Nun ein erster Versuch mit Torch und Matrizen.
Mit Torch ist es ohne weiteres möglich synthetische Daten zu gewinnen.
Bei analogen Versuchen mit Tensorflow ist das alles nicht mehr möglich.
Ich musste leider feststellen, dass für den ' Normalverbraucher'
Tensorflow nicht mehr zur Verfügung steht. Man muss nur die
"Hardware-Voraussetzungen " für Tensorflow nachlesen.
Meine sämtlichen ersten Tensorflow-Programme scheitern
schon bei 'import Tenrosflow as tf'. _Unbrauchbar also.
Hier eindas Beispiel mit torch
Gute Zeit OSWALD

Code: Alles auswählen

#    Berechnung von Tensoren
#Tensor 0  = Skalar , Tensor 1 = vector, Tensor 2 = matrix  

import  torch


print(" Datengewinnung    mit         Vektor  x   Vector  =  Tensor")
skalar1 = torch.randn(2)
print("VektorA    " ,skalar1)
skalar2 = torch.randn(2)
print("VektorB ",skalar2)

print()
print()


#Multiplikation   vector  x vector    mit matmul       ergibt    2 Tensoren
torch.matmul(skalar1, skalar2).size()
tensor= torch.matmul(skalar1, skalar2).size()
print(" 2 Vektoren bilden  tensor",tensor )
print()
print()



print(" Datengewinnung    und     matrix x vector")
matrixA = torch.randn( 3,4
)# Datengewinnung
print(matrixA )
matrixB = torch.randn(4) 
print(matrixB )
print()
print()

print("   3 x   3 x4  matrix multiplikation")
torch.matmul(matrixA , matrixB).size()
print(torch.matmul(matrixA, matrixB).size())
torch.Size([3])
print()
print()


# batched matrix x broadcasted vector
tensor1 = torch.randn(10, 3, 4)
print(tensor1 )
tensor2 = torch.randn(4)
print(tensor2 )


torch.matmul(tensor1, tensor2).size()
torch.Size([10, 3])
 # batched matrix x batched matrix
tensor1 = torch.randn(10, 3, 4)
print(tensor1)

tensor2 = torch.randn(10, 4, 5)
print(tensor2)
torch.matmul(tensor1, tensor2).size()

torch.Size([10, 3, 5])


 # batched matrix x broadcasted matrix
tensor1 = torch.randn(10, 3, 4)
print(tensor1)


tensor2 = torch.randn(4, 5)
print(tensor2)

torch.matmul(tensor1, tensor2).size()

print(tensor2)

[OSWALD]

24.4.2025
Ich beginne PyTorch mit der Erzeugung
synthetischer Zufalls-Daten von Matrizen und Tensoren.
torch.randn(8,8) ergibt immer Matrizen (8x8)
torch.fandn(8,8,1) ergibt immer Tensoren

Matrizen kann maan mit imshow darstelllen
Tensoren kann man, da 3D mit imshow nicht darstellen
Genau hier liegt der Knackpunkt, denn ich möchte auch die 3.Dim darstellen-
Es gibt ein imbedded " Modul ubigraph", dieses ist aber nur kommerziell erreichbar.
Das aber widerspricht dem open source Prinzip.(Hobby)
Also bin ich auf der Suche nach der visuellen Darstellung von 3D Tensoren.
(sieht nicht gut aus)
Gute Zeit OSWALD

Code: Alles auswählen

#Erzeugung von Zufalls-Matrizen  und Tensoren
#  
import torch 
x = torch.randn((8, 8))  #  entsteht eine   Matrix (mmer 2D)
print(x)

[OSWALD]

4.4.2025
Hierzu ein Beispiel:
ich habe nur tensor durch matrix ersetzt
ohne jegliche Veränderung
OSWALD

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt
import torch
#import matplotlib.cm as cm
#                             
 
matrix = ([[ 1.9142, -0.3580, -0.2318,  0.4833, -0.3514,  1.0003,  0.7939,  0.4898],
        [-1.6934, -0.3755,  0.7060,  0.0661,  0.4878, -0.5865,  1.0425, -0.2180],
        [-0.6687, -0.6098,  0.3713, -0.3411, -2.0592, -0.3839, -0.8848, -0.2597],
        [-1.4298,  0.9270,  1.6306,  0.8766, -0.6080,  0.8616, -1.0021, -1.2937],
        [ 1.1534, -0.8179, -0.0158,  1.0806,  0.4026,  3.2698,  0.5814, -1.6400],
        [ 0.0829,  0.5317,  0.6183, -0.4249,  0.1894,  0.2182, -1.4970,  2.1503],
        [ 0.0045,  1.2668,  0.9653,  1.4634, -0.3426,  1.1845,  0.1253, -0.5824],
        [-0.1883, -1.1787, -1.7248,  0.3514,  1.4711,  1.7292, -0.4492, -0.1684]])

matrix  
fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#

#'nearest' interpolation - faithful but blocky
ax1.imshow(matrix, interpolation='nearest', cmap=('spring')  )    
 
plt.show()

[OSWALD]

26.4.2025
Thema synth . Zufallszahlen.
Wenn man die einmal gewählten Zufallszahlen
für weitere Bearbeitung behalten will, kann man
"seed" wie folgt einsetzen:
seed(0) oder seed(1...... n) also eine beliebige Zahl.
Ansonsten werden immer neue Zahlen generiert.

seed wird oft auch mit der Kryptographie in Verbindung
gebracht, aber dafür nicht geeignet.
Gute Zeit OSWALD

Code: Alles auswählen

import torch
torch.manual_seed(0) 
stabil = torch.randn(5, 5)     
print(stabil)

[OSWALD]

26.4.2025
elementweise Division von Matrizen mit torch

ich einfach die geladene Matrix durch 10000 dividiert und es
scheint zu funktioniere. Dann wurde die Matrix als Bild generiert.
1. Erstellung der Matrix (Datensatz bleibt erhalten)I
. Darstellung der Matr[ze. 2 Programme
Weiterhin möchte ich mehr von Pixeln verstehen.??

Gute Zeit OSWALD

Code: Alles auswählen

import torch
torch.manual_seed(0) 
stabil = torch.randn(15, 15)     
print(stabil/10000)

#####################
mport numpy as np
import matplotlib.pyplot as plt
import torch
#import matplotlib.cm as cm
#                             
 
matrix =  [[-1.1258e-04, -1.1524e-04, -2.5058e-05, -4.3388e-05,  8.4871e-05,
          6.9201e-05, -3.1601e-05, -2.1152e-04,  3.2227e-05, -1.2633e-04,
          3.4998e-05,  3.0813e-05,  1.1984e-05,  1.2377e-04,  1.1168e-04],
        [-2.4728e-05, -1.3527e-04, -1.6959e-04,  5.6665e-05,  7.9351e-05,
          5.9884e-05, -1.5551e-04, -3.4136e-05,  1.8530e-04,  7.5019e-05,
         -5.8550e-05, -1.7340e-05,  1.8348e-05,  1.3894e-04,  1.5863e-04],
        [ 9.4630e-05, -8.4368e-05, -6.1358e-05,  3.1593e-06, -4.9268e-05,
          2.4841e-05,  4.3970e-05,  1.1241e-05,  6.4079e-05,  4.4116e-05,
         -1.0231e-05,  7.9244e-05, -2.8967e-05,  5.2507e-06,  5.2286e-05],
        [ 2.3022e-04, -1.4689e-04, -1.5867e-04, -6.7309e-05,  8.7283e-05,
          1.0554e-04,  1.7784e-05, -2.3034e-05, -3.9175e-05,  5.4329e-05,
         -3.9516e-05, -4.4622e-05,  7.4402e-05,  1.5210e-04,  3.4105e-04],
        [-1.5312e-04, -1.2341e-04,  1.8197e-04, -5.5153e-05, -5.6925e-05,
          9.1997e-05,  1.1108e-04,  1.2899e-04, -1.4782e-04,  2.5672e-04,
         -4.7312e-05,  3.3555e-05, -1.6293e-04, -5.4974e-05, -4.7983e-05],
        [-4.9968e-05, -1.0670e-04,  1.1149e-04, -1.4067e-05,  8.0575e-05,
         -9.3348e-06,  6.8705e-05, -8.3832e-05,  8.9182e-08,  8.4189e-05,
         -4.0003e-05,  1.0395e-04,  3.5815e-05, -2.4600e-05,  2.3025e-04],
        [-1.8817e-04, -4.9727e-06, -1.0450e-04, -9.5650e-05,  3.3532e-06,
          7.1009e-05,  1.6459e-04, -1.3602e-04,  3.4457e-05,  5.1987e-05,
         -2.6133e-04, -1.6965e-04, -2.2824e-05,  2.7996e-05,  2.4693e-05],
        [ 7.6887e-06,  3.3801e-05,  4.5440e-05,  4.5694e-05, -8.6537e-05,
          7.8131e-05, -9.2679e-05, -2.1883e-05, -2.4351e-04, -7.2915e-06,
         -3.3986e-06,  9.6252e-05,  3.4917e-05, -9.2146e-05, -5.6195e-06],
        [-6.2270e-05, -4.6372e-05,  1.9218e-04, -4.0255e-05,  1.2390e-05,
          1.1648e-04,  9.2337e-05,  1.3873e-04, -8.8338e-05, -4.1891e-05,
         -8.0483e-05,  5.6561e-05,  6.1036e-05,  4.6688e-05,  1.9507e-04],
        [-1.0631e-04, -7.7326e-06,  1.1640e-05, -5.9399e-05, -1.2439e-04,
         -1.0209e-05, -1.0335e-04, -3.1264e-05,  2.4579e-05, -2.5964e-05,
          1.1834e-05,  2.4396e-05,  1.1646e-04,  2.8858e-05,  3.8660e-05],
        [-2.0106e-05, -1.1793e-05,  1.9220e-05, -7.7216e-05, -1.9003e-04,
          1.3068e-05, -7.0429e-05,  3.1472e-05,  1.5739e-05,  3.8536e-05,
          9.6715e-05, -9.9108e-05,  3.0161e-05, -1.0732e-05,  9.9846e-05],
        [-4.9871e-05,  7.6111e-05,  6.1830e-05,  3.1405e-05,  2.1333e-05,
         -1.2005e-05,  3.6046e-05, -3.1403e-05, -1.0787e-04,  2.4081e-05,
         -1.3962e-04, -6.6144e-06, -3.5836e-05, -1.5616e-04, -3.5464e-05],
        [ 1.0811e-04,  1.3148e-05,  1.5735e-04,  7.8143e-05, -1.0787e-04,
         -7.2091e-05,  1.4708e-04,  2.7564e-05,  6.6678e-05, -9.9439e-05,
         -1.1894e-04, -1.1959e-04, -5.5963e-05,  5.3347e-05,  4.0689e-05],
        [ 3.9459e-05,  1.7151e-05,  8.7604e-05, -2.8709e-05,  1.0216e-04,
         -7.4395e-06, -1.0922e-04,  3.9203e-05,  5.9453e-05,  6.6227e-05,
         -1.2063e-04,  6.0744e-05, -5.4716e-05,  1.1711e-04,  1.5713e-04],
        [ 1.9161e-05,  3.7994e-05, -1.4476e-05,  6.3762e-05, -2.8129e-05,
         -1.3299e-04, -6.5380e-05, -5.3415e-05, -5.2338e-05,  8.6150e-05,
         -8.8696e-05,  8.3877e-05,  1.1529e-04, -1.7611e-04, -1.1070e-04]]

fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#

#'nearest' interpolation - faithful but blocky
ax1.imshow(matrix, interpolation='nearest', cmap=('spring')  )    
 
plt.show()

[OSWALD]

26.4.20p25Hier noch eine weitere Möglichkeit zur
Manipulation von synth. Daten mit "torch-where"
Gute Zeit OSWALD

Code: Alles auswählen

# torch where
import torch
 
torch.manual_seed(0) 
x = torch.randn(3, 3)
y = torch.ones(3, 3)

print(x)
print(y)
 
print(torch.where(x > 0, x, y))
print(torch.where(x < 0, x, y))
 

[OSWALD]

27.4.2025
Irgendwie kommt man bei der Beschäftigung
mit Python, Matrizen , synth. Daten und torch
auch auf das Thema ENTROPIE.
Hier erklärender Code mit Python
Dazu auch noch 'kleine Mathe-Spielerei
Ich versuche mit einem Trick einen Tensor zu
generieren und mit dem Entropie-Wert eine 'Matrix' zu visualisieren-
Reine Phantasie
Gute Zeit OSWALD

Code: Alles auswählen

#ENTROPIE
import numpy as np
from scipy.stats import entropy
base = 2  # work in units of bits
pk = np.array([1/2, 1/2])  # fair coin
H = entropy(pk, base=base)
H
1.0
H == -np.sum(pk * np.log(pk)) / np.log(base)
True
print("totale Unsicherheit = immer  1   :",H)

#manipulierte Münze   ist weniger unsicher
qk = np.array([9/10, 1/10])  # biased coin
entropy(qk, base=base)
print("manipulierte Münze ist weniger unsicher  :",entropy(qk, base=base))


0.46899559358928117
##################
#Die relative Entropie zwischen der fairen Münze und der
#verzerrten Münze wird wie folgt berechnet:

D = entropy(pk, qk, base=base)
print("relativee Entrope   .  ",D)
0.7369655941662062
np.isclose(D, np.sum(pk * np.log(pk/qk)) / np.log(base), rtol=4e-16, atol=0)
True

#Die Kreuzentropie kann als Summe der Entropie und der relativen Entropie berechnet werden:

CE = entropy(pk, base=base) + entropy(pk, qk, base=base)
print("Kreuzentropie    :", CE)
1.736965594166206
CE == -np.sum(pk * np.log(qk)) / np.log(base)
True

##############die Spoelerei

Code: Alles auswählen

#                  Entropie ist der Grad der Zufälligkeit in einem System.
 #                  Mit zunehmender Zufälligkeit steigt auch die Entropie .
#        Die Entropien von Gasen sind deutlich größer als die von Flüssigkeiten,
#                          die wiederum größer sind als die von Feststoffen.
#               Daher weist die Substanz in fester Phase die geringste Entropie auf.

#  Matrix-Konstruktion   zur  Erzeugung    zufälliger Entropie- Werte   
#  Entropie  ist  als Wahrscheinlichkeits-Wert  immmer  <  0.5
import matplotlib.pyplot as plt
import torch
#import matplotlib.cm as cm
                            
 
entropy = torch.rand(1, 1)/2
print("Entropie als Tensor angezeigt   :", entropy)

Entropy_neu =    entropy
print(Entropy_neu)
fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#
#'nearest' interpolation - faithful but blocky
ax1.imshow(Entropy_neu, interpolation='nearest', cmap=('spring')  )    
 
plt.show()

[OSWALD]

30.4.202530.4.2025
Ich muss gestehen, ich bin immer noch dabei, den Begriff
Entropie 100%ig zu verinnerlichen.
Trotzdem wage ich , nach dem Lesen von allen möglichen
Definitionen, jetzt eine Art Illustration mit Python,
abgewandelt , frei nach Aunkofer für die
' Zustandsbeschreibung Entropie ' zu zeigen.
Ich muss mich mit diesem Thema auf jeden Fall noch weiter beschäftigen.
Am besten in eInem konkreten Fall aus Chemie oder Physik.

Ich will es versuchen
Gute Zeit OSWALD

Code: Alles auswählen

Entropie nach Aunkofer
#    Die Entropie steigt ,
#    wenn Wärme von einem heißen zu einem kalten Objekt fließt .
#    Sie steigt, wenn Eis schmilzt, Wasser erhitzt wird, Wasser kocht oder verdunstet.
#    Die Entropie steigt,
#    wenn ein Gas aus einem Behälter unter hohem Druck in einen Bereich mit niedrigerem Druck fließt.


import numpy as np
from numpy import *
import torch
import matplotlib.pyplot as plt 
p = torch.randn(1,1)                   #  p = tensor =entropie  
#p = torch.rand(10 ,1)/2
#

def entropy(p):
    return  -p * np.log2(p) - (1-p) * np.log2(1 - p)   
#Die Entropie ist maximal (bei zwei Klassen: 1.00), #
#wenn die Klassen innerhalb einer Obermenge gleich häufig sind. 
#Gewinnt eine Klasse eine quantitative Dominanz, #
#steigt die Wahrscheinlichkeit für diese Klasse gleichermaßen an,
#die Entropie sinkt. Entropie, als Maß für die Unreinheit,
#funktioniert mathematisch nur mit Wahrscheinlichkeiten größer 0 und kleiner 1,
# was wir abfangen sollten:
print("Anzeige eins es Tensors  oder mehrerer Tensoren", p) 
print("kann als Matrix dargestellt werden")

def entropy(p):
    if p > 1.0 or p <= 0.0:
       return 0
    else:
        return - p * np.log2(p) - (1-p) * np.log2(1 - p)   
#Schauen wir uns die Entropie nun einmal visuell an:
#               Entropie als Maß der Unreinheit	
 
import numpy as np
import matplotlib.pyplot as plt 
 
x = np.arange(0.0, 1.0, 0.001)
p = [entropy(p) for p in x]

fig = plt.figure(figsize=(8,7))
ax = plt.subplot(111)
 
ax.plot(x, p, color = 'red', lw = 2)
 
plt.ylim([0, 1.01])
plt.xlim([-0.01, 1.01])
plt.xlabel('p(=zeitlicher Verlauf')
plt.ylabel('Entropie-Wert')
plt.title(" Verlauf des Entropie-Wertes" )
plt.grid()
plt.show()
 
#Der Gini-Koeffizient als Maß für Unreinheit
#Der Gini-Koeffizient funktioniert ähnlich wie die Entropie
#und nimmt sein Maximum bei exakt gleichhäufigen Klassen an,
#das bei 0,5 liegt. Der Gini-Koeffizient hat auch gegenüber der Entropie
#ein flacheres degressives Wachstum,
#reagiert demnach etwas unempfindlicher auf Änderungen in Klassenhäufigkeiten.

#Gini = \sum \limits_{i = 1}^n p_{i} \cdot (1 - p_{i}) = 1 - \sum \limits_{i = 1}^n p_{i}^2
#In Python:
def gini(p):
    q = 1 - p
    return p * q+ (1 - p) * (1 - ( 1 - p))
 
#Der Klassifikationsfehler als Maß für die Unreinheit
#Noch unempfindlicher auf Änderungen in den Klassenhäufigkeiten
#(= Klassenwahrscheinlichkeiten) ist der Klassifikationsfehler:

#Fehler = 1 - max([p_{1}, \dotso p_{n}])

#In Python:
 
def error(p):
    return 1 - np.max([p, 1 - p])
 
#Der Klassifikationsfehler sollte, insbesondere bei Mehrfachklassifikation,
#nicht zur Konstruktion für Entscheidungsbäume verwendet werden, #
#ist aber das empfohlene Maß für das nachträgliche Stutzen (Pruning)
#der Baumzweige (Entscheidungsbäume neigen zu vielen komplexen Modellen und zum Overfitting, was durch Pruning korrigiert werden kann).
#Unreinheit – Alles zusammenbringen
#Bringen wir nun Entropie, Gini-Koeffizient und Klassifikationsfehler in eine gemeinsame Darstellung:
 
x = np.arange(0.0, 1.0, 0.001)
p = [entropy(p) for p in x]
p_scaled = [e * 0.5 for e in p]
err = [error(i) for i in x]
 
fig = plt.figure(figsize=(8,7))
ax = plt.subplot(111)
for i, lab, ls, c, in zip ([p, p_scaled, gini(x), err], 
                            ['Entropie', 'Entropie (skaliert)', 'Gini-Koeffizient', 'Klassifizierungsfehler'], 
                            ['-', '-', '--', '-.'], 
                            ['red', 'orange', 'black', 'black']):
    line = ax.plot(x, i, label = lab, linestyle = ls, lw = 2, color = c)
 
 
 
ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.30), ncol = 3)
ax.axhline(y = 0.5, linewidth = 1, color = 'k', linestyle = '--')
ax.axhline(y = 1.0, linewidth = 1, color = 'k', linestyle = '--')
plt.ylim([0, 1.01])
plt.xlim([-0.01, 1.01])
plt.xlabel('p(x =zeitlicher Verlauf)')
plt.ylabel("Entropie'")
plt.title("Entropie '-' ,Entropie skaliert''-',Gni'-- ',Klassifizierungsfehler'-.' ")

[OSWALD]

1.5.2025
Zeitpunkt Bildverarbeitung:
Visualisierung der skalaren Entropie.
Entropie hier Zustandsbeschreibung des Bildes.
Gute Zeit OSWALD

Code: Alles auswählen

import matplotlib.pyplot as plt
import numpy as np
import torch

import numpy as np
from skimage import data
from skimage.util import img_as_ubyte
from skimage.filters.rank import entropy
from skimage.morphology import disk

rng = np.random.default_rng()                      #PseudoZufalls Gen.  64 bit int 
 
noise_mask = np.full((128, 128), 28, dtype=np.uint8)
noise_mask[32:-32, 32:-32] = 30
noise = (noise_mask * rng.random(noise_mask.shape) - 0.5 * noise_mask).astype(np.uint8)
#print(noise)
img = noise + 128
print(img)
entr_img = entropy(img, disk(10))

fig, (ax0, ax1, ax2) = plt.subplots(nrows=1, ncols=3, figsize=(10, 4))
img0 = ax0.imshow(noise_mask, cmap='gray')

ax0.set_title("Object")
ax0
ax1.imshow(img, cmap='gray')

ax1.set_title("Noisy image")
ax2.imshow(entr_img, cmap='viridis')
ax2.set_title("Local entropy")

#img.tight_layout()
plt.show()

[OSWALD]

1.5.2025
Hier habe ich noch ein kleines Programm
geschrieben, mit dem sich beliebige Entropie-Verläufe
als Bilder darstellen lassen.
Man kann die Einzelwerte solcher Matrizen natürlich
als Quellen für synthetische Daten aller Art verwenden.
Gute Zeit OSWALD

Code: Alles auswählen

 
#  Erzeugung    zufälliger Entropie- Werte   mit anschließender  Visualisierung  

import matplotlib.pyplot as plt
import torch
#import matplotlib.cm as cm
                            
 
entropy = torch.rand(334, 334)
print("Entropie-Verlauf  als Tensor / Matrix angezeigt   :", entropy)

Entropy_neu =    entropy
print(Entropy_neu)
fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#
#'nearest' interpolation - faithful but blocky
ax1.imshow(Entropy_neu, interpolation='nearest', cmap=('spring')  )    
 
plt.show()

[OSWALD]

1.5.2025
Ich kann das Spielen nicht lassen.
Mein PC schafft in etwa 20 sec

torch.rand( 32553 x 32553) Pixel
(und maximal ?),
ist also eine gute Methode , um die Leistungsfähigkeit eines PC zu messen
Gute Zeit OSWALD

[OSWALD]

2.5.2025
Matrizen sind zweidimensional.
Mit der Hinzufügung von Farbe entsteht
ein 3-D -Tensor. Auch dieser lässt sich visualisieren,
wie hier gezeigt.
Gute Zeit OSWALD

Code: Alles auswählen

#  Erzeugung    zufälliger Entropie- Werte   mit anschließender  Visualisierung  
#  2D  und 3D
import matplotlib.pyplot as plt
import torch
#import matplotlib.cm as cm
                            
 
#entropy = torch.rand(34, 24)
entropy = torch.rand(34, 24,3)
print("Entropie-Verlauf  als Tensor / Matrix angezeigt   :", entropy)
print("2D-Matrizen  oder 3D-Tensoren darstellbar")
      
Entropy_neu =    entropy
print(Entropy_neu)
fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#
#'nearest' interpolation - faithful but blocky
ax1.imshow(Entropy_neu, interpolation='nearest', cmap=('spring')  )    
 
plt.show()

[OSWALD]

5.5.2025
Nach Einarbeitung in
syth, Daten und Matrizen, wage ich mich
an die Bildanalyse und beginne mit
einem ersten Programm zur Darstellung von
Datentypen und Bildwerten.
Es ist dabei essentiell, sich quasi mit
jeder Zahl und Funktion zu befassen, um die
Zusammenhänge zu verstehen. Ein Versuch,
auf dem ich dann aufbauen kann.
Gute Zeit OSWALD

Code: Alles auswählen

#                Datentypen und Bildwerte
 #               Darstellung von Bildwerten:

 
#Hier zwei gültige Bilder:
import numpy as np
import matplotlib.pyplot as plt
linear0 = np.linspace(0, 1, 400).reshape((20, 20))
#print("          Daten für Bild 1    :", linear0)
linear1 = np.linspace(0, 50, 2500).reshape((50, 50)).astype(np.uint8)
#print("           Daten für Bild 2   : " , linear1 )
#print("Linear0:", linear0.dtype, linear0.min(), linear0.max())
#print("Linear1:", linear1.dtype, linear1.min(), linear1.max())

fig, (ax0, ax1) = plt.subplots(1, 2, figsize=(15, 15))
ax0.imshow(linear0, cmap='gray')
ax1.imshow(linear1, cmap='spring');
#Linear0: float64 0.0 1.0
     #Linear1: uint8 0 255
plt.show() 

[OSWALD]

18.5.2025
Die sog. Bildanalyse ist ein Teil der Bildverarbeitung.
Hier ein ganz einfaches Beispiel dafür.
Dieses zeigt, dass ( alle? ) Bilder aus Pixeln innerhalb
einer Matrix bestehen( können).
Selbst in diesem kleinen Programm ist die Menge der
Daten schon, groß, dass sie nicht alle
gleichzeitig dargestellt werden können.
Die Bedeutung der einzelnen Argumente für das Gesamtbild
muss nun eruiert werden.
Das ist bei diesem Bild relativ leicht, anders bei größeren Bildern.
Insgesamt aber sind die Möglichkeiten eir Analyse eingeschränkt
Der Begriff data.checkerboard wird in einem 2. Programm geklärt.
Es folgen nun weitere Versuche

Gute Zeit OSWALD

Code: Alles auswählen

#  Einfachstes  Beispiel zum   Versuch einer Bildmanipulation 

import numpy as np
import matplotlib.pyplot as plt
from skimage import data, filters, color, morphology
from skimage.segmentation import flood, flood_fill
checkers = data.checkerboard()     #  checkerboard =schwarz-weiß -Matrix
print("                  Das sind Daten des Originals    :",checkers)
# Fill a square near the middle with value 127, starting at index (76, 76),25)
print()
print("                  Das sind Daten nach der Füllung     :",checkers)
filled_checkers = flood_fill(checkers, (76, 76), 169)
print()
print(filled_checkers)
print()
print("                 Shape    :    =  ",checkers.shape)
  
fig, ax = plt.subplots(ncols=2, figsize=(10, 5))      #
ax[0].imshow(checkers, cmap=plt.cm.Blues)
ax[0].set_title('Original')

ax[1].imshow(filled_checkers, cmap=plt.cm.Reds)
ax[1].plot(67, 67  , 'wx')  # seed point
ax[1].set_title('Nach der Füllung')

plt.show()

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


#checkerboardmuster
import numpy as np

# function to print Checkerboard pattern
def printcheckerboard(n):
    print("Checkerboard pattern:")

    # create a n * n matrix
    x = np.zeros((n, n), dtype=int)

    # fill with 1 the alternate cells in rows and columns
    x[1::2, ::2] = 1
    x[::2, 1::2] = 1

    # print the pattern
    for i in range(n):
        for j in range(n):
            print(x[i][j], end=" ")
        print()

# driver code
n = 15
printcheckerboard(n)

[OSWALD]

18.5.2025
Bei diesem Beispiel geht es u.a. hauptsächlich
um Farben.
Natürlich sind hier zahlreiche weitere Begriffe zu klären,
die aber alle schon einmal erörtet wurden.
Gute Zeit OSWALD

[code

# VERSUCH einer BILDANALYSE
import matplotlib.pyplot as plt
from skimage import data
from skimage import color
from skimage import img_as_float, img_as_ubyte
import numpy as np
grayscale_image = img_as_float(data.camera()[::2, ::2])
image = color.gray2rgb(grayscale_image)

red_multiplier = [1, 0, 1]
yellow_multiplier = [1, 1, 0]

fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(8, 4), sharex=True, sharey=True)
ax1.imshow(red_multiplier * image)
ax2.imshow(yellow_multiplier * image)

hue_gradient = np.linspace(0, 1)
hsv = np.ones(shape=(1, len(hue_gradient), 3), dtype=float)
hsv[:, :, 0] = hue_gradient

all_hues = color.hsv2rgb(hsv)

fig, ax = plt.subplots(figsize=(5, 4))
# Set image extent so hues go from 0 to 1 and the image is a nice aspect ratio.
ax.imshow(
all_hues, extent=(0 - 0.5 / len(hue_gradient), 1 + 0.5 / len(hue_gradient), 0, 0.2)
)
ax.set_axis_off()


def colorize(image, hue, saturation=1):
"""Add color of the given hue to an RGB image.
By default, set the saturation to 1 so that the colors pop!
"""
hsv = color.rgb2hsv(image)
hsv[:, :, 1] = saturation
hsv[:, :, 0] = hue
return color.hsv2rgb(hsv)

hue_rotations = np.linspace(0, 1, 6)
fig, axes = plt.subplots(nrows=2, ncols=3, sharex=True, sharey=True)

for ax, hue in zip(axes.flat, hue_rotations):
# Turn down the saturation to give it that vintage look.
tinted_image = colorize(image, hue, saturation=0.3)
ax.imshow(tinted_image, vmin=0, vmax=1)
ax.set_axis_off()
fig.tight_layout()

from skimage.filters import rank
# Square regions defined as slices over the first two dimensions.
top_left = (slice(25),) * 2
bottom_right = (slice(-25, None),) * 2

sliced_image = image.copy()
sliced_image[top_left] = colorize(image[top_left], 0.82, saturation=0.5)
sliced_image[bottom_right] = colorize(image[bottom_right], 0.5, saturation=0.5)

# Create a mask selecting regions with interesting texture.
noisy = rank.entropy(img_as_ubyte(grayscale_image), np.ones((9, 9)))
textured_regions = noisy > 1.25

masked_image = image.copy()
masked_image[textured_regions, :] *= red_multiplier
fig, (ax1, ax2) = plt.subplots(
ncols=2, nrows=1, figsize=(8, 4), sharex=True, sharey=True
)
ax1.imshow(sliced_image)
ax2.imshow(masked_image)
plt.show()



[/code]

[OSWALD]

19.5.2025
Wenn man sich in der Bildanalyse versucht
,dann liegt es nahe, sich auch mal an ein
Konstruktion eines 'echten' Bildes zu wagen.
Um 'echte' Daten zu erhalten , verwende ich ein erstes Programm.
Es handelt sich um ein einfaches Model eines
neuronales Netzwerkes.
Mit diesen Daten werde ich das gewünschte Bild generieren.
Welche Informationen kann ich dem Bild entnehmen. ?????
Gute Zeit OSWALD

Code: Alles auswählen

[

#    Einfaches neuronales Netzwerk
import torch
import torch.nn as nn
import torch.optim as optim
print("Testung der Verlust-Funktion")
# Dummy dataset
X = torch.rand((100, 10))
print("DATEN ziegen von X  :",X)
y = torch.randint(0, 2, (100,))
 
# Define the model
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc1 = nn.Linear(10, 5)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(5, 2)
 
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x
 
# Instantiate the model, loss function, and optimizer
model = SimpleModel()

#criterion: legt fest, welche Funktion verwendet wird, um die Güte einer Aufteilung (engl. Split) an #einem Knoten zu messen.
#Als Kriterium kann entweder "gini" oder "entropy" verwendet.
criterion = nn.CrossEntropyLoss()
print("Verlust-Funktion zeigt   an :",  criterion)
optimizer = optim.SGD(model.parameters(), lr=0.01)
 
# Training loop
epochs = 100
for epoch in range(epochs):
    # Forward pass
    outputs = model(X)
    loss = criterion(outputs, y)
    
    # Backward pass and optimization
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
 
    # Print the loss every 10 epochs
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{epochs}], Loss: {loss.item():.4f}')
 
# Test the trained model
with torch.no_grad():
    test_outputs = model(X)
    predicted_classes = torch.argmax(test_outputs, dim=1)
 
    accuracy = torch.sum(predicted_classes == y).item() / len(y)
    print(f'Test Accuracy: {accuracy * 100:.2f}%')

###############################################
mport numpy as np
import matplotlib.pyplot as plt
import torch
import scipy
from scipy import  ndimage
  
tensor =  ([[2.9222e-01, 6.8663e-01, 4.1914e-01, 3.2479e-01, 6.0228e-01, 3.2373e-01,
         2.9539e-01, 8.4033e-01, 9.5505e-01, 7.0594e-01],
        [5.5544e-01, 8.2971e-01, 7.2241e-01, 9.7464e-01, 5.7786e-01, 5.0167e-01,
         8.6048e-01, 6.8625e-01, 4.0596e-01, 7.5086e-01],
        [3.1874e-01, 6.3524e-01, 2.6089e-01, 9.6443e-01, 9.0779e-01, 2.1823e-01,
         5.6332e-01, 5.1251e-01, 4.7989e-03, 7.4893e-01],
        [5.9204e-01, 4.4428e-01, 9.6443e-01, 5.8609e-01, 5.0464e-01, 8.8172e-01,
         6.6654e-01, 7.8601e-01, 9.4057e-01, 2.2864e-01],
        [2.5650e-01, 8.7065e-01, 9.0367e-01, 4.7278e-01, 9.3282e-01, 5.8669e-01,
         5.9083e-01, 2.1389e-01, 9.1218e-01, 9.9553e-01],
        [6.6305e-01, 2.9749e-01, 3.6908e-01, 6.4292e-01, 7.5590e-01, 1.5389e-01,
         3.5624e-02, 7.3437e-01, 3.8163e-01, 2.7315e-01],
        [1.7760e-01, 4.4198e-01, 3.3210e-01, 6.0096e-01, 3.0625e-01, 5.1850e-01,
         7.1673e-01, 8.7827e-02, 3.5141e-01, 3.0929e-02],
        [5.8477e-01, 2.1883e-01, 4.3152e-01, 6.9485e-01, 7.1417e-01, 6.9463e-01,
         3.4283e-01, 2.7907e-01, 2.6518e-01, 6.6480e-01],
        [8.8045e-01, 9.5399e-01, 5.3331e-01, 2.9123e-01, 5.8292e-01, 3.6120e-01,
         6.8459e-01, 7.9680e-01, 8.6240e-01, 1.5592e-01],
        [9.2280e-01, 9.9376e-01, 8.4381e-01, 6.5200e-01, 3.1540e-01, 4.5797e-01,
         4.1886e-02, 6.3258e-01, 9.5808e-01, 5.0344e-02],
        [8.8334e-02, 8.9776e-01, 3.4384e-01, 5.0235e-01, 3.1382e-01, 7.9876e-01,
         2.0493e-01, 6.4204e-02, 4.4943e-02, 8.7843e-01],
        [8.0665e-01, 8.3744e-01, 3.3685e-01, 2.9427e-01, 1.1306e-01, 4.1694e-01,
         7.1008e-01, 8.7323e-01, 7.6534e-01, 2.8780e-01],
        [7.1148e-01, 3.8040e-02, 3.6555e-01, 9.6701e-01, 5.9422e-02, 2.0057e-01,
         6.1941e-01, 3.7715e-01, 3.0884e-01, 4.1637e-01],
        [6.2487e-01, 4.1928e-01, 5.1479e-01, 3.3076e-01, 8.2149e-01, 7.2501e-01,
         1.2322e-01, 1.3032e-02, 3.0238e-01, 7.9741e-01],
        [8.6331e-01, 6.9823e-02, 7.6358e-01, 3.1601e-01, 4.5241e-01, 8.1125e-01,
         3.0014e-01, 5.6941e-01, 4.5805e-01, 8.5795e-01],
        [7.0448e-01, 7.7074e-01, 1.5635e-01, 7.9033e-02, 6.1231e-01, 5.8012e-01,
         2.8157e-01, 4.6207e-01, 7.5831e-01, 1.8134e-01],
        [6.1088e-01, 5.3516e-01, 2.2604e-01, 9.7685e-01, 5.2848e-01, 1.5712e-01,
         1.7187e-01, 5.6004e-01, 4.1409e-01, 9.8594e-02],
        [6.6292e-01, 8.8074e-01, 3.0678e-02, 7.8093e-01, 1.9115e-01, 7.8609e-01,
         4.3511e-01, 8.1887e-01, 4.5660e-01, 1.9084e-02],
        [7.5283e-01, 9.7684e-02, 9.4945e-01, 5.6791e-01, 7.0553e-02, 6.4049e-01,
         3.0040e-01, 8.1810e-01, 4.3042e-01, 4.4683e-01],
        [5.3737e-01, 1.3268e-02, 7.1108e-02, 8.8229e-01, 4.0202e-02, 4.7219e-01,
         2.5212e-01, 8.1536e-01, 3.5650e-02, 2.8261e-01],
        [4.6611e-01, 6.6067e-01, 1.5575e-01, 5.3506e-01, 2.2433e-01, 1.5486e-01,
         3.0141e-01, 7.6119e-01, 2.7229e-02, 3.6025e-01],
        [1.0992e-01, 4.2459e-01, 4.4045e-01, 2.2743e-01, 8.0854e-01, 6.4810e-02,
         6.3009e-01, 5.8266e-01, 5.5659e-01, 1.1392e-01],
        [7.6072e-01, 9.7096e-01, 5.1644e-01, 2.1967e-01, 3.2724e-01, 2.0654e-01,
         7.4081e-01, 1.5519e-01, 2.1602e-01, 9.6006e-01],
        [5.4901e-01, 1.3773e-01, 5.7840e-01, 8.8988e-01, 8.4628e-01, 9.5022e-01,
         2.4751e-01, 9.8896e-01, 2.0124e-01, 8.7620e-01],
        [5.8564e-01, 5.1860e-02, 3.9538e-01, 7.0925e-01, 7.7490e-03, 5.5837e-01,
         2.8165e-01, 5.3774e-01, 2.6431e-01, 9.9645e-02],
        [8.6033e-01, 3.3721e-01, 8.3283e-01, 2.5277e-02, 7.9154e-01, 8.4806e-01,
         5.5159e-01, 6.9289e-01, 1.6528e-01, 8.0464e-01],
        [5.2457e-01, 9.0078e-01, 2.1915e-01, 2.5751e-01, 9.0211e-01, 6.7849e-01,
         1.1509e-01, 7.1387e-01, 8.6969e-01, 2.7644e-01],
        [5.5972e-02, 1.1983e-01, 4.9041e-01, 9.9400e-01, 8.8517e-01, 1.4428e-02,
         3.7697e-01, 6.4687e-01, 3.8596e-01, 9.6571e-01],
        [6.8951e-01, 8.5334e-01, 8.6565e-02, 1.8547e-02, 6.5070e-02, 8.7672e-01,
         4.1221e-01, 4.4641e-01, 2.3863e-01, 9.1675e-01],
        [4.9606e-01, 2.6298e-02, 6.4699e-01, 4.2721e-01, 1.4803e-01, 6.9795e-01,
         2.8151e-01, 7.6911e-01, 6.1303e-01, 8.5187e-01],
        [9.8147e-01, 7.0773e-01, 7.8670e-01, 1.4692e-01, 6.0948e-01, 3.5310e-02,
         5.1172e-02, 1.1099e-01, 6.9157e-01, 1.4322e-01],
        [9.0609e-02, 3.0412e-01, 9.8467e-01, 3.0651e-01, 2.7855e-01, 7.7115e-01,
         4.1309e-01, 1.9661e-01, 2.8331e-01, 2.1097e-01],
        [1.9634e-02, 5.7923e-01, 1.4618e-01, 3.9010e-01, 9.6408e-01, 5.4127e-01,
         2.0997e-01, 6.0890e-02, 8.7565e-01, 1.7133e-02],
        [5.6985e-01, 5.7799e-01, 4.2893e-01, 5.1398e-02, 2.4685e-01, 1.7251e-01,
         6.1724e-01, 3.6940e-01, 6.5831e-01, 5.2967e-01],
        [3.4606e-01, 9.5751e-01, 7.6821e-01, 9.7272e-01, 4.7985e-01, 1.7994e-01,
         4.4263e-01, 6.9897e-01, 5.4709e-02, 6.3397e-02],
        [1.6931e-01, 5.5858e-01, 4.3684e-01, 6.7865e-02, 3.0036e-01, 9.5423e-01,
         7.6249e-01, 5.9683e-01, 6.9628e-01, 9.4078e-01],
        [2.7949e-01, 4.6483e-01, 1.0771e-01, 3.4711e-02, 6.8404e-01, 4.5241e-01,
         4.5303e-02, 3.5591e-01, 4.1435e-02, 3.1528e-01],
        [9.0869e-01, 7.4594e-01, 1.1349e-01, 7.7406e-01, 1.1500e-01, 1.7778e-01,
         9.8661e-01, 4.3592e-01, 5.1381e-01, 9.2029e-01],
        [1.7512e-01, 3.0051e-01, 6.4638e-01, 4.4352e-02, 2.0955e-02, 3.1129e-01,
         4.8915e-01, 4.7555e-01, 1.6702e-01, 4.6281e-01],
        [9.5157e-01, 7.7810e-02, 2.7575e-01, 9.7361e-02, 4.6171e-01, 9.5497e-01,
         5.7111e-02, 7.3816e-01, 8.5530e-01, 1.3710e-01],
        [3.9048e-01, 5.5571e-01, 2.9871e-01, 9.1940e-01, 4.0984e-01, 1.7032e-01,
         1.3171e-02, 3.8254e-01, 3.9833e-01, 8.5882e-01],
        [5.3493e-01, 2.0766e-01, 4.3932e-01, 8.3939e-01, 6.8860e-01, 1.9726e-01,
         9.0481e-01, 7.1256e-01, 5.1281e-01, 2.8908e-02],
        [3.8967e-01, 1.2540e-01, 5.5113e-01, 2.9233e-01, 3.2754e-01, 3.3044e-01,
         6.6803e-01, 6.6371e-01, 1.6859e-02, 7.6549e-01],
        [1.0511e-01, 2.3739e-01, 8.6655e-01, 6.5663e-01, 9.1280e-01, 3.7999e-01,
         2.6827e-01, 1.3552e-01, 7.9422e-01, 3.4088e-01],
        [9.3246e-01, 5.9042e-01, 9.9210e-01, 1.4655e-01, 1.1316e-01, 9.7569e-01,
         9.4429e-01, 8.1775e-01, 5.1455e-01, 3.7566e-01],
        [9.6137e-01, 4.3157e-01, 2.1667e-01, 7.8126e-01, 8.5581e-01, 4.0715e-03,
         5.5497e-01, 9.8247e-01, 4.8944e-02, 2.1780e-02],
        [8.2578e-01, 3.0677e-01, 8.0798e-01, 1.3925e-01, 4.6488e-01, 3.7848e-01,
         4.0705e-01, 4.3679e-01, 1.7203e-01, 3.6747e-01],
        [2.1734e-01, 9.3373e-01, 6.6016e-01, 4.6801e-01, 2.2420e-01, 3.2868e-01,
         6.1461e-01, 1.7236e-01, 7.9881e-01, 2.5230e-01],
        [2.9836e-01, 2.5506e-01, 8.7575e-01, 8.3300e-01, 9.6389e-01, 2.1767e-01,
         1.3653e-01, 3.5681e-01, 3.7055e-01, 4.3991e-01],
        [9.9734e-01, 6.0806e-01, 5.2164e-01, 3.7105e-02, 3.5561e-01, 4.1590e-01,
         5.0681e-01, 6.7795e-01, 5.1055e-01, 8.3642e-01],
        [1.7313e-01, 7.0428e-02, 8.2351e-01, 8.7569e-01, 4.4394e-01, 5.2152e-01,
         5.7196e-01, 3.4497e-01, 5.2469e-01, 4.9370e-01],
        [8.3869e-01, 5.0104e-01, 8.1875e-01, 6.9142e-01, 3.9997e-01, 2.6710e-01,
         9.5983e-01, 3.1358e-01, 3.6192e-01, 3.6725e-01],
        [2.5805e-01, 8.9373e-01, 2.2295e-01, 6.3752e-01, 7.0348e-01, 6.6524e-01,
         9.3193e-01, 1.1488e-01, 4.7194e-01, 4.4708e-01],
        [3.3909e-01, 7.2410e-01, 3.2524e-01, 8.7411e-02, 2.4941e-02, 9.3732e-01,
         1.9455e-01, 1.5489e-01, 2.9837e-01, 8.2482e-02],
        [2.2607e-01, 1.6468e-01, 8.4908e-01, 3.1397e-01, 3.9330e-01, 3.1672e-01,
         8.2573e-01, 6.3221e-02, 8.0053e-01, 9.0150e-01],
        [8.7152e-01, 1.4332e-01, 9.6870e-01, 4.4784e-01, 3.9655e-01, 7.6710e-01,
         8.5161e-01, 6.4302e-01, 3.9614e-01, 2.9665e-01],
        [7.0411e-01, 1.6245e-01, 8.8512e-02, 5.9223e-01, 5.1323e-01, 6.7313e-01,
         9.6079e-01, 7.7948e-01, 2.7065e-01, 8.6823e-01],
        [1.9587e-01, 9.3866e-01, 5.2729e-01, 3.5963e-01, 7.1215e-01, 9.3342e-01,
         1.2569e-01, 3.0992e-01, 3.2552e-01, 8.9278e-01],
        [1.4818e-01, 1.4275e-01, 5.4856e-01, 9.9537e-01, 1.0662e-01, 8.6988e-01,
         4.9906e-02, 3.8861e-01, 2.0084e-01, 2.5154e-01],
        [7.7792e-01, 1.3703e-01, 7.3264e-01, 2.9706e-01, 4.5026e-01, 7.4389e-01,
         7.2757e-03, 2.6973e-01, 3.2169e-01, 5.6198e-01],
        [2.5568e-01, 7.8891e-01, 1.3368e-01, 3.7920e-01, 7.5319e-01, 7.7325e-01,
         7.9872e-01, 4.1685e-01, 9.9097e-01, 8.5145e-02],
        [5.1568e-01, 8.6595e-01, 7.4815e-01, 1.6975e-01, 8.7473e-01, 2.7133e-01,
         5.3170e-01, 2.5603e-02, 4.9775e-01, 7.2825e-01],
        [1.4931e-01, 2.1399e-01, 3.5575e-01, 7.9274e-01, 9.0562e-01, 8.4352e-01,
         7.4092e-02, 8.7944e-01, 9.6758e-01, 9.5010e-01],
        [7.9526e-01, 3.4426e-01, 5.4267e-01, 2.8139e-01, 9.6069e-01, 9.9585e-01,
         9.7355e-02, 6.7790e-01, 1.0186e-01, 8.7978e-01],
        [5.6790e-02, 8.7512e-01, 3.6122e-01, 6.6688e-01, 2.7828e-01, 6.3765e-01,
         3.0436e-01, 7.8392e-01, 2.5085e-01, 2.9563e-01],
        [8.6982e-01, 7.5486e-01, 6.1933e-01, 6.6229e-01, 2.6602e-01, 9.2379e-01,
         4.8884e-01, 1.9995e-01, 4.5762e-01, 5.4512e-02],
        [2.2080e-01, 6.9508e-01, 9.7425e-01, 8.4476e-01, 2.2368e-01, 2.3680e-01,
         4.9887e-01, 5.9969e-01, 2.2045e-01, 6.3384e-01],
        [4.3330e-01, 7.2166e-03, 7.9777e-01, 9.0748e-01, 8.5832e-01, 7.9568e-02,
         1.6630e-01, 6.5773e-01, 4.5499e-01, 7.9068e-02],
        [5.2761e-01, 7.6765e-01, 5.1973e-02, 9.6698e-01, 1.4936e-02, 1.5769e-01,
         2.7398e-01, 6.1970e-01, 3.5983e-01, 2.8027e-01],
        [3.1966e-02, 5.2905e-01, 5.1649e-01, 3.4139e-01, 6.6388e-01, 9.7574e-01,
         4.7287e-01, 9.9288e-01, 7.7020e-01, 2.2221e-01],
        [2.5633e-01, 3.1520e-01, 7.1653e-01, 6.4355e-01, 9.8392e-02, 3.7037e-02,
         2.8539e-01, 9.4372e-01, 3.4244e-01, 4.8553e-02],
        [8.9574e-01, 4.7491e-01, 6.6274e-03, 5.5411e-01, 9.4067e-01, 6.1803e-01,
         8.2746e-01, 9.1990e-01, 8.6414e-01, 3.6938e-01],
        [1.3779e-01, 8.5399e-01, 6.7845e-01, 6.7704e-01, 9.6094e-02, 3.0603e-01,
         2.8175e-01, 6.3975e-01, 2.0144e-01, 3.1131e-01],
        [1.6600e-01, 1.0541e-01, 1.6036e-01, 8.1871e-01, 8.5597e-02, 7.5808e-01,
         5.5306e-01, 3.9933e-01, 8.3156e-01, 5.2096e-02],
        [6.5191e-01, 6.7186e-01, 4.7698e-01, 8.3654e-01, 6.9990e-02, 9.3142e-01,
         7.4296e-01, 8.8787e-01, 8.6272e-02, 8.9171e-01],
        [6.0749e-01, 5.3081e-01, 7.6772e-01, 7.3041e-01, 5.5577e-01, 9.3322e-01,
         4.9645e-01, 6.7960e-01, 6.0921e-01, 2.4096e-01],
        [2.8267e-01, 8.2379e-01, 9.5513e-01, 6.6809e-01, 4.7172e-01, 7.0887e-01,
         5.7371e-01, 6.2902e-01, 5.7224e-01, 4.0719e-01],
        [8.5748e-01, 4.4690e-01, 9.7979e-01, 4.8270e-01, 6.6564e-01, 8.4580e-01,
         2.9920e-01, 8.7938e-01, 4.1206e-01, 8.8065e-01],
        [2.1827e-01, 6.1685e-01, 6.2416e-01, 1.1625e-01, 9.3612e-01, 3.8182e-01,
         8.6648e-01, 7.7634e-01, 9.5924e-01, 8.4979e-01],
        [4.5904e-01, 2.8375e-01, 1.7923e-01, 1.0265e-01, 2.6487e-01, 8.7427e-01,
         6.3931e-01, 9.2185e-01, 1.8814e-01, 4.6688e-01],
        [9.3432e-01, 6.3559e-01, 8.5197e-01, 3.2361e-01, 2.0056e-01, 9.2445e-01,
         2.2350e-01, 5.8269e-01, 8.3440e-01, 6.6469e-02],
        [5.6964e-01, 2.2937e-01, 2.0973e-01, 1.2911e-01, 8.2727e-01, 1.5506e-01,
         4.5108e-01, 5.3088e-01, 4.7621e-02, 8.6652e-01],
        [8.2846e-01, 7.8891e-01, 1.7300e-01, 8.8942e-01, 8.6031e-02, 8.6696e-01,
         7.5673e-01, 9.5832e-01, 7.1232e-01, 6.4838e-04],
        [6.0151e-01, 5.5573e-01, 8.8099e-01, 5.4313e-01, 4.8009e-01, 4.9952e-01,
         8.4308e-01, 6.0059e-02, 7.7979e-01, 8.1841e-01],
        [3.5385e-01, 8.4562e-01, 6.6722e-01, 8.6063e-01, 4.5924e-01, 3.0050e-01,
         7.8364e-01, 8.7273e-01, 6.4574e-01, 4.5296e-01],
        [2.9081e-01, 1.9456e-01, 7.4062e-01, 4.6530e-01, 1.5013e-01, 1.4595e-01,
         2.7953e-01, 1.4313e-01, 6.1942e-01, 7.0994e-01],
        [4.6606e-01, 4.2371e-01, 8.6644e-01, 9.2781e-01, 7.9696e-01, 1.9017e-01,
         6.8353e-02, 9.0217e-01, 5.1970e-01, 2.1213e-01],
        [1.8870e-01, 4.3505e-01, 9.7652e-01, 9.6948e-01, 8.3129e-01, 2.8473e-01,
         8.9527e-01, 2.7648e-01, 8.3105e-01, 7.3924e-01],
        [4.9153e-01, 6.1254e-01, 8.4064e-01, 3.6957e-01, 3.9874e-01, 8.1734e-02,
         5.4617e-01, 5.0426e-01, 8.0616e-01, 5.5730e-01],
        [1.1220e-01, 5.9337e-01, 5.5275e-01, 3.7697e-01, 7.0846e-01, 8.7905e-02,
         4.3779e-02, 9.2227e-01, 2.5081e-01, 9.7404e-02],
        [7.7806e-01, 1.7218e-01, 2.5968e-01, 8.5514e-01, 2.8270e-01, 2.8551e-01,
         8.9627e-01, 8.6489e-01, 3.4114e-01, 2.4419e-01],
        [5.2629e-01, 4.1494e-01, 4.0478e-01, 8.4493e-01, 8.1986e-01, 5.0504e-01,
         5.1902e-01, 5.4134e-01, 3.3008e-01, 1.2345e-01],
        [7.1760e-01, 9.4789e-01, 2.4671e-02, 5.8957e-01, 7.1790e-01, 9.7698e-02,
         9.5448e-02, 2.6961e-02, 5.9844e-01, 3.2093e-01],
        [5.0963e-01, 3.1826e-01, 1.5183e-01, 9.2145e-01, 7.3766e-01, 3.2501e-01,
         9.5764e-01, 1.9023e-01, 3.4118e-04, 1.4548e-01],
        [5.1828e-01, 6.0104e-02, 6.9069e-02, 3.2410e-01, 7.0291e-01, 5.5621e-01,
         7.7059e-02, 1.6506e-01, 7.8744e-01, 6.4652e-01],
        [6.0191e-01, 4.2128e-01, 3.7009e-01, 1.9005e-01, 2.8042e-01, 7.6023e-02,
         8.4108e-01, 6.8998e-01, 9.4244e-02, 2.9001e-01],
        [7.4080e-01, 9.3798e-01, 3.5967e-01, 3.0795e-01, 7.2310e-01, 6.8691e-02,
         9.4789e-01, 3.0437e-01, 1.4640e-01, 3.0191e-01],
        [9.0145e-02, 9.6858e-01, 2.8762e-01, 2.7806e-01, 1.5026e-01, 8.2724e-01,
         9.2107e-01, 6.7317e-01, 3.8515e-01, 1.4702e-01],
        [6.8593e-01, 8.4820e-02, 6.7524e-01, 2.0206e-01, 8.7099e-01, 4.8546e-03,
         4.6318e-01, 5.7283e-01, 3.3211e-01, 9.3403e-01],
        [2.9909e-01, 5.2113e-01, 2.8686e-01, 4.7439e-01, 2.9226e-02, 7.4341e-02,
         6.8179e-01, 2.6745e-01, 5.1926e-01, 7.6659e-01]])      

fig = plt.figure()
ax1 = fig.add_subplot(121)
# Bilinear interpolation - this will look blurry
#
#'nearest' interpolation - faithful but blocky
plt.imshow(tensor,cmap='spring',)      
 
plt.show()









/code]

[OSWALD]

24.05.2025

Bildverarbeitung mit Convolution
Ich wage den Einstieg und schaue wie weit ich komme.
In Python.Scipy werden die Themen Signal- u. Bildverarbeitung hervorragend erklärt.
TensorFlow und Torch etc. sind zwar mächtiger ,erfordern jedoch spezielle technische Ausrüstung.
Hinweis: "Zitronenfalter falten keine Zitronen und 'Faltungen' falten keine Matrizen"

Die Faltung ist eine sehr scwierige mathematische Operation(Integrale),
die zwei Funktionen zu einer neuen Funktion kombiniert,
indem sie eine Funktion (oder Matrix ) über die andere "gleiten" (Überlagerung)lässt
und die Ergebnisse summiert. (das "Input")

Die Faltung, auch bekannt als Kernel-basierte Filterung, ist ein mathematischer Operator,
der in der Signalverarbeitung und
in der digitalen Bildverarbeitung weit verbreitet ist.
Kernel ist eine variable Matrix mit markiertem Mittelpunkt.
Filter sind Matrizen mit unterschiedlichem Inhalt, je nach Bedarf.
'Faltung' dient dazu, zwei Funktionen zu kombinieren, um eine dritte Funktion zu erzeugen.
In der Bildverarbeitung werden Faltungsfilter (Kernels) eingesetzt,
um Effekte wie Weichzeichnen, Schärfen, Prägen, oder Kantenerkennung zu erzielen.

Zunächst einige einfache Beispiele
Gute Zeit ODSWALD

Code: Alles auswählen

#             convolve1d  (1.Matrix und 2.Vektor)
from scipy.ndimage import  convolve1d
print(convolve1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 7 , 5]))

[OSWALD]

24.5.2025
Das war zunächst die Funktion, aber nur mit einer Liste und Vektor
und macht noch wenig Sinn.
Nun folgt eine eine 2x4 Matrix und wir erhalten
einen Tensor als Ergebnis der Convolution 1d.
Mit imshow können wir das erste Bild darstellen.
Und aus den erhaltenen Daten und der nächsten Convolution 1d
das nächste Bild usw.
Allerdings, müssen wir von Hand jeweils die Kommata setzen.
Mit torch werden bei einem analogen Code die Kommata automatisch
gesetzt, was bei großen Matrizen auch notwendig ist.
Nun kommt Convolution 2d
OSWALD

Code: Alles auswählen

#             convolve1d  (Matrix und Vektor)
from scipy.ndimage import  convolve1d
#print(convolve1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 7 , 5]))
print(convolve1d([[2, 8, 0, 4],[ 1, 9, 9, 0]] ,weights=[1, 7 , 5]))

[OSWALD]

24.5.2025
Beispiel Convolution 2d .
Dazu die Daten Kernel und der neu erstellten
8x8 Matrix.
Anschließend mit imshow das Bild dieser Matrix.
Hier musste ich 'händisch' die Kommata einsetzen.
OSWALD

Code: Alles auswählen

#       CONVOLUTION  2D
import numpy as np                                                  
from scipy.signal  import convolve2d                                            
import image
image = np.random.rand(8, 8)        
padded_image = np.pad(image, (2, 2))                                                                          
kernel = np.random.rand(5, 5)                                                                                 
print(" Die Daten des  5x5- kernel    =: ",kernel)
print()
assert (convolve2d(image, kernel, mode="same") == convolve2d(padded_image, kernel, mode="valid")).all()
print("Deten  der 8x8  Matrix(Ergebnis)  = : ",(convolve2d(image, kernel, mode="same")))

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

#Hier die in Convolution 2d gezeigte  8x8 Matrix

import matplotlib.pyplot as plt

matrix =  [[2.52682633 ,2.51153483 ,3.58721357 ,3.60527332 ,1.9963239,  2.70350048,
  2.24092487, 2.20638676],
 [3.11934416, 3.83848352 ,4.32719142 ,4.7077301 , 3.69729516 ,5.1126075,
  4.1442479 , 3.21570947],
 [3.36454916 ,4.19786977 ,5.62666577, 5.69259946 ,5.42566727,6.45376037,
  5.26728892, 3.5165384 ],
 [3.7723844 , 3.95411701, 6.19408344 ,6.31125584 ,6.54346455 ,6.09336596,
  4.82881118, 3.92561314],
 [3.49830453, 3.78541149 ,6.03139468, 6.35047502, 6.63366227, 6.65949458,
  4.96860167 ,4.00392249],
 [3.6232779  ,4.23531179, 6.05949193,6.6808968 , 6.10714375, 6.34749422,
  5.19072966 ,3.04274917],
 [3.11141003, 3.37001308, 4.58267795 ,5.53244073 ,4.85868024, 3.59224558,
  3.5353882 , 1.98266293],
 [2.22775129 ,2.49933268 ,3.25702938 ,3.45179497 ,3.48058226 ,2.79058751,
  2.14153537, 1.41015545]]
# Figure und Axes erstellen
leinwand, diagramm = plt.subplots()

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

# Diagramm anzeigen
plt.show()

/code]

[OSWALD]

l24.5.2025
An diesem Beispiel kann man die erworbenen
Kenntnisse bereits etwas messen.
Ein Problem kann auftauchen, wenn man
versucht Beispiele aus dem Netz für Testzwecke zu laden.
Originalbilder zur Analyse herunter zu laden ist
oft nicht möglich, bzw. nicht legal.
Gute Zeit OSWALD

Code: Alles auswählen

#     PYTHONCONVOLUTIONVISUAL
import numpy as np
from scipy import signal
from scipy import datasets
ascent = datasets.ascent()
scharr = np.array([[ -3-3j, 0-10j,  +3 -3j],
                   [-10+0j, 0+ 0j, +10 +0j],
                   [ -3+3j, 0+10j,  +3 +3j]]) # Gx + j*Gy

grad = signal.convolve2d(ascent, scharr, boundary='symm', mode='same')
print(grad)

import matplotlib.pyplot as plt
fig, (ax_orig, ax_mag, ax_ang) = plt.subplots(3, 1, figsize=(6, 15))
ax_orig.imshow(ascent, cmap='gray')
ax_orig.set_title('Original')
ax_orig.set_axis_off()
ax_mag.imshow(np.absolute(grad), cmap='gray')
ax_mag.set_title('Gradient magnitude')
ax_mag.set_axis_off()
ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles
ax_ang.set_title('Gradient orientation')
ax_ang.set_axis_off()
fig.show()