kleine Mathe-Spielereien

[OSWALD]

Immer noch auf das Suche nach verwertbaren synthetischen Daten
habe ich einmal Torch in einer eine MonteCarlo- Simulation verwendet .
Die erhaltenen Tensoren enthalten immer die notwenigen Kommata für eine
direkte Weiterverarbeitung.
Das ist bei numpy-arrays nicht der Fall.
Anbei der direkte Vergleich .

Gute Zeit OSWALD

Code: Alles auswählen

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

# Beispiel  mit TORCH   ergibt  direkt auswertbare  Daten  hier mit  1000 simulierten Endwerten
# plus  zusätzlicher Erweiterung der Datenmengen 

simulation_results = torch.randn(1000) * 10 + 50 # Beispiel-Daten
print("In diesem Tensor  sind die  Einzelwerte  durch Kommata getrennt : " )  
print("und deshalb für eine Weiterverarbeitung direkt verwendbar            : " , simulation_results)

# Tensor in NumPy-Array konvertieren
results_np = simulation_results.numpy()   
print("Nach  der Transformation  in einen numpy-array ")
print("ist das (ohne Kommata ) nicht mehr möglich :" , results_np)

# Histogramm plotten
plt.hist(results_np, bins=50, color='skyblue', edgecolor='black')
plt.title('Monte-Carlo-Simulation: Verteilung der Ergebnisse')
plt.xlabel('Wert')
plt.ylabel('Häufigkeit')
plt.axvline(np.mean(results_np), color='r', linestyle='--', label=f'Mittelwert: {np.mean(results_np):.2f}')
plt.legend()
plt.show()

[OSWALD]

20.11.2025
Nach dieser Pseudo-Simulation ein weiteres
Beispiel zur synthetischen Datengewinnung.
OSWALD

Code: Alles auswählen

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

# Anzahl der Datenpunkte
n_samples = 100

# Feature (x) generieren: Zufällige Werte
# Wir verwenden torch.randn für eine Normalverteilung
x = torch.randn(n_samples, 3) * 10
print(x)
# Rauschen generieren
noise = torch.randn(n_samples, 1) * 2

# Target (y) generieren: y = 2*x + 5 + Rauschen (lineare Beziehung)
y = 2 * x + 5 + noise

# Visualisierung (optional)
# plt.scatter(x.numpy(), y.numpy())
# plt.xlabel("X")
# plt.ylabel("Y")
# plt.title("Synthetische Daten mit PyTorch")
# plt.show()

[OSWALD]

20.11.2025
torch bietet zahlreiche Möglichkeiten
zur Generierung von verwertbaren synth. Daten
in beliebiger Menge. ein Beispiel
OSWALD

Code: Alles auswählen

import torch

torch.manual_seed(42) # Setzt den Seed für den CPU-Zufallszahlengenerator
matrix_a = torch.rand(4, 4,2)

torch.manual_seed(42)
matrix_b = torch.rand(6, 6,3)

print("Matrix A (mit Seed 42):\n", matrix_a)
print("Matrix B (mit demselben Seed 42):\n", matrix_b)
# matrix_a und matrix_b werden identisch sein

/code]

[OSWALD]

21.11.2025
hier noch eine Auswahl zur Gewnerierung von Zufallsdaten mit torch
OSWALD

Code: Alles auswählen

import torch
# Create a 6x8 tensor with random values between 0 and 1
random_list = torch.rand(6,3 , 8)
print(random_list)


import torch
# Create a 2x2 tensor with random values from a normal distribution
normal_tensor = torch.randn(5, 5)
print(normal_tensor)

import torch
# Create a 4x3 tensor with random integers between 0 and 10
integer_tensor = torch.randint(0, 10, (6, 4))
print(integer_tensor)


import torch
# Set the random seed
torch.manual_seed(42)
# Create a 2x3 tensor with random values
seeded_tensor = torch.rand(5, 5)
print(seeded_tensor)

[OSWALD]

21.11.2025
Hier ist etwas Geduld gefragt.
Mit jedem Start ein neues Bild, solange der Vorrat reicht.
Alles imSub-Bereich von Ki und mit torch.
ODSWAD

Code: Alles auswählen

#              Mit  jedem Start  einn neues Bild  
#              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()
print("Das ist der Tensor   :",image_np)
print("shape          :  ",image_np.shape)
print("Size             :  ", image_np.size)  
# Display the image
plt.imshow(image_np)
#plt.axis('off')  # Turn off axis labels
plt.show()

[OSWALD]

23.11.2025
Als dreht sich heute nur noch um KI.
Auf jede meiner Fragen im Net erhalte ich
(unter Google) sofort eine Antwort von einer KI.
Ich möchte aber wissen , was ich bis heute von Python
helernt habe.
Deshalb habe ich mir ein schwieriges Programm gesucht,
um meinen tatsächlichen Wissensstand zu kontrollieren.
Ich habe aufgegeben nach dem 'Stein der Weisen (KI)
zu suchen und 'wende mich wieder allein Python zu.'.

OSWALD

Code: Alles auswählen

Doppler-Effekt: Synchrone Audio- und Videoausgabe.

# In diesem Programm wird nicht nur die Bewegung von Quelle und
       #Beobachter animiert dargestellt, sondern auch die Ausbreitung der
#Wellenzüge.


import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.animation
import sounddevice

# Simulationsdauer [s] und Abtastrate [1/s].
t_max = 32.0
abtastrate = 44100
# Frequenz, mit der die Quelle Schallwellen aussendet [Hz].
f_Q = 300.0
# Frequenz, mit der die dargestellten Wellenzüge ausgesendet
# werden [Hz].
f_Q_graph = 1.0
# Ausbreitungsgeschwindigkeit der Welle [m/s].
c = 20.0
# Lege die Startposition der Quelle und des Beobachters fest [m].
startort_Q = np.array([-150.0, 5.0])
startort_B = np.array([0.0, -5.0])
# Lege die Geschwindigkeit von Quelle und Beobachter fest [m/s].
v_Q = np.array([10.0, 0.0])
v_B = np.array([0.0, 0.0])
# Dargestellter Koordinatenbereich [m].
plotbereich_x = (-160, 160)
plotbereich_y = (-30, 30)


def signal_quelle(t):
    """Ausgesendetes Signal als Funktion der Zeit."""
    signal = np.sin(2 * np.pi * f_Q * t)
    signal[t < 0] = 0.0
    return signal


# Erzeuge ein Array von Zeitpunkten und lege ein leeres Array
# für das vom Beobachter empfangene Signal an.
t = np.arange(0, t_max, 1 / abtastrate)
signal_beob = np.zeros(t.size)

# Berechne für jeden Zeitpunkt die Positionen von Quelle und
# Beobachter.
r_Q = startort_Q + v_Q * t.reshape(-1, 1)
r_B = startort_B + v_B * t.reshape(-1, 1)

# Berechne für jeden Zeitpunkt t, zu dem der Beobachter ein
# Signal auffängt, die Zeitdauer dt, die das Signal
# von der Quelle benötigt hat. Dazu ist eine quadratische
# Gleichung der Form
#             dt² - 2 a dt - b = 0
# mit den unten definierten Größen a und b zu lösen.
r = r_B - r_Q
a = np.sum(v_Q * r, axis=1) / (c ** 2 - v_Q @ v_Q)
b = np.sum(r ** 2, axis=1) / (c ** 2 - v_Q @ v_Q)

# Berechne für jeden Zeitpunkt die beiden Lösungen der
# quadratischen Gleichung.
dt1 = a + np.sqrt(a ** 2 + b)
dt2 = a - np.sqrt(a ** 2 + b)

# Berücksichtige das Signal der positiven Lösungen.
# Beachte, dass die Amplitude mit 1/r abfällt.
idx1 = dt1 > 0
abstand = c * dt1[idx1]
signal_beob[idx1] = signal_quelle(t[idx1] - dt1[idx1]) / abstand

idx2 = dt2 > 0
abstand = c * dt2[idx2]
signal_beob[idx2] += signal_quelle(t[idx2] - dt2[idx2]) / abstand

# Normiere das Signal auf den Wertebereich -1 ... +1.
if np.max(np.abs(signal_beob)) > 0:
    signal_beob = signal_beob / np.max(np.abs(signal_beob))

# Erzeuge eine Figure und eine Axes.
fig = plt.figure(figsize=(12, 6))
fig.set_tight_layout(True)
ax = fig.add_subplot(1, 1, 1)
ax.grid()
ax.set_xlim(plotbereich_x)
ax.set_ylim(plotbereich_y)
ax.set_aspect('equal')
ax.set_xlabel('$x$ [m]')
ax.set_ylabel('$y$ [m]')

# Erzeuge zwei Kreise für Quelle und Beobachter.
kreis_quelle = mpl.patches.Circle((0, 0), radius=1.5,
                                  visible=False, color='black',
                                  fill=True, zorder=4)
ax.add_patch(kreis_quelle)
kreis_beobachter = mpl.patches.Circle((0, 0), radius=1.5,
                                      visible=False, color='blue',
                                      fill=True, zorder=4)
ax.add_patch(kreis_beobachter)

# Lege eine Liste an, die die kreisförmigen Wellenzüge speichert.
kreise = []

# Startindex für die nächste Audioausgabe.
audio_index = 0


def audio_callback(outdata, frames, time, status):
    """Stelle neue Audiodaten zur Ausgabe bereit."""
    global audio_index

    # Gib im Fehlerfall eine Fehlermeldung aus.
    if status:
        print(status)

    # Extrahiere den benötigten Ausschnitt aus den Daten. Durch
    # das Slicing kann es passieren, dass 'audiodaten' weniger
    # Datenpunkte als die Anzahl der 'frames' enthält.
    audiodaten = signal_beob[audio_index: audio_index + frames]

    # Schreibe die Daten in das Ausgabe-Array.
    outdata[:audiodaten.size, 0] = audiodaten

    # Fülle das Ausgabe-Array ggf. mit Nullen auf.
    outdata[audiodaten.size:, 0] = 0.0

    # Erhöhe den Index um die Anzahl der verwendeten Datenpunkte.
    audio_index += audiodaten.size


def update(n):
    """Aktualisiere die Grafik zum n-ten Zeitschritt."""
    # Ignoriere den von der Animation übergebenen Bildindex n und
    # verwende stattdessen den Index, der sich aus der
    # Audioausgabe ergibt, sodass Audio- und Videoausgabe synchron
    # erfolgen.
    n = min(audio_index, t.size - 1)

    # Aktualisiere die Positionen von Quelle und Beobachter.
    kreis_quelle.center = r_Q[n]
    kreis_beobachter.center = r_B[n]
    kreis_quelle.set_visible(True)
    kreis_beobachter.set_visible(True)

    # Erzeuge zum Startzeitpunkt einen neuen Kreis oder wenn
    # seit dem Aussenden des letzten Wellenzuges mehr als eine
    # Periodendauer vergangen ist.
    if not kreise or t[n] >= kreise[-1].startzeit + 1 / f_Q_graph:
        kreis = mpl.patches.Circle(kreis_quelle.center, radius=0,
                                   color='red', linewidth=1.5,
                                   fill=False, zorder=3)
        kreis.startzeit = t[n]
        kreise.append(kreis)
        ax.add_patch(kreis)

    # Aktualisiere die Radien aller dargestellten Kreise.
    for kreis in kreise:
        kreis.radius = (t[n] - kreis.startzeit) * c

    # Färbe den Beobachter rot, wenn ein Wellenzug auftrifft.
    kreis_beobachter.set_color('blue')
    for kreis in kreise:
        d = np.linalg.norm(kreis.center - kreis_beobachter.center)
        if abs(d - kreis.radius) < kreis_beobachter.radius:
            kreis_beobachter.set_color('red')

    # Färbe die Quelle rot, wenn ein Wellenzug ausgesendet wird.
    d = np.linalg.norm(kreise[-1].center - kreis_quelle.center)
    if abs(d - kreise[-1].radius) < kreis_quelle.radius:
        kreis_quelle.set_color('red')
    else:
        kreis_quelle.set_color('black')

    return kreise + [kreis_quelle, kreis_beobachter]


# Erzeuge einen Ausgabestrom für die Audioausgabe.
stream = sounddevice.OutputStream(abtastrate, channels=1,
                                  callback=audio_callback)

# Erzeuge die Animation.
ani = mpl.animation.FuncAnimation(fig, update,
                                  interval=30, blit=True)

# Starte die Audioausgabe und die Animation.
with stream:
    plt.show(block=True)

[OSWALD]

2q4.11.2025
In Ergänzung zu den obigen Beispielen mit Torch.
Vom Zufallsgenerator für synth.Daten zu
Tensoren und zur bitmap ---> 'Bild'
Datenmege nach oben ..... hardware
Gute Zeit OSWALD

Code: Alles auswählen

#  1.                              Erzeugung von Zufalls-Matrizen  und Tensoren
#  2.                              Erstellung einer  Bitmap  aus  Tensoren
import torch 
x = torch.rand((6,8, 3 ))   #    Matrix (hier   2D  und Farbe    -> Bild)
print(x)

 
#################################
import matplotlib.pyplot as plt
import numpy as np 
from bitmap import BitMap
tensor  = ([[[0.2752, 0.2771, 0.2272],
         [0.0216, 0.8198, 0.7874],
         [0.1280, 0.9265, 0.3432],
         [0.1446, 0.2345, 0.7920],
         [0.8068, 0.3140, 0.9211],
         [0.0259, 0.0333, 0.3102],
         [0.1606, 0.8945, 0.3264],
         [0.0832, 0.6151, 0.8872]],

        [[0.6397, 0.0602, 0.7886],
         [0.5545, 0.7710, 0.5090],
         [0.3861, 0.1520, 0.1537],
         [0.7465, 0.0316, 0.7108],
         [0.9825, 0.8839, 0.6118],
         [0.7419, 0.0893, 0.9006],
         [0.0721, 0.5595, 0.8934],
         [0.2904, 0.1725, 0.3220]],

        [[0.2637, 0.6273, 0.3890],
         [0.9703, 0.6399, 0.8096],
         [0.0013, 0.2654, 0.3301],
         [0.2378, 0.4126, 0.4720],
         [0.9360, 0.6645, 0.7847],
         [0.0470, 0.4570, 0.7433],
         [0.4580, 0.9922, 0.9418],
         [0.2662, 0.8459, 0.6025]],

        [[0.1408, 0.0032, 0.7725],
         [0.0298, 0.5469, 0.7878],
         [0.7678, 0.3125, 0.1460],
         [0.0501, 0.4877, 0.9303],
         [0.8927, 0.6384, 0.7855],
         [0.0932, 0.2247, 0.9271],
         [0.5782, 0.0564, 0.2795],
         [0.8985, 0.5049, 0.2210]],

        [[0.9450, 0.2706, 0.7669],
         [0.5578, 0.5603, 0.5820],
         [0.3710, 0.8383, 0.7674],
         [0.2861, 0.4116, 0.8847],
         [0.4335, 0.1761, 0.5212],
         [0.1821, 0.3320, 0.7835],
         [0.2771, 0.0595, 0.2235],
         [0.5497, 0.5970, 0.0776]],

        [[0.1234, 0.9276, 0.6487],
         [0.2229, 0.2746, 0.5632],
         [0.6341, 0.1391, 0.6137],
         [0.2288, 0.8777, 0.2009],
         [0.2771, 0.5167, 0.9786],
         [0.0094, 0.8415, 0.7888],
         [0.5392, 0.0812, 0.9291],
         [0.9139, 0.0344, 0.0937]]]) 
plt.imshow(tensor)
plt.colorbar()
plt.show()

[OSWALD]

24.11.2025
der neu erzeugte Tensor muss natürlich a
jedes Mal usgetauscht werden
OSWALD

[OSWALD]

26.11.25
mit 8 GB RAM sind 30x30 BitMaps mit Tensoren
in Torch nicht mehr darstellbar.

Deshalb werde ich meinen PC mit
2 mal 16 GB aufpeppen.
für windows 10 scheint mir das der beste Weg zu sein
OSWALD
S innvoll?

[__blackjack__]

Ausgehen von einer 30×30 Bitmap mit sagen wir mal vier Kanälen (RGBA) und 8 Byte pro Wert (Gleitkommazahlen), also 28,800 Bytes, ist es sehr sinnvoll 32 GiB RAM zu installieren wenn man das in 8 GiB nicht mehr untergebracht bekommt.

[OSWALD]

@_blackjack
Leider ist daraus bis jetzt nichts geworden.
bei Mediamarkt online angeblich vorrätig, vor vOrt heute
wegen Knappheit nicht lleferbar. Preis 3 mal höher als vor.her
Jetzt neuer Versuch bei anderem Händler.
Oder warten bis .....C.
OSWALD