Das deutsche Python-Forum

Code: Alles auswählen

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

#                                  [A]  x  [B]  = 5 x 3  /  3x3  Matrix   = C  
#                                  [B]   x [A]     nicht möglich                        
#        

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 =  [[ 4 ,8  ,3],                                 
             [ 6,7,-3]  ,                               
             [ 1,2,9]  ,                               
             [ 3, 4, 8 ]  ,                               
             [ 9, 2 ,6]]                                
                                                   
   B =  [[ 7 ,3,6] ,                             
            [ 9 , 6  ,1],
            [ 6 , 4 , 4]]                                             
     
    # Print the result of matrix multiplication
     
   print ("C = A * B     :     ",   matrix_multiplication(A, B))

Code: Alles auswählen

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

#                                   
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 =  [[ 4 ,8  ,3,2],                                 
             [ 6,7,-3,4]  ,                               
             [ 1,2,9,3]  ,                               
             [ 3, 4, 8,7 ]  ,                               
             [ 9, 2 ,6,-3]]                                
                                                   
   B =  [[ 7 ,3,6,5]]                       
                                                   
             
    # Print the result of matrix multiplication
     
   print ("C = A * B     :     ",   matrix_multiplication(A, B))

Code: Alles auswählen

# Vektoren mit Matrix  multiplizieren


# 3x2 matrix
X = [ [3,2],[3,4],[4,5] ]
# 
Y = [ [1],
        [3],
       [ 1]]                                     

# resultant matrix
resultant = [[sum(a*b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

# printing matrix.
for x in resultant:
   print(x)

Code: Alles auswählen

 #  Die Division von Matrizen ist nicht definiert.
 #   Wurde eine Matrize mit einem Skalar multipliziert. dann
 #   ist dieses  Produkt     dem gleichen Skalar  wieder teilbar.
 #  Allerdings entstehen als Ergebnis dann Dezimal-Brüche.
 #  Skalare sind reine Zahlen ..Vektoren sind  gerichtete Größen-


 # 3x2 Matrix als  Skalar-Produkt    
X = [ [3,2],[3,4],[4,5] ]
Y = [ [1],
      [ 3]]                                     
 
resultant = [[sum(a * b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

# printing matrix.
for x in resultant:
   print("Ergebnis sind Vektoren" ,                   x)

######### 
print()
######### 
# Jetzt  MatrVektor durch   Skalar  t e i l e n
X = [ [3,2],[3,4],[4,5] ]
Y = [[1],
       [3]]
        

resultant = [[sum(a / b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]
for x in resultant:
    print("Als Ergebnis  enstehen Dezimalbrüche"  , x)

Code: Alles auswählen

#                                Multiplikation von   zwei    6 x 6  Matritzen  
#                    Wie viele 'händische  Rechenschritte '  wären   zur Lösung    notwendig ?  
#                                Wie hoch wäre der zeitliche Aufwand ?                

X = [[ 1,3,2,7,9,7],
        [ 2,1,3,5,5,1],
        [ 3,1,1,2,6,4],
        [ 1,0,3,1,2,5],
        [4,1,4,1,1,6],
        [1,1,2,4,2,4]]

Y = [[1,3,0,7,9,1],
        [ 2,1,3,5,5,2],
        [ 3,1,1,2,6,2],
        [ 1,0,3,1,2,5],
        [4,1,4,1,1,6],
        [2,4,1,2,4,2]]                     
 
resultant = [[sum(a  *  b for a,b in zip(X_row,Y_col)) for Y_col in zip(*Y)] for X_row in X]

# printing matrix.
for x in resultant:
   print("Könnte dieses Ergebnis  korrekt sein ???     " , x)

Code: Alles auswählen

  
Tensoren
sind der Überbegriff von Vektoren und Matrizen
und umfassen im  Machine Learning Bereich mehrdimensionale Arrays.
Je nachdem, welche Dimensionalität das Array besitzt, unterscheidet man verschiedene Arten:

Skalar
Der Skalar, also eine einzelne Zahl, ist ein   0-dimensionaler Tensor.
Es wird kein einziger Index benötigt, um auf eine Zahl zu referenzieren.
Der Skalar hat also keine Achsen und somit auch den Rang 0.   also  'tensor 0'

Vektor
Der Vektor ist ein 1-dimensionaler Tensor und hat den       Rang 1.      'tensor 1'
Je nachdem wie viele Elemente der Vektor besitzt,
ändert sich die Länge der Achsen entsprechend.



Matrix
Wie wir bereits ausführlich beschrieben haben, ist die Matrix ein 2-dimensionaler Tensor.

Tensor
Ab drei oder mehr Dimensionen spricht man tatsächlich auch von Tensoren.
Einen Tensor mit drei Dimensionen kann man sich als eine Ansammlung von Matrizen vorstellen.

Skalare sind einzelne Zahlen.
Vektoren sind 1D-Spalten von Zahlen.
Matrizen sind 2D-Gitter von Zahlen.

Tensoren
sind allgemeiner.
Sie können 1D, 2D, 3D oder wirklich alles sein.
Tensor-Komponenten könnten eine beliebige Anzahl von Indizes benötigen.
Wir indizieren oft Komponenten eines Vektors mit 0, 1, 2 usw., um klarzustellen,
über welchen  Tensor  wir sprechen.

Matrizen
Um dasselbe für Matrizen zu tun, müssen wir jeder Komponente zwei Indizes geben
(einen für die Zeile und einen für die Spalte).

Code: Alles auswählen

import numpy as np 
  
# zwei Matrizen erzeugen
p = [[1, 2], [2, 3], [4, 5]] 
q = [[4, 5, 1], [6, 7, 2]]  
print("Matrix p :") 
print(p) 
print("Matrix q :") 
print(q) 
  

result = np.dot(p, q) 
  
# printing the result 
print(" Das Resultat  :",result) 

Code: Alles auswählen

 
######TensorSKALARPPRODUKT
import numpy as np
a = np.arange(60.).reshape(3,4,5)
print(a)
b = np.arange(24.).reshape(4,3,2)
print(b)
c = np.tensordot(a,b, axes=([1,0],[0,1]))

c.shape
(5, 2)
print("Hier ist das Tensor-Skalarprodukt"  ,c)
#array([[4400., 4730.],
#       [4532., 4874.],
#       [4664., 5018.],
#       [4796., 5162.],
#       [4928., 5306.]])
# A slower but equivalent way of computing the same...
d = np.zeros((5,2))
for i in range(5):
  for j in range(2):
    for k in range(3):
      for n in range(4):
        d[i,j] += a[k,n,i] * b[n,k,j]
c == d

Code: Alles auswählen

#Matrixmulti  einmal mit Li-cmprehension iund mit Schleifen
matrix1 = [[12,7,3],
        [4 ,5,6],
        [7 ,8,9]]
matrix2 = [[5,8,1],
        [6,7,3],
        [4,5,9]]

res = [[0 for x in range(3)] for y in range(3)] 

# explicit for loops
for i in range(len(matrix1)):
    for j in range(len(matrix2[0])):
        for k in range(len(matrix2)):

            # resulted matrix
            res[i][j] += matrix1[i][k] * matrix2[k][j]

Code: Alles auswählen

import matplotlib.pyplot as plt
import numpy as np

# Matrix auswählen u. erstellen
# Feststellen, ob eine Matrix vorliegt

#                                Keine Matrizen  sondern verschachtelte Listen
#matrix = [[58, 64], [139, 154]]              #   keine Matrix
#matrix  = [[1],                                        #   keine Matrix( Vektor)
 #               [ 3],   
  #              [11]] 
#matrix =     [[1],[3],[11]]                            #   verschachtelte Liste  


#matrix  = 2*np.diag(range(14) )
#matrix  =  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#matrix =  [[ 4 ,3,2],                                 
#            [ 6,7,4]  ,                               
#            [ 1,2,-3]  ,                               
#           [ 3, 4, 7 ]  ,                               
  #         [ 9, 2 ,6]]                                
#matrix = [[ 1,3,2,7,9,255],
               # [ 3,1,1,255,7,3],
               # [ 1,0,255,2,5,6],
              #  [4,255,4,1,1,6],
               # [255,4,2,4,2,1]]

#matrix  = [[1,3,0,7,9,1],
             #  [ 2,1,3,5,5,2],
            #  [ 3,1,1,2,6,2],
             #  [ 1,0,3,1,2,5],
            #   [4,1,4,1,1,6],
             #  [2,4,1,2,4,2]]                     
                                 

 #matrix = [
#    [1,0],
#    [0,1],
#]m

# 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: Alles auswählen

##  Mit zwei Farbbalken alle Farbpletten (2) darstellen
import matplotlib.pyplot as plt 
import numpy as np 
from numpy.ma import masked_array 
  
# Bild ereugen  mit = 10x10  Numpy-array 
img = np.random.randint(-100, 100, (10, 10)) 
# Matrix darstellen   
print("Das ist die aus dem Numpy.Array  erzeugte 10x10 - Matrix :"  ,img)
# masked array to positive and negative values 
neg_img = masked_array(img, img >= 0) 
pos_img = masked_array(img, img < 0) 
  
# make plot 
fig, ax = plt.subplots() 
  
# show image 
shw1 = ax.imshow(neg_img, cmap=plt.cm.Reds) 
shw2 = ax.imshow(pos_img, cmap=plt.cm.Blues)                       # swinter) 
  
# make color-bars 
bar1 = plt.colorbar(shw1) 
bar2 = plt.colorbar(shw2) 
  
# show plot with labels 
plt.xlabel('X Label') 
plt.ylabel('Y Label') 
bar1.set_label('ColorBar 1') 
bar2.set_label('ColorBar 2') 
plt.show()

Code: Alles auswählen

                                 Matrizen, Transpose und Achsen vertauschen
import numpy as np
data = np.arange(16)
print(data)      #dies ist  keine Liste sondern ein Tupel
#array( 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15)

reshaped_data = data.reshape((4, 4)) # hier die Veränderung in  einen Tensor  
print(reshaped_data)
print()
[[ 8,  9, 10, 11],
[12, 13, 14, 15]]
print()
#  Der Tensor  wird jetzt transoniert,also Vertauschung der Achsen
reshaped_data.T     
print(reshaped_data.T)
print()
 
print("Erstes Skalarprodukt   : transponierter Tensor mit  Skalar") 
np.dot(reshaped_data.T, reshaped_data)
print(np.dot(reshaped_data.T, reshaped_data))
#array([[224, 248, 272, 296],
#       [248, 276, 304, 332],
#       [272, 304, 336, 368],
 #      [296, 332, 368, 404]])
print("Der @ Infix-Operator ist eine weitere Möglichkeit, eine Matrixmultiplikation durchzuführen.")
print("@    ist  eine Abkürzung von    np.matmul.")

print(data.T @ data)
1240
#Bei höherdimensionalen Arrays akzeptiert transpose ein Tupel von Achsennummern,
#um die Achsen zu vertauschen:

array_3d = np.arange(16).reshape((2, 2, 4))
print(array_3d)
#array([[[ 0,  1,  2,  3],
#        [ 4,  5,  6,  7]],

  #     [[ 8,  9, 10, 11],
   #     [12, 13, 14, 15]]])
array_3d.transpose((1, 0, 2))
#array([[[ 0,  1,  2,  3],
   #     [ 8,  9, 10, 11]],
 #      [[ 4,  5,  6,  7],
#        [12, 13, 14, 15]]])

#Hier wurden die Achsen neu geordnet, wobei die zweite Achse an erster Stelle steht,
#die erste Achse an zweiter Stelle und die letzte Achse unverändert bleibt.

#ndarray verfügt auch über eine Methode swapaxes,
#die ein Paar von Achsennummern nimmt und die angegebenen Achsen vertauscht,
#um die Daten neu anzuordnen:

array_3d.swapaxes(1, 2)
#        [ 1,  5],
#        [ 2,  6],
#
 #      [[ 8, 12],
 #       [ 9, 13],
 #       [10, 14],
#        [11, 15]]])

Code: Alles auswählen

# Funktion definieren
def f(x):
    #return  x**2 + np.random.normal(0, 0.1, len(x))  # Sinusfunktion mit Rauschen
     # return  - x**3  +2*exp(-sin(x) ) - np.random.normal(0, 0.4, len(x))  # Sinusfunktion mit Rauschen
     return     x**2  +5  *np.sin(4*x)  - np.random.normal(0, 0.1, len(x))  # Sinusfunktion mit Rauschen


# x-Werte generieren
x_values = np.linspace(-1, 1, 100)
y_values = f(x_values)

# Interpolationsfunktion erstellen
interp_func = interp1d(x_values, y_values, kind='linear')

# Feinere x-Werte für die Suche nach Nullstellen
fine_x_values = np.linspace(-1 , 1, 100)
fine_y_values = interp_func(fine_x_values)

# Nullstellen finden durch Überprüfen des Vorzeichenwechsels
nullstellen_x = fine_x_values[np.where(np.diff(np.sign(fine_y_values)))[0]]
nullstellen_y = [0] * len(nullstellen_x)

# Positive Spitzenwerte zwischen den Nullstellen finden
pos_spitzenwerte_x = []
pos_spitzenwerte_y = []
for i in range(len(nullstellen_x) - 1):
    segment_x = fine_x_values[(fine_x_values >= nullstellen_x[i]) & (fine_x_values <= nullstellen_x[i+1])]
    segment_y = fine_y_values[(fine_x_values >= nullstellen_x[i]) & (fine_x_values <= nullstellen_x[i+1])]
    if np.any(segment_y > 0):
        peak_idx, _ = find_peaks(segment_y)
        if peak_idx.size > 0:
            max_peak = peak_idx[np.argmax(segment_y[peak_idx])]
            pos_spitzenwerte_x.append(segment_x[max_peak])
            pos_spitzenwerte_y.append(segment_y[max_peak])

# Höchsten positiven Spitzenwert finden
if pos_spitzenwerte_y:
    highest_idx = np.argmax(pos_spitzenwerte_y)
    highest_peak_x = pos_spitzenwerte_x[highest_idx]

    # Gesuchte Nullstelle finden
    nulldurchgang_von_neg_nach_pos = nullstellen_x[nullstellen_x < highest_peak_x]
    if nulldurchgang_von_neg_nach_pos.size > 0:
        gesuchte_nullstelle_x = nulldurchgang_von_neg_nach_pos[-1]
        print("x-Koordinate der gesuchten Nullstelle:", gesuchte_nullstelle_x)

# Koordinaten aller Nullstellen und positiven Spitzenwerte ausgeben
print("Koordinaten aller Nullstellen:", list(zip(nullstellen_x, nullstellen_y)))
print("Koordinaten der positiven Spitzenwerte:", list(zip(pos_spitzenwerte_x, pos_spitzenwerte_y)))

# Plotten der Kurve
plt.figure(figsize=(10, 6))
plt.plot(x_values, y_values, label='Verrauschte Sinusfunktion')
plt.scatter(nullstellen_x, nullstellen_y, color='red', label='Nullstellen')
plt.scatter(pos_spitzenwerte_x, pos_spitzenwerte_y, color='green', label='Positive Spitzenwerte')
if pos_spitzenwerte_y:
    plt.scatter(highest_peak_x, pos_spitzenwerte_y[highest_idx], color='purple', label='Höchster Spitzenwert')
plt.title('Verrauschte Sinusfunktion mit Nullstellen und Spitzenwerten')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.grid(True)
plt.legend()
plt.show()