kleine Mathe-Spielereien

[OSWALD]

26.8.2024
Leider musste ich meinen PV zurücksetzen.
Inkompatible Namensräume bereinigen.
Module und Pakete neu erstellen
OSWALD

[OSWALD]

26.8.2024
Die Problematik mit den 'Abhängigkeiten wird hier beschgrieben:
ohttps://blog.german-smartbrain.com/python-dependency-management.html#python-abhangigkeiten-verstehen
Gute Zeit OSWALD

[OSWALD]

27.8.2024
Ein Versuch Pakete zu löschen.
'Abhängigkeiten' wirklich zu beseitigen.
Mit folgendem Code auf Windows Power Shell.
Ausgehend davon , dass Tensorflow und torch tatsächlich Pakete und nicht nur Module sind,
konnte ich beide sowohl löschen als auch neu installieren.
Wie gesagt ein Versuch. Kann das bestätigt werden ?
gute Zeit OSWALD

Code: Alles auswählen

   py -m pip uninstall      SomePackage

[Dennis89]

Ja, siehe hier:
https://pip.pypa.io/en/stable/cli/pip_uninstall/

Windows nutzt soweit ich weis `py`als alias für `python`.

Grüße
Dennis

[OSWALD]

27.8.2024
Tatsächlich konnte ich viele Programme zum Laufen bringen
die ich vorher nicht vollenden konnte, weil wie z.B
hier nur auf 'Halde' lagen, weil 'statsmodels' nicht gefunden wurde.
Zuerst habe ich das Packet gelöscht . Meldung nicht vorhanden.
Dann installiert. Meldung satisfied.
Dann hat es auch geklappt.
Manhmal geht die Installation eben anders als erwartet.

Hier das kleine Programmbeispiel
OSWALD

Code: Alles auswählen

py- -m pip   uninstall   statsmodels
python -m pip install statsmodels

[__blackjack__]

Wenn das nicht deinstalliert werden konnte weil es nicht vorhanden war, dann hätte auch einfach installieren gereicht.

[OSWALD]

8.9.2024
Seitdem mir Microsoft ein großes Werbeschild von Samsung (HDTV,SERIESPIPMOVIEHAMI
auf meinen Bildschirm gesetzt hat, lklappt
bei mir gar nichts mehr.
Das Plakat versperrt die Sicht , alle Versuche zur Beseitigung schlagen fehl.
Ich kann meine PC nicht mehr korrekt bedienen.
Das Internet ikst voll mit beschwerden und guten Ratschlägen.
OSWALD

[Dennis89]

Ich verstehe zwar das Problem nicht, aber ich habe eine Lösung: Nutze doch Linux

[OSWALD]

10.9.2024
Problem Werbeplakat von Samsung beseitigt.
Lösung:
Werbung und mein Monitor sind von Samsung. !!
Windows Oberfläche ist lediglich das Objekt.

Ursache liegt im Samsung Monitor. Von dort wird Werbung gesteuert.


Fernbedienung :
Drücken auf Tools.
Auf Bildmodus -> Standard
Löschen SRS-TS -HD
Löschen E -Pop Hier ist der Sünder !
Weg ist das Plakat
Da mein Monitor nur für den PC verwendet wird ,
können zur Sicherheit auch noch weitere <Modi Bedarf gelöscht werden.
Gute Zeit OSWALD
(Nur wer stetig sich bemüht, den können wir erlösen (Faust II)

[OSWALD]

Ich versuche jetzt, mich über ' NUMPY-Arrays als kleinem Datensatz ' dem
Thema Neurales Netzwerk mit mehreren Codes zu nähern.
ich versuche also immer größere numpy.Arrays als Datensatz auszuprobieren.
in diesem eifachen Fall kann ich u.a. durch Veränderung von Argumenten
die Größe des Fehlers in Abhängigkeit von der Zahl de rEpochen nachvollziehen.
Jetzt kann ich also wieder ungehindert zu spielen.
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np

# Eingabedaten
X = np.array([[0, 0, 1],
              [0, 1, 1],
              [1, 0, 1],
              [1, 1, 1]])

print(X)
# Erwartete Ausgabedaten
y = np.array([[0],
              [1],
              [1],
              [0]])
 
print(y)
# Anzahl der Eingabe- und Ausgabeneuronen
input_neurons = X.shape[1]
output_neurons = y.shape[1]

# Anzahl der Neuronen in der versteckten Schicht
hidden_neurons = 10


# Definition der Aktivierungsfunktion (Sigmoid)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Definition der Ableitung der Aktivierungsfunktion (Sigmoid)
def sigmoid_derivative(x):
    return x * (1 - x)

weights_input_hidden = np.random.rand(input_neurons, hidden_neurons)
# Gewichte zwischen versteckter Schicht und Ausgabe
weights_hidden_output = np.random.rand(hidden_neurons, output_neurons)

# Anzahl der Epochen für das Training
epochs = 5

# Trainingschleife
for epoch in range(epochs):
    # Vorwärtspropagation (Forward Propagation)
    hidden_layer_input = np.dot(X, weights_input_hidden)
    hidden_layer_output = sigmoid(hidden_layer_input)
    output = sigmoid(np.dot(hidden_layer_output, weights_hidden_output))
    
    # Berechnung des Fehlers (Error)
    error = y - output
    print("Fehler :",y-output)
    # Rückwärtspropagation (Backpropagation) und Gewichtsanpassung
    d_weights_hidden_output = np.dot(hidden_layer_output.T, error * sigmoid_derivative(output))
    d_weights_input_hidden = np.dot(X.T, np.dot(error * sigmoid_derivative(output), weights_hidden_output.T) * sigmoid_derivative(hidden_layer_output))
    
    weights_hidden_output += d_weights_hidden_output
    weights_input_hidden += d_weights_input_hidden

# Ausgabe der finalen Vorhersage
print(output)

[OSWALD]

14.9.2024
An diesem Beispiel kann man erkennen, dass im Zusammenhang mit Tensorflow
zusammen Probleme mit dser Darstellung auftreten. GPU fehlt.
Jetzt werde ich versuchen den Code ohne Tensorflow vollständig in Gang zu bringen.
OSWALD

Code: Alles auswählen

import tensorflow as tf
import numpy as np 


# Beispieltrainingsdaten und -labels
train_features = np.array([[1,1], [1, 2], [2, 0], [2, 2]], dtype=np.float64)
train_labels = np.array([[1], [2], [2], [1]], dtype=np.float64)
 

# Erstellen eines TensorFlow-Datensatzes
train_dataset = tf.data.Dataset.from_tensor_slices((train_features, train_labels))
train_dataset = train_dataset.shuffle(buffer_size=4).batch(2)    


# Neuronales Netzwerk erstellen
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(2,)),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])  

# Modell kompilieren
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])        

# Modell trainieren
model.fit(train_dataset, epochs=20)
# Beispieltestdaten

test_features = np.array([[1,1], [1, 2], [2, 1], [2, 2]], dtype=np.float32)


# Vorhersagen treffen
predictions = model.predict(test_features)


# Ausgabe der Vorhersagen
print(predictions)  
/code]

[OSWALD]

15.9.2024
Perzeptron , wichtiger Bestandteil von neuronalen Netzwerken.

Das Perzeptron ist ein mathematisches Modell eines künstlichen neuronalen Netzwerks. Es besteht in der einfachsten Form aus einem Neuron, dessen Ausgangsfunktion durch die Gewichtung der Eingänge und durch Schwellwerte bestimmt wird. Ein Perzeptron kann für maschinelles Lernen und Anwendungen der Künstlichen Intelligenz (KI) eingesetzt werden.

Hier ein Beispiel , indem die Trennungf von Daten vom Perzeptron (=Ausgangs-Neuron)
ausgegeben wird.
Gute Zeit OSWALD

Code: Alles auswählen

mport numpy as np
from collections import Counter

class Perceptron:
    
    def __init__(self, 
                 weights,
                 bias=1,
                 learning_rate=0.3):
        """
        'weights' kann ein Numpy-Array, eine Liste oder ein 
        Tupel mit den Werten der Gewichte. Die Anzahl der Eingabewerte
         ist indirekt durch die Länge von 'weights' definiert 
        """
        self.weights = np.array(weights)
        self.bias = bias
        self.learning_rate = learning_rate
        
    @staticmethod
    def unit_step_function(x):
        if  x <= 0:
            return 0
        else:
            return 1
        
    def __call__(self, in_data):
        in_data = np.concatenate( (in_data, [self.bias]) )
        result = self.weights @ in_data
        return Perceptron.unit_step_function(result)
    
    def adjust(self, 
               target_result, 
               in_data):
        if type(in_data) != np.ndarray:
            in_data = np.array(in_data)  # 
        calculated_result = self(in_data)
        error = target_result - calculated_result
        if error != 0:
            in_data = np.concatenate( (in_data, [self.bias]) )
            correction = error * in_data * self.learning_rate
            self.weights += correction
            
    def evaluate(self, data, labels):
        evaluation = Counter()
        for sample, label in zip(data, labels):
            result = self(sample) # predict
            if result == label:
                evaluation["correct"] += 1
            else:
                evaluation["wrong"] += 1
           
                
        return evaluation
        print("Hallo")

################################################
from sklearn.datasets import make_blobs

n_samples = 250
samples, labels = make_blobs(n_samples=n_samples, 
                             centers=([2.5, 3], [6.7, 7.9]), 
                             random_state=0)
########Wir werden nun die vorher erzeugten Daten visualisieren:

 
import matplotlib.pyplot as plt

colours = ('green', 'magenta', 'blue', 'cyan', 'yellow', 'red')
fig, ax = plt.subplots()


for n_class in range(2):
    ax.scatter(samples[labels==n_class][:, 0], samples[labels==n_class][:, 1], 
               c=colours[n_class], s=40, label=str(n_class))
#einfaches_neuronales_netz 5: Graph 4
 
n_learn_data = int(n_samples * 0.8) # 80 % of available data points
learn_data, test_data = samples[:n_learn_data], samples[-n_learn_data:]
learn_labels, test_labels = labels[:n_learn_data], labels[-n_learn_data:]

 
p = Perceptron(weights=[1., 2., 1.],
               learning_rate=0.8)

for sample, label in zip(learn_data, learn_labels):
    p.adjust(label,
             sample)

evaluation = p.evaluate(learn_data, learn_labels)
print(evaluation)
Counter({'correct': 200})
#Nun wollen wir auch die Trennlinie darstellen:

 
import matplotlib.pyplot as plt


fig, ax = plt.subplots()

# plotting learn data
colours = ('green', 'blue')
for n_class in range(2):
    ax.scatter(learn_data[learn_labels==n_class][:, 0], 
               learn_data[learn_labels==n_class][:, 1], 
               c=colours[n_class], s=40, label=str(n_class))
    
# plotting test data
colours = ('lightgreen', 'lightblue')
for n_class in range(2):
    ax.scatter(test_data[test_labels==n_class][:, 0], 
               test_data[test_labels==n_class][:, 1], 
               c=colours[n_class], s=40, label=str(n_class))


    
X = np.arange(np.max(samples[:,0]))
m = -p.weights[0] / p.weights[1]
c = -p.weights[2] / p.weights[1]
print(m, c)
ax.plot(X, m * X + c )
plt.plot()
plt.show()
 
 

[OSWALD]

15.9.2024
Hier habe ich in einem bereits oben gezeigten Beispiel
die Zahlendie Datenmenge stark verändert ,
ohne Kenntnis des zu erwarteten Ergebnisses.
Mein Ziel ist nun, bekannte große Matrizen als Datenquelle
auszutesten. Mal sehen.
OSWALD

Code: Alles auswählen

import numpy as np

# Eingabedaten
X = np.array([[3, 4, 5],
              [1, 3, 2],
              [3, 2, 1],
              [1, 2, 3]])

# Erwartete Ausgabedaten
y = np.array([[0],
              [4],
              [3],
              [5]])

# Anzahl der Eingabe- und Ausgabeneuronen
input_neurons = X.shape[1]
output_neurons = y.shape[1]

# Anzahl der Neuronen in der versteckten Schicht
hidden_neurons =16
# Definition der Aktivierungsfunktion (Sigmoid)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
# Definition der Ableitung der Aktivierungsfunktion (Sigmoid)
def sigmoid_derivative(x):
    return x * (1 - x)
weights_input_hidden = np.random.rand(input_neurons, hidden_neurons)
# Gewichte zwischen versteckter Schicht und Ausgabe
weights_hidden_output = np.random.rand(hidden_neurons, output_neurons)

# Anzahl der Epochen für das Training
epochs = 10

# Trainingschleife
for epoch in range(epochs):
    # Vorwärtspropagation (Forward Propagation)
    hidden_layer_input = np.dot(X, weights_input_hidden)
    hidden_layer_output = sigmoid(hidden_layer_input)
    output = sigmoid(np.dot(hidden_layer_output, weights_hidden_output))
    print(output)
    # Berechnung des Fehlers (Error)
    error = y - output
    print("Fehler                        ",error)
    # Rückwärtspropagation (Backpropagation) und Gewichtsanpassung
    d_weights_hidden_output = np.dot(hidden_layer_output.T, error * sigmoid_derivative(output))
    d_weights_input_hidden = np.dot(X.T, np.dot(error * sigmoid_derivative(output), weights_hidden_output.T) * sigmoid_derivative(hidden_layer_output))
    
    weights_hidden_output += d_weights_hidden_output
    weights_input_hidden += d_weights_input_hidden

# Ausgabe der finalen Vorhersage
print(output)
 

[OSWALD]

15.9.2024
Ein erster Versuch Bitmap-Matrizen
als Datenquelle für Neuronale Netze zu verwenden.
Zum Schluss des Codes wird das Bitmap selbst dargestellt.
Zusätzlich habe ich die im Ablauf auftretenden Zahlen
dargestellt, um mehr Einblick in die Materie zu kriegen.
Gute Zeit OSWALD

Code: Alles auswählen

mport matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation
from bitmap import *
fig, ax = plt.subplots()


# Eingabedaten
mydata = np.array(
   [[2.5, 2.5, 2.5, 2.5],
    [2.5, 3.5, 3.5 ,2.5],
    [2.5 ,3.5 ,3.5, 2.5 ],
    [2.5,2.5, 2.5 , 2.5]])

y = np.array([[3, 4, 5],
             [1, 3, 2],
             [2, 3, 1],
            [1, 2, 3]])

# Erwartete Ausgabedaten
#y = np.array([[0],
 #             [4],
 #             [3],
    #          [5]])

# Anzahl der Eingabe- und Ausgabeneuronen
input_neurons = mydata.shape[1]
output_neurons = y.shape[1]

# Anzahl der Neuronen in der versteckten Schicht
hidden_neurons = 1
# Definition der Aktivierungsfunktion (Sigmoid)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
# Definition der Ableitung der Aktivierungsfunktion (Sigmoid)
def sigmoid_derivative(x):
    return x * (1 - x)
weights_input_hidden = np.random.rand(input_neurons, hidden_neurons)
# Gewichte zwischen versteckter Schicht und Ausgabe
weights_hidden_output = np.random.rand(hidden_neurons, output_neurons)

# Anzahl der Epochen für das Training
epochs = 1

# Trainingschleife
for epoch in range(epochs):
    # Vorwärtspropagation (Forward Propagation)
    hidden_layer_input = np.dot(mydata, weights_input_hidden)
    hidden_layer_output = sigmoid(hidden_layer_input)
    output = sigmoid(np.dot(hidden_layer_output, weights_hidden_output))
    print(output)
    # Berechnung des Fehlers (Error)
    error = y - output
     # Rückwärtspropagation (Backpropagation) und Gewichtsanpassung
    d_weights_hidden_output = np.dot(hidden_layer_output.T, error * sigmoid_derivative(output))
    d_weights_input_hidden = np.dot(mydata.T, np.dot(error * sigmoid_derivative(output), weights_hidden_output.T) * sigmoid_derivative(hidden_layer_output))

print(" Ableitung  hidden output  ",   d_weights_hidden_output)
print(" Ableitung  hidden  input   ",   d_weights_input_hidden)
print()
weights_hidden_output += d_weights_hidden_output
weights_input_hidden += d_weights_input_hidden
print("Gewichtung  hidden utput   ", d_weights_hidden_output)
print("Gewichtung   input_hidden      ",  d_weights_input_hidden   )                         
print()

print(                                "Ausgabe der finalen Vorhersage")
print( weights_hidden_output)
print ( weights_input_hidden )
print()
plt.imshow(mydata)
plt.colorbar()
plt.title("Bitmap  als Datensatz für Neuronal-Netz  und  Anzeigen der Bitmap")
plt.show()
 
#Anzahl der Bits einsetzen 8,26,32 ,64,128  und   beide  Zahlen-Formate  anzeigen
  
bm = BitMap(16)
print( bm.tostring())
bm.set(0)
print( bm.tostring())

bm = BitMap.fromstring( "00011101")
print( bm.tostring())
bm.flip(1)

[OSWALD]

16.9.2024
Hier ein Projekt, das ich im Internet gefunden habe.
Es geht um Matrixapproximation mit Core-APIs

Hier werden die Low-Level-APIs von TensorFlow Core,
um die Fähigkeiten von TensorFlow als leistungsstarke wissenschaftliche Computerplattform
zu demonstrieren.
Hier eine Core-API,
um mehr über TensorFlow Core und seine vorgesehenen Anwendungsfälle zu erfahren.

Das lineare Algebra-Paket von TensorFlow verfügt über eine Funktion, --tf.linalg.svd--
mit der die Singulärwertzerlegung einer oder mehrerer Matrizen berechnet werden kann.
Beginnen Sie mit der Definition einer einfachen Matrix
und der Berechnung ihrer SVD-Faktorisierung.


Ich zeige hier dieses sehr komplizierte Beispiel , um zu zeigen dass
Tensorflow zusammen mit Matrizen als Datensätze auch auf einer CPU
ohne weiteres läuft.
(Eventuell müssen noch einige wenige Module geladen werden,
damit der Code überall läuft)

Gute Zeit OSWALD

Code: Alles auswählen

mport matplotlib
from matplotlib.image import imread
from matplotlib import pyplot as plt
import requests
# Preset Matplotlib figure sizes.
matplotlib.rcParams['figure.figsize'] = [10, 9]

import tensorflow as tf
print("Tensorflow Version:  ",tf.__version__)

A = tf.random.uniform(shape=[40,30])
# Compute the SVD factorization
s, U, V = tf.linalg.svd(A)
# Define Sigma and V Transpose
S = tf.linalg.diag(s)
V_T = tf.transpose(V)
# Reconstruct the original matrix
A_svd = U@S@V_T
# Visualize 
plt.bar(range(len(s)), s);
plt.xlabel("Singular value rank")
plt.ylabel("Singular value")
plt.title("Bar graph of singular values");


A_svd = tf.einsum('s,us,vs -> uv',s,U,V)
print('\nReconstructed Matrix, A_svd', A_svd)

#Reconst 
def rank_r_approx(s, U, V, r, verbose=False):
  # Compute the matrices necessary for a rank-r approximation
  s_r, U_r, V_r = s[..., :r], U[..., :, :r], V[..., :, :r] # ... implies any number of extra batch axes
  # Compute the low-rank approximation and its size
  A_r = tf.einsum('...s,...us,...vs->...uv',s_r,U_r,V_r)
  A_r_size = tf.size(U_r) + tf.size(s_r) + tf.size(V_r)
  if verbose:
    print(f"Approximation Size: {A_r_size}")
  return A_r, A_r_size

def viz_approx(A, A_r):
  # Plot A, A_r, and A - A_r
  vmin, vmax = 0, tf.reduce_max(A)
  fig, ax = plt.subplots(1,3)
  mats = [A, A_r, abs(A - A_r)]
  titles = ['Original A', 'Approximated A_r', 'Error |A - A_r|']
  for i, (mat, title) in enumerate(zip(mats, titles)):
    ax[i].pcolormesh(mat, vmin=vmin, vmax=vmax)
    ax[i].set_title(title)
    ax[i].axis('off')
   # plt.show()
def rank_r_approx(s, U, V, r, verbose=False):
  # Compute the matrices necessary for a rank-r approximation
  s_r, U_r, V_r = s[..., :r], U[..., :, :r], V[..., :, :r] # ... implies any number of extra batch axes
  # Compute the low-rank approximation and its size
  A_r = tf.einsum('...s,...us,...vs->...uv',s_r,U_r,V_r)
  A_r_size = tf.size(U_r) + tf.size(s_r) + tf.size(V_r)
  if verbose:
    print(f"Approximation Size: {A_r_size}")
  return A_r, A_r_size

def viz_approx(A, A_r):
  # Plot A, A_r, and A - A_r
  vmin, vmax = 0, tf.reduce_max(A)
  fig, ax = plt.subplots(1,3)
  mats = [A, A_r, abs(A - A_r)]
  titles = ['Original A', 'Approximated A_r', 'Error |A - A_r|']
  for i, (mat, title) in enumerate(zip(mats, titles)):
    ax[i].pcolormesh(mat, vmin=vmin, vmax=vmax)
    ax[i].set_title(title)
    ax[i].axis('off')

print(f"Original Size of A: {tf.size(A)}")
s, U, V = tf.linalg.svd(A)

#Original Size of A: 1200

A_15, A_15_size = rank_r_approx(s, U, V, 15, verbose = True)
viz_approx(A, A_15)

#Approximation Size: 1065
#png


# Rank-3 approximation
A_3, A_3_size = rank_r_approx(s, U, V, 3, verbose = True)
viz_approx(A, A_3)
img_link = "https://imagen.research.google/main_gallery_images/a-photo-of-a-corgi-dog-riding-a-bike-in-times-square.jpg"
img_path = requests.get(img_link, stream=True).raw
I = imread(img_path, 0)
print("Input Image Shape:", I.shape)

#Input Image Shape: (1024, 1024, 3)
 
def show_img(I):
  # Display the image in matplotlib
  img = plt.imshow(I)
  plt.axis('off')
  return

show_img(I)
plt.show()

def compress_image(I, r, verbose=False):
  # Compress an image with the SVD given a rank 
  I_size = tf.size(I)
  print(f"Original size of image: {I_size}")
  # Compute SVD of image
  I = tf.convert_to_tensor(I)/255
  I_batched = tf.transpose(I, [2, 0, 1]) # einops.rearrange(I, 'h w c -> c h w')
  s, U, V = tf.linalg.svd(I_batched)
  # Compute low-rank approximation of image across each RGB channel
  I_r, I_r_size = rank_r_approx(s, U, V, r)
  I_r = tf.transpose(I_r, [1, 2, 0]) # einops.rearrange(I_r, 'c h w -> h w c')
  I_r_prop = (I_r_size / I_size)
  if verbose:
    # Display compressed image and attributes
    print(f"Number of singular values used in compression: {r}")
    print(f"Compressed image size: {I_r_size}")
    print(f"Proportion of original size: {I_r_prop:.3f}")
    ax_1 = plt.subplot(1,2,1)
    show_img(tf.clip_by_value(I_r,0.,1.))
    ax_1.set_title("Approximated image")
    ax_2 = plt.subplot(1,2,2)
    show_img(tf.clip_by_value(0.5+abs(I-I_r),0.,1.))
    ax_2.set_title("Error")
  return I_r, I_r_prop

I_100, I_100_prop = compress_image(I, 100, verbose=True)

#Original size of image: 3145728
#Compressed image size: 614700
#
I_50, I_50_prop = compress_image(I, 50, verbose=True)

#Original size of image: 3145728
#Compressed image size: 307350
#
I_10, I_10_prop = compress_image(I, 10, verbose=True)

#Original size of image: 3145728
#Compressed image size: 61470
#Proportion of original size: 0.020

#

plt.figure(figsize=(11,6))
plt.plot([100, 50, 10], [I_100_prop, I_50_prop, I_10_prop])
plt.xlabel("Rank")
plt.ylabel("Proportion of original image size")
plt.title("Compression factor vs rank");

def compress_image_with_factor(I, compression_factor, verbose=False):
  # Returns a compressed image based on a desired compression factor
  m,n,o = I.shape
  r = int((compression_factor * m * n)/(m + n + 1))
  I_r, I_r_prop = compress_image(I, r, verbose=verbose)
  return I_r
#

compression_factor = 0.15
I_r_img = compress_image_with_factor(I, compression_factor, verbose=True)

#Original size of image: 3145728
#Number of singular values used in compression: 76
#Proportion of original size: 0.149

def viz_energy(I):
  # Visualize the energy captured based on rank
  # Computing SVD
  I = tf.convert_to_tensor(I)/255
  I_batched = tf.transpose(I, [2, 0, 1]) 
  s, U, V = tf.linalg.svd(I_batched)
  # Plotting average proportion across RGB channels 
  props_rgb = tf.map_fn(lambda x: tf.cumsum(x)/tf.reduce_sum(x), s)
  props_rgb_mean = tf.reduce_mean(props_rgb, axis=0)
  plt.figure(figsize=(11,6))
  plt.plot(range(len(I)), props_rgb_mean, color='k')
  plt.xlabel("Rank / singular value number")
  plt.ylabel("Cumulative proportion of singular values")
  plt.title("RGB-averaged proportion of energy captured by the first 'r' singular values")

viz_energy(I)

def compress_image_with_factor(I, compression_factor, verbose=False):
  # Returns a compressed image based on a desired compression factor
  m,n,o = I.shape
  r = int((compression_factor * m * n)/(m + n + 1))
  I_r, I_r_prop = compress_image(I, r, verbose=verbose)
  return I_r
#Compress an image to 15% of its original size.


compression_factor = 0.15
I_r_img = compress_image_with_factor(I, compression_factor, verbose=True)

#Number of singular values used in compression: 76
#Proportion of original size: 0.149

def viz_energy(I):
  # Visualize the energy captured based on rank
  # Computing SVD
  I = tf.convert_to_tensor(I)/255
  I_batched = tf.transpose(I, [2, 0, 1]) 
  s, U, V = tf.linalg.svd(I_batched)
  # Plotting average proportion across RGB channels 
  props_rgb = tf.map_fn(lambda x: tf.cumsum(x)/tf.reduce_sum(x), s)
  props_rgb_mean = tf.reduce_mean(props_rgb, axis=0)
  plt.figure(figsize=(11,6))
  plt.plot(range(len(I)), props_rgb_mean, color='k')
  plt.xlabel("Rank / singular value number")
  plt.ylabel("Cumulative proportion of singular values")
  plt.title("RGB-averaged proportion of energy captured by the first 'r' singular values")

viz_energy(I)
plt.show() 

[OSWALD]

17.9.2024
Hier ein kleines aber feines Programm.
Aus einem Bild aus dem WWW. und
dessen Matrix , Araays und das shape
werden erstellt.
Genial , schon KI mit Python ??
Gute Zeit OSWALD

Code: Alles auswählen

from PIL import Image
import numpy as np

img = Image.open("computer.jpg")

img_as_array = np.array(img)
print("Hier das gewünschte array , eine  Matrix    ",  img_as_array)

print("Hier das shape",                   (img_as_array.shape))

print("type:", img_as_array.dtype)
print("minimum:", np.amin(img_as_array))
print("maximum:", np.amax(img_as_array))

img_as_array_float = (img_as_array / 255.0).astype("float32")
print("type:", img_as_array_float.dtype)
print("minimum:", np.amin(img_as_array_float))
print("maximum:", np.amax(img_as_array_float))

from matplotlib import pyplot as plt

plt.imshow(img_as_array_float)
plt.show() 
 

[OSWALD]

18.9.2024
Der letzte Code(computer) wurde direkt vom Netz geladen
und musste deshalb von .ipynb nach .py konvertiert werden.
Das lief unter anaconda/Jupiter quasi automatisch,

Der neue Code(anemone) befindet sich stets auf der py-Ebene.
Das Bild wid demnach auf 'Bilder' und von hier aus mit dem
richtigen Pfad ins Perogramm kopiert.
Hier habe ich Matrix, shape und Array zusätzlich angezeigt .
Gute zeit OSWALD

Code: Alles auswählen

 from PIL import Image
import numpy as np

img = Image.open("C:/Users/Oswald Ruckriegel/Pictures/anemone-2396299_640.jpg   " )             
img_as_array = np.array(img)

print("type:", img_as_array.dtype)
print("minimum:", np.amin(img_as_array))
print("maximum:", np.amax(img_as_array))
print()
img_as_array_float = (img_as_array / 255.0).astype("float64")
 
print("type:", img_as_array_float.dtype)
print("minimum:", np.amin(img_as_array_float))
print("maximum:", np.amax(img_as_array_float))
print()
print("Hier die  gesuchte  ",                             img_as_array)
print()
print("Hier das shape",                        (img_as_array.shape))
print()
print(" Hierdie  ARRAY - Form",                     img_as_array_float)
print()
from matplotlib import pyplot as plt
print("Hier das shape",                   (img_as_array.shape))


plt.imshow(img_as_array_float)
plt.show() 

[OSWALD]

13.10.2024
Ich bin immer noch mit dem Thema Matrix,
speziell mit der Matrix-Multiplikation beschäftigt.
Jetzt endlich habe ich mit der Listen-Comprehension
eine Lösung für die mühevolle Rechnerei gefunden.
Das Programm besteht aus zwei Teilen.
Einmal A x B und dann B x A. Die Ergebnisse sind
natürlich unterschiedlich.Ich hoffe richtig.
Diese Ergebnisse sind für mich Anlass, mich jetzt
mit 'Listen-Verständnis" noch intensiver zu befassen.
Gute Zeit OSWALD

Code: Alles auswählen

#        Funktion  zur  Multiplikation of   2 Matrizen   /  A mit   B   bzw B  mit   A /
##        1.                 A * B 

def matrix_multiplication(A, B):
    """
    Perform matrix multiplication of matrices A and B.

    Args:
    A: First matrix (list of lists).
    B: Second matrix (list of lists).

    Returns:
    Result of matrix multiplication (list of lists).
    """
    if len(A[0]) != len(B):
        raise ValueError("Number of columns in A must equal number of rows in B")

    # Number of rows and columns in resulting matrix
    num_rows_A = len(A)
    num_cols_B = len(B[0])

    # Perform matrix multiplication using list comprehension
    result = [[sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(num_cols_B)] for i in range(num_rows_A)]

    return result

# Example usage:
if __name__ == "__main__":
    # Example matrices A and B
    A = [[1, 2, 3],
         [4, 5, 6]]

    B = [[7, 8],
         [9, 10],
         [11, 12]]

    # Print the result of matrix multiplication
    print("Ergebnis  aus    A x B  :",  matrix_multiplication(A, B))

#######################       2.            B *  A                                          ##########

 
def matrix_multiplication(B,A):
     
    if len(B[0]) != len(A):
        raise ValueError("Number of columns in A must equal number of rows in B")

    # Number of rows and columns in resulting matrix
    num_rows_A = len(B)
    num_cols_B = len(A[0])

    # Perform matrix multiplication using list comprehension
    result = [[sum(B[i][k] * A[k][j] for k in range(len(B))) for j in range(num_cols_B)] for i in range(num_rows_A)]

    return result

# Example usage:
if __name__ == "__main__":
    # Example matrices A and B
    B = [[1, 2, 3],
         [4, 5, 6]] 


    A = [[7, 8],
         [9, 10],
         [11, 12]]



     
    # Print the result of matrix multiplication
    print("Ergebnis  aus    B x A  : ",matrix_multiplication(B, A))

[grubenfox]

Das Programm besteht aus zwei Teilen.
Einmal A x B und dann B x A. Die Ergebnisse sind
natürlich unterschiedlich.Ich hoffe richtig.

und wenn man dabei solange A und B vertauscht bis allen schwindlig ist, dann ist ein Ergebnis auch gleich falsch.
Multipliziert man eine (2*3)-Matrix A mit einer (3*2)-Matrix B, dann ist das Ergebnis eine (2x2)-Matrix.
Aber multipliziert man eine (3*2)-Matrix B mit einer (2*3)-Matrix A, dann erhält man eine (3x3)-Matrix.

Die Ergebnismatrix hat dann die Zeilenzahl der ersten und die Spaltenzahl der zweiten Matrix.

Zitat von https://de.wikipedia.org/wiki/Matrizenmultiplikation

[OSWALD]

17.10.2024
Der Fehler wurde erkannt.
An Grubenfuchs herzlichen Dank für den wertvollen Hinweis auf
meine Fehler.
Es handelt sich um irrtümliche Veränderung in der Syntax
Die 3x2 bzw 2x3 Matrizen-Multiplikation erlaubt die BxA Multiplikation
der Matrizen im vorliegenden Fall.
die beiden neuen Programme wurden mit neuen Zahlen
ausgeführt und die Ergebnisse sollten korrekt sein.

An Grubenfuchs herzlichen Dank für den Hinweis auf orrigierten Fall.
Als Nächstes will ich austesten, ob das vorliegende
Programm auch Matrizen mit größeren Dimensionen
richtig berechnen kann. Ich bin davon überzeugt.
Gute Zeit OSWALD

Code: Alles auswählen

##########  [A]  x  [B]  =   [ a    b]   =  C  
#                                           [ c   d ]                          
#        

def matrix_multiplication(A, B):
     
    if len(A[0]) != len(B):
        raise ValueError("Number of columns in A must equal number of rows in B")

    # Number of rows and columns in resulting matrix
    num_rows_A = len(A)
    num_cols_B = len(B[0])

    # Perform matrix multiplication using list comprehension
    result = [[sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(num_cols_B)] for i in range(num_rows_A)]

    return result

# Example usage:
if __name__ == "__main__":
    # Example matrices A and B
    A = [[1, 2, 3],
         [4, 0, 6]]

    B = [[2, 1],
         [0, 7],
         [2,-1]]

    # Print the result of matrix multiplication
     
    print ("C = A * B     :     ",   matrix_multiplication(A, B))
                                 
##########################################
 
#           [A]  x  [B]  =   [ a    b]   =  C 
#                                   [ c    d]                          
#        

def matrix_multiplication(A, B):
    
    if len(A[0]) != len(B):
        raise ValueError("Number of columns in A must equal number of rows in B")

    # Number of rows and columns in resulting matrix
    num_rows_A = len(A)
    num_cols_B = len(B[0])

    # Perform matrix multiplication using list comprehension
    result = [[sum(A[i][k] * B[k][j] for k in range(len(B))) for j in range(num_cols_B)] for i in range(num_rows_A)]

    return result

# Example usage:
if __name__ == "__main__":
    # Example matrices A and B
  
    B = [[2, 1],
         [0, 7],
         [2,-1]]


    A = [[1, 2, 3],
         [4, 0, 6]]

    # Print the result of matrix multiplication
     
    print (" B .*  A   ",   matrix_multiplication(B, A))
                                 ##########