From 571c5e03f4bec68708d1514e2754157a250593eb Mon Sep 17 00:00:00 2001 From: romanamo Date: Mon, 20 May 2024 15:22:55 +0200 Subject: [PATCH] abgabe ready --- uebungen/aufgabe3/uebung3.py | 47 ++++++++++++++++++++---------------- 1 file changed, 26 insertions(+), 21 deletions(-) diff --git a/uebungen/aufgabe3/uebung3.py b/uebungen/aufgabe3/uebung3.py index 8535ec8..e00592a 100644 --- a/uebungen/aufgabe3/uebung3.py +++ b/uebungen/aufgabe3/uebung3.py @@ -20,58 +20,61 @@ def sigmoid(x): class RBM: def __init__(self, visible_size: int, hidden_size: int, learnrate: float = 0.1, epochs: int = 20): - """__init__ Initializes a newly created Restricted Bolzmann Machine. + """__init__ Initialisiere der RBM. Args: - visible_size (int): amount of neurons inside the visible layer - hidden_size (int): amount of neurons inside the hidden layer - learnrate (float, optional): learnrate eta in [0;1]. Defaults to 0.1. - epochs (int, optional): training epochs. Defaults to 20. + 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 - # initialize/reset learnable attributes + # 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 def activate(self, v0): - return sigmoid(np.matmul(v0.T, self.weights) + self.hidden_bias) + return self.sample(sigmoid(np.matmul(v0.T, self.weights) + self.hidden_bias)) def reactivate(self, h0): - return sigmoid(np.matmul(self.weights, h0.T) + self.visible_bias) + return self.sample(sigmoid(np.matmul(self.weights, h0.T) + self.visible_bias)) + + def sample(self, a): + return np.where(a > np.random.uniform(0, 1, a.shape), 1, 0) def contrastive_divergence(self, v0, h0, v1, h1): - # calculate gradients + # Gradient postive_gradient = np.outer(v0, h0) - negative_gradient = np.outer(v1, h0) + negative_gradient = np.outer(v1, h1) - # Adjust weights by delta + # Gewichte per delta anpassen self.weights += self.learnrate * (postive_gradient - negative_gradient) - # Adjust biases by delta + # Biases per delta anpassen self.visible_bias += self.learnrate * (v0 - v1) self.hidden_bias += self.learnrate * (h0 - h1) def train(self, v0): for _ in range(self.epochs): - # activate hidden layer + # versteckte schichten aktivieren h0 = self.activate(v0) - # reactivate visible layer + # Reaktivieren sichtbarer Schichten v1 = self.reactivate(h0) - # activate next hidden layer + # Aktivieren nächster versteckter Schicht h1 = self.activate(v1) - # Adjust weights + # Gewichte anpassen self.contrastive_divergence(v0, h0, v1, h1) def run(self, v0): - # activate hidden layer + # Aktivieren der Schichten h0 = self.activate(v0) v1 = self.reactivate(h0) @@ -81,22 +84,24 @@ class RBM: rbm = RBM(28 ** 2, 100, 0.2, epochs=2) for i in range(100, 600): - # normalize mnist data and train + # Normalisieren der mnist daten und trainieren number = mnist[i] / 255 rbm.train(number) -# plot results +# Ergebnisse plotten rows, columns = (9, 9) fig = plt.figure(figsize=(10, 7)) -fig.canvas.manager.set_window_title("Reconstruction of MNIST Numbers using a Restricted Boltzmann Machine") +fig.canvas.manager.set_window_title( + "Rekonstruktion des MNIST Datensatzes mit einer Restricted Boltzmann Machine") for i in range((rows * columns)): if i % 3 == 0: number = mnist[i] / 255 (hidden, visible) = rbm.run(number) - results = [hidden.reshape((10, 10)), visible.reshape((28, 28)), number.reshape((28, 28))] + results = [hidden.reshape((10, 10)), visible.reshape( + (28, 28)), number.reshape((28, 28))] for j, item in enumerate(results): fig.add_subplot(rows, columns, i + j + 1)