kleine Mathe-Spielereien

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

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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
User
Beiträge: 547
Registriert: Freitag 18. März 2022, 17:32

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



Antworten