fixed uebung 3

uebungen/aufgabe3/uebung3.py

@@ -6,43 +6,37 @@ import matplotlib.pyplot as plt
 def load_data():
     df_orig_train = pd.read_csv('uebungen/aufgabe3/mnist.csv')
     df_digits = df_orig_train.drop('label', axis=1)
-
     return df_digits.to_numpy()
 
-
 mnist = load_data()
 
-
 def sigmoid(x):
     return 1.0 / (1.0 + np.exp(-x))  # Sigmoidfunktion
 
-
 class RBM:
 
-    def __init__(self, visible_size: int, hidden_size: int, learnrate: float = 0.1, epochs: int = 20):
+    def __init__(self, visible_size: int, hidden_size: int, learnrate: float = 0.1):
         """__init__ Initialisiere der RBM.
 
         Args:
             visible_size (int): anzahl neuronen sichtbare schicht
             hidden_size (int): anzahl neuronen sichtbare schicht
             learnrate (float, optional): learnrate eta in [0;1]. Default als 0.1.
-            epochs (int, optional): training epochs. Defaults als 20.
         """
         self.learnrate = learnrate
         self.visible_size = visible_size
         self.hidden_size = hidden_size
-        self.epochs = epochs
 
         # Initialisieren lernbarer Attribute
-        self.weights = np.random.randn(self.visible_size, self.hidden_size)
-        self.visible_bias = np.zeros(self.visible_size) * 0.1
-        self.hidden_bias = np.zeros(self.hidden_size) * 0.1
+        self.weights = np.random.normal(0, 0.01, (self.visible_size, self.hidden_size))
+        self.visible_bias = np.zeros(self.visible_size)
+        self.hidden_bias = np.zeros(self.hidden_size)
 
     def activate(self, v0):
-        return sigmoid(np.matmul(v0.T, self.weights) + self.hidden_bias)
+        return sigmoid(np.dot(v0, self.weights) + self.hidden_bias)
 
     def reactivate(self, h0):
-        return sigmoid(np.matmul(self.weights, h0.T) + self.visible_bias)
+        return sigmoid(np.dot(self.weights, h0) + self.visible_bias)
 
     def contrastive_divergence(self, v0, h0, v1, h1):
         # Gradient
@@ -57,18 +51,17 @@ class RBM:
         self.hidden_bias += self.learnrate * (h0 - h1)
 
     def train(self, v0):
-        for _ in range(self.epochs):
-            # versteckte schichten aktivieren
-            h0 = self.activate(v0)
+        # versteckte schichten aktivieren
+        h0 = self.activate(v0)
 
-            # Reaktivieren sichtbarer Schichten
-            v1 = self.reactivate(h0)
+        # Reaktivieren sichtbarer Schichten
+        v1 = self.reactivate(h0)
 
-            # Aktivieren nächster versteckter Schicht
-            h1 = self.activate(v1)
+        # Aktivieren nächster versteckter Schicht
+        h1 = self.activate(v1)
 
-            # Gewichte anpassen
-            self.contrastive_divergence(v0, h0, v1, h1)
+        # Gewichte anpassen
+        self.contrastive_divergence(v0, h0, v1, h1)
 
     def run(self, v0):
         # Aktivieren der Schichten
@@ -77,13 +70,16 @@ class RBM:
 
         return h0, v1
 
+training_epochs = 20
+rbm = RBM(28 ** 2, 100, 0.02)
 
-rbm = RBM(28 ** 2, 100, 0.2, epochs=2)
-
-for i in range(100, 600):
-    # Normalisieren der mnist daten und trainieren
-    number = mnist[i] / 255
-    rbm.train(number)
+for epoch in range(training_epochs):
+    np.random.shuffle(mnist)
+    for i in range(100, 600): # 500 mnist zahlen zwischen 100 und 600 
+        number = mnist[i] / 255
+        rbm.train(number)
+    if (epoch + 1) % 5 == 0:
+        print(f"Epoch {epoch+1}/{training_epochs} completed.")
 
 # Ergebnisse plotten
 rows, columns = (9, 9)