Das deutsche Python-Forum

Code: Alles auswählen

   py -m pip uninstall      SomePackage

Code: Alles auswählen

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

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)

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]

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

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)
 

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)

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

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

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

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

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