Compare revisions

Nikolai Killer · Nikolai Killer · f6fc2126 · f6fc2126 · f6fc2126
--- a/Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb
+++ b/Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb
+%% Cell type:markdown id: tags:
+
+#0.&nbsp; Imports und Helper
+
+%% Cell type:code id: tags:
+
+``` python
+!pip install torchinfo
+!pip install matplotlib --quiet
+!pip install tqdm
+```
+
+%% Output
+
+    Defaulting to user installation because normal site-packages is not writeable
+    Requirement already satisfied: torchinfo in /home/niko/.local/lib/python3.10/site-packages (1.8.0)
+    Defaulting to user installation because normal site-packages is not writeable
+    Requirement already satisfied: tqdm in /home/niko/.local/lib/python3.10/site-packages (4.66.1)
+
+%% Cell type:code id: tags:
+
+``` python
+# Imports
+import copy
+
+import ipywidgets as widgets
+import matplotlib.pyplot as plt
+import numpy as np
+
+import time
+import torch
+import torchvision
+#import torchvision.datasets as datasets
+import torch.nn.functional as F
+import torch.nn as nn
+import torch.optim as optim
+import tqdm
+
+import random
+import keras.datasets.imdb
+
+from torch.autograd import Variable
+from tqdm.auto import tqdm as tqdmauto
+import timeit
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def set_seed(seed=None, seed_torch=True):
+  """
+  Handles variability by controlling sources of randomness
+  through set seed values
+
+  Args:
+    seed: Integer
+      Set the seed value to given integer.
+      If no seed, set seed value to random integer in the range 2^32
+    seed_torch: Bool
+      Seeds the random number generator for all devices to
+      offer some guarantees on reproducibility
+
+  Returns:
+    Nothing
+  """
+  if seed is None:
+    seed = np.random.choice(2 ** 32)
+  random.seed(seed)
+  np.random.seed(seed)
+  if seed_torch:
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.benchmark = False
+    torch.backends.cudnn.deterministic = True
+  print(f'Random seed {seed} has been set.')
+SEED = 2021
+set_seed(seed=SEED)
+DEVICE = "cuda"
+
+def zero_grad(params):
+  """
+  Clear gradients as they accumulate on successive backward calls
+
+  Args:
+    params: an iterator over tensors
+      i.e., updating the Weights and biases
+
+  Returns:
+    Nothing
+  """
+  for par in params:
+    if not(par.grad is None):
+      par.grad.data.zero_()
+
+
+def print_params(model):
+  """
+  Lists the name and current value of the model's
+  named parameters
+
+  Args:
+    model: an nn.Module inherited model
+      Represents the ML/DL model
+
+  Returns:
+    Nothing
+  """
+  for name, param in model.named_parameters():
+    if param.requires_grad:
+      print(name, param.data)
+
+def sample_minibatch(input_data, target_data, num_points=100):
+  """
+  Sample a minibatch of size num_point from the provided input-target data
+
+  Args:
+    input_data: Tensor
+      Multi-dimensional tensor containing the input data
+    target_data: Tensor
+      1D tensor containing the class labels
+    num_points: Integer
+      Number of elements to be included in minibatch with default=100
+
+  Returns:
+    batch_inputs: Tensor
+      Minibatch inputs
+    batch_targets: Tensor
+      Minibatch targets
+  """
+  # Sample a collection of IID indices from the existing data
+  batch_indices = np.random.choice(len(input_data), num_points)
+  # Use batch_indices to extract entries from the input and target data tensors
+  batch_inputs = input_data[batch_indices, :]
+  batch_targets = target_data[batch_indices]
+
+  return batch_inputs, batch_targets
+
+
+def gradient_update(loss, params, lr=1e-3):
+  """
+  Perform a gradient descent update on a given loss over a collection of parameters
+
+  Args:
+    loss: Tensor
+      A scalar tensor containing the loss through which the gradient will be computed
+    params: List of iterables
+      Collection of parameters with respect to which we compute gradients
+    lr: Float
+      Scalar specifying the learning rate or step-size for the update
+
+  Returns:
+    Nothing
+  """
+  # Clear up gradients as Pytorch automatically accumulates gradients from
+  # successive backward calls
+  zero_grad(params)
+
+  # Compute gradients on given objective
+  loss.backward()
+
+  with torch.no_grad():
+    for par in params:
+      # Here we work with the 'data' attribute of the parameter rather than the
+      # parameter itself.
+      # Hence - use the learning rate and the parameter's .grad.data attribute to perform an update
+      par.data -= lr * par.grad.data
+```
+
+%% Output
+
+    Random seed 2021 has been set.
+
+%% Cell type:code id: tags:
+
+``` python
+(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000, maxlen=250,)
+
+# print the first comment
+word_indizes_orig = keras.datasets.imdb.get_word_index(path="imdb_word_index.json")
+word_indizes = {v: k for k, v in word_indizes_orig.items()}
+for i in x_train[0]:
+    print(f"{word_indizes.get(i-3, '')}", end=" ")
+print()
+
+def vectorize_sequences(sequences, dimension=10000):
+    # all zero matrix of shape (len(sequences), dimension)
+    result = np.zeros((len(sequences), dimension))
+    for i,sequence in enumerate(sequences):
+        result[i, sequence] = 1
+    return result
+
+print(len(x_train))
+print(len(x_test))
+
+x_train = vectorize_sequences(x_train)
+x_test = vectorize_sequences(x_test)
+#x_train = np.expand_dims(x_train, -1)
+#x_test = np.expand_dims(x_test, -1)
+
+x_train = Variable(torch.from_numpy(x_train)).float().to(DEVICE)
+y_train = Variable(torch.from_numpy(y_train)).long().to(DEVICE)
+x_test  = Variable(torch.from_numpy(x_test)).float().to(DEVICE)
+y_test  = Variable(torch.from_numpy(y_test)).long().to(DEVICE)
+
+print("x_train shape:", x_train.shape)
+print("y_train shape:", y_train.shape)
+print(x_train.shape[0], "train samples")
+print(x_test.shape[0], "test samples")
+```
+
+%% Output
+
+     this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert  is an amazing actor and now the same being director  father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for  and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also  to the two little boy's that played the  of norman and paul they were just brilliant children are often left out of the  list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all
+    17121
+    17588
+    x_train shape: torch.Size([17121, 10000])
+    y_train shape: torch.Size([17121])
+    17121 train samples
+    17588 test samples
+
+%% Cell type:code id: tags:
+
+``` python
+# Why so many data? I thought the imdb dataset consists only of 25000 reviews?
+```
+
+%% Cell type:markdown id: tags:
+
+# 1.&nbsp; Softmax Implementieren
+Implementieren Sie die Softmax Funktion mit Numpy und stellen Sie zunächst sicher, dass diese die selben Ergebnisse liefert wie die Pytorch-Funktion im Beispiel. Vergleichen Sie dann Ihre Implementierungen mit anderen Gruppen und diskutieren Sie auch über Performance und numerische Stabilität. Erstellen Sie ein kleines Benchmark, um Performance und numerische Stabilität zu testen.
+
+%% Cell type:code id: tags:
+
+``` python
+def softmax(vector):
+    exp_vec = np.exp(vector)
+    vec_sum = exp_vec.sum()
+    return exp_vec / vec_sum
+
+def softmax_save(vector):
+    norm_vec = vector - torch.max(vector)
+    exp_vec = np.exp(norm_vec)
+    vec_sum = exp_vec.sum()
+    return exp_vec / vec_sum
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# test softmax
+m = nn.Softmax(dim=1)
+tolerance = 1e-6
+for i in range(1000):
+    input = torch.randn(1, 3)
+    soft1 = softmax(input)
+    soft2 = m(input)
+    soft3 = softmax_save(input)
+    if not np.allclose(soft1, soft2, tolerance) or not np.allclose(soft2, soft3, tolerance):
+        raise Exception(f"Error with Tensor: {input}")
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# Numerical Stability
+info = torch.finfo(torch.float32)
+max_min_test = torch.tensor([info.max, info.min])
+print(max_min_test)
+print(softmax_save(max_min_test))
+
+# test performance
+counter = 1000
+times_torch = np.zeros(counter)
+times_own_safe = np.zeros(counter)
+times_own_unsafe = np.zeros(counter)
+m = nn.Softmax(dim=1)
+for i in range(counter):
+    input = torch.randn(1, 200000)
+    time_torch = timeit.timeit(lambda: m(input), number=1)
+    time_own_safe = timeit.timeit(lambda: softmax_save(input), number=1)
+    time_own = timeit.timeit(lambda: softmax(input), number=1)
+    times_torch[i] = time_torch
+    times_own_safe[i] = time_own_safe
+    times_own_unsafe[i] = time_own
+print(f"Avg time torch: {times_torch.mean()} vs own save implementation: {times_own_safe.mean()} vs unsafe: {times_own_unsafe.mean()}")
+```
+
+%% Output
+
+    tensor([ 3.4028e+38, -3.4028e+38])
+    tensor([1., 0.])
+    Avg time torch: 0.00021779541100002574 vs own save implementation: 0.0004932853010000429 vs unsafe: 0.00040290728599981664
+
+%% Cell type:markdown id: tags:
+
+# 2.&nbsp; Regularisierung Implementieren
+
+Unten finden Sie einen Pytorch-SGD Schritt mit eingebauter L2-Regularisierung und ohne. Interpretieren Sie die unterschiedlichen Ausgaben. Modifizieren Sie den ersten Codabschnitt mit einer eigenen L2-Regularisierung so, dass identische Ergebnisse erzeugt werden. Sie können dazu die noch nicht verwendete und noch falsch definierte Variable "regtermwrong" umdefinieren und zu einem späteren Zeitpunkt im Code darauf zurückgreifen. ACHTUNG: weight_decay*2=lambda.
+
+%% Cell type:code id: tags:
+
+``` python
+#Datendefinition
+np.random.seed(123)
+np.set_printoptions(8, suppress=True)
+
+x_numpy = np.random.random((3, 4)).astype(np.double)
+w_numpy = np.random.random((4, 5)).astype(np.double)
+w_numpy[0,0] =9.9
+x_torch = torch.tensor(x_numpy, requires_grad=True)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# ohne Regularisierung
+w_torch = torch.tensor(w_numpy, requires_grad=True)
+print('Original weights', w_torch)
+
+lr = 0.1
+sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=0)
+omega = w_torch.square().sum()
+y_torch = torch.matmul(x_torch, w_torch)
+loss = y_torch.sum() + 1 * omega #
+
+
+sgd.zero_grad()
+loss.backward()
+sgd.step()
+
+w_grad = w_torch.grad.data.numpy()
+print('0 weight decay', w_torch)
+```
+
+%% Output
+
+    Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],
+            [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],
+            [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],
+            [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,
+           requires_grad=True)
+    0 weight decay tensor([[ 7.7303, -0.1419,  0.1287,  0.4007, -0.0437],
+            [ 0.0302,  0.3151,  0.3153,  0.3974,  0.5694],
+            [ 0.4245,  0.3337,  0.4229,  0.1033,  0.1344],
+            [-0.0139,  0.0385,  0.3083, -0.1228,  0.1504]], dtype=torch.float64,
+           requires_grad=True)
+
+%% Cell type:code id: tags:
+
+``` python
+#mit Regularisierung
+
+
+w_torch = torch.tensor(w_numpy, requires_grad=True)
+
+print('Reset Original weights', w_torch)
+
+sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=2)
+
+y_torch = torch.matmul(x_torch, w_torch)
+loss = y_torch.sum()
+
+sgd.zero_grad()
+loss.backward()
+sgd.step()
+
+w_grad = w_torch.grad.data.numpy()
+print('1 weight decay', w_torch)
+```
+
+%% Output
+
+    Reset Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],
+            [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],
+            [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],
+            [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,
+           requires_grad=True)
+    1 weight decay tensor([[ 7.7303, -0.1419,  0.1287,  0.4007, -0.0437],
+            [ 0.0302,  0.3151,  0.3153,  0.3974,  0.5694],
+            [ 0.4245,  0.3337,  0.4229,  0.1033,  0.1344],
+            [-0.0139,  0.0385,  0.3083, -0.1228,  0.1504]], dtype=torch.float64,
+           requires_grad=True)
+
+%% Cell type:code id: tags:
+
+``` python
+# FRAGE:
+# Wieso ist der weight_decay hier doppelt? also warum etspricht alpha * 2 = lambda?
+```
+
+%% Cell type:markdown id: tags:
+
+# 3.&nbsp; Einfaches MLP in Pytorch
+Machen Sie sich ein wenig mit dem IMDB Datensatz und den für Sie erstellten Datenstrukturen in x/y_train/test vertraut.
+
+%% Cell type:markdown id: tags:
+
+## 3.1 Modell erstellen und  Angaben zur Modellgröße verstehen
+Definieren Sie ein Pytorch Multilayer Perzeptron mit der Größe des IMDB-Dictionaries für one-hot-encodierte Wörte als Eingabe (Sigmoid Aktivierung), 50 Neuronen im Hidden Layer und 2 Ausgabeneuronen. Layer 1 und 2 Ihres Netzes verwendet die Sigmoid-Aktivierungsfunktion, Layer 3 die Softmax-Aktivierungsfunktion.
+
+Generieren Sie Modell-Summary mit torchinfo und erklären Sie, was die ausgegebenen Werte bedeuten und wie diese zustande kommen.
+
+%% Cell type:code id: tags:
+
+``` python
+#Ihr Code hier
+class Model(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.layers = nn.Sequential(
+            nn.Linear(10000, 50),
+            nn.Sigmoid(),
+            nn.Linear(50,50),
+            nn.Sigmoid(),
+            nn.Linear(50,2),
+            nn.Softmax()
+        )
+    def forward(self, x):
+        return self.layers(x)
+```
+
+%% Cell type:markdown id: tags:
+
+## 3.2 Modell trainieren und Performancekurven interpretieren
+Nutzen Sie den untenstehenedn Code um Ihr Modell zu trainieren. Interpretieren und diskutieren Sie die entstehenden Performancekurven. Falls Sie einen unerwarteten Anstieg Ihres Losses beobachten, recherchieren Sie wie Sie diese mit dem Einbau einer einzelnen Verbesserung innerhalb des gegebenen SGD Lernverfahrens beheben können. ACHTUNG: Wenn Sie Ihr Modell nicht oben neu initialisieren, optimieren Sie weiter auf den schon veränderten Parametern.
+
+%% Cell type:code id: tags:
+
+``` python
+model = Model().to(DEVICE)
+
+EPOCHS  = 290 #@param {type:"slider", min:2, max:1000, step:1}
+RATE = 0.9 #@param {type:"slider", min:0.001, max:2, step:0.001}
+optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)
+loss_fn   = nn.CrossEntropyLoss()
+loss_list     = np.zeros((EPOCHS,))
+accuracy_list = np.zeros((EPOCHS,))
+accuracy_list_test = np.zeros((EPOCHS,))
+
+
+
+for epoch in tqdm.trange(EPOCHS):
+    y_pred = model(x_train)
+    #loss = loss_fn(y_pred, y_train)
+    loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)
+    loss_list[epoch] = loss.item()
+
+    # Zero gradients
+    optimizer.zero_grad()
+
+    loss.backward()
+    #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)
+    optimizer.step()
+
+    with torch.no_grad():
+        y_pred = model(x_train)
+        correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)
+        accuracy_list[epoch] = correct.mean()
+        y_pred = model(x_test)
+        correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)
+        accuracy_list_test[epoch] = correct.mean()
+
+
+
+
+fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)
+
+ax1.plot(accuracy_list)
+ax1.set_ylabel("train accuracy")
+ax2.plot(loss_list)
+ax2.set_ylabel("train loss")
+ax3.plot(accuracy_list_test)
+ax3.set_ylabel("test acc")
+ax3.set_xlabel("epochs");
+```
+
+%% Output
+
+    100%|█████████████████████████████████████████████████████████████████████████████████| 290/290 [00:06<00:00, 44.49it/s]
+
+
+
+%% Cell type:markdown id: tags:
+
+## 3.3.&nbsp;Momentum Implementieren
+Vervollständigen Sie Methode momentum_update. Überlegen Sie sich, wie Sie die Korrektheit mit einem Durchlauf inkl. Momentum Update auf Ihrem oben definierten Modell prüfen können
+
+%% Cell type:code id: tags:
+
+``` python
+def momentum_update(loss, params, grad_vel, lr=1e-3, beta=0.8):
+  # Clear up gradients as Pytorch automatically accumulates gradients from
+  # successive backward calls
+  zero_grad(params)
+  # Compute gradients on given objective
+  loss.backward()
+
+  with torch.no_grad():
+    for (par, vel) in zip(params, grad_vel):
+        if vel != None:
+            par.grad.data += beta * vel
+        par.data -= lr * par.grad.data
+```
+
+%% Cell type:code id: tags:
+
+``` python
+model = Model().to(DEVICE)
+
+EPOCHS  = 300 #@param {type:"slider", min:2, max:1000, step:1}
+RATE = 0.9 #@param {type:"slider", min:0.001, max:2, step:0.001}
+optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)
+loss_fn   = nn.CrossEntropyLoss()
+loss_list     = np.zeros((EPOCHS,))
+accuracy_list = np.zeros((EPOCHS,))
+accuracy_list_test = np.zeros((EPOCHS,))
+
+params = list(model.parameters())
+
+for epoch in tqdm.trange(EPOCHS):
+    y_pred = model(x_train)
+    #loss = loss_fn(y_pred, y_train)
+    loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)
+    loss_list[epoch] = loss.item()
+
+
+    vel = [param.grad for param in params]
+    # Zero gradients
+    optimizer.zero_grad()
+
+    #loss.backward()
+
+    #momentum_update(loss, params, vel)
+    gradient_update(loss, params)
+    #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)
+    #optimizer.step()
+
+    with torch.no_grad():
+        y_pred = model(x_train)
+        correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)
+        accuracy_list[epoch] = correct.mean()
+        y_pred = model(x_test)
+        correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)
+        accuracy_list_test[epoch] = correct.mean()
+
+
+
+
+fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)
+
+ax1.plot(accuracy_list)
+ax1.set_ylabel("train accuracy")
+ax2.plot(loss_list)
+ax2.set_ylabel("train loss")
+ax3.plot(accuracy_list_test)
+ax3.set_ylabel("test acc")
+ax3.set_xlabel("epochs");
+```
+
+%% Output
+
+    100%|█████████████████████████████████████████████████████████████████████████████████| 300/300 [00:06<00:00, 45.36it/s]
+
+
+
+%% Cell type:markdown id: tags:
+
+## 3.4 Experimente zum Lernverhalten mit Momentum und Batch Size
+Im folgenden können Sie für ein festgelegtes Zeitbudget schauen, wie sich der Loss Ihres neuronalen Netzes innerhalb dieser Zeit entwickelt.
+Experimentieren Sie zunächst mit den Voreinstellungen mit und ohne Momentum, probieren Sie dann eigene Einstellungen aus. Diskutieren Sie das visualisierte Lernverhalten insbesondere bzgl. unterschiedlicher Batch Sizes.
+
+%% Cell type:code id: tags:
+
+``` python
+@widgets.interact_manual
+def minibatch_experiment(batch_sizes='1, 20, 500, 17000',
+                         lrs='0.9, 0.9, 0.9, 0.9',
+                         time_budget=widgets.Dropdown(options=["0.05", "0.5",  "2.0", "5.0", "7.5"],
+                                                      value="5.0"),
+                         use_momentum = widgets.ToggleButton(value=True)):
+
+  """
+  Demonstration of minibatch experiment
+
+  Args:
+    batch_sizes: String
+      Size of minibatches
+    lrs: String
+      Different learning rates
+    time_budget: widget dropdown instance
+      Different time budgets with default=2.5s
+
+  Returns:
+    Nothing
+  """
+  batch_sizes = [int(s) for s in batch_sizes.split(',')]
+  lrs = [float(s) for s in lrs.split(',')]
+
+  LOSS_HIST = {_:[] for _ in batch_sizes}
+
+  #X, y = train_set.data, train_set.targets
+  base_model = Model().to(DEVICE)
+  #base_model = MLP(in_dim=784, out_dim=10, hidden_dims=[100, 100])
+
+  for id, batch_size in enumerate(tqdm.auto.tqdm(batch_sizes)):
+    start_time = time.time()
+    # Create a new copy of the model for each batch size
+    model = copy.deepcopy(base_model)
+    params = list(model.parameters())
+    lr = lrs[id]
+    # Fixed budget per choice of batch size
+    #initial_vel = [torch.randn_like(p) for p in model.parameters()]
+    aux_tensors = [torch.zeros_like(_) for _ in params]
+    while (time.time() - start_time) < float(time_budget):
+      data, labels = sample_minibatch(x_train, y_train, batch_size)
+      loss = loss_fn(model(data), labels)
+      if use_momentum:
+        momentum_update(loss, params, grad_vel=aux_tensors, lr=lr, beta=0.5)
+      else:
+        gradient_update(loss, params, lr=lr)
+      LOSS_HIST[batch_size].append([time.time() - start_time,
+                                    loss.item()])
+
+  fig, axs = plt.subplots(1, len(batch_sizes), figsize=(10, 3))
+  for ax, batch_size in zip(axs, batch_sizes):
+    plot_data = np.array(LOSS_HIST[batch_size])
+    ax.plot(plot_data[:, 0], plot_data[:, 1], label=batch_size,
+            alpha=0.8)
+    #ax.set_title('Batch size: ' + str(batch_size) + ' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))
+    ax.set_title(' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))
+    ax.set_xlabel('Seconds')
+    ax.set_ylabel('Loss')
+  plt.show()
+  #return(LOSS_HIST)
+```
+
+%% Output
+
+
+%% Cell type:markdown id: tags:
+
+![image.png](data:image/png;base64,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)
+%% Cell type:markdown id: tags:
+
+#0.&nbsp; Imports und Helper
+
+%% Cell type:code id: tags:
+
+``` python
+!pip install torchinfo
+!pip install matplotlib --quiet
+!pip install tqdm
+```
+
+%% Output
+
+    Defaulting to user installation because normal site-packages is not writeable
+    Requirement already satisfied: torchinfo in /home/niko/.local/lib/python3.10/site-packages (1.8.0)
+    Defaulting to user installation because normal site-packages is not writeable
+    Requirement already satisfied: tqdm in /home/niko/.local/lib/python3.10/site-packages (4.66.1)
+
+%% Cell type:code id: tags:
+
+``` python
+# Imports
+import copy
+
+import ipywidgets as widgets
+import matplotlib.pyplot as plt
+import numpy as np
+
+import time
+import torch
+import torchvision
+#import torchvision.datasets as datasets
+import torch.nn.functional as F
+import torch.nn as nn
+import torch.optim as optim
+import tqdm
+
+import random
+import keras.datasets.imdb
+
+from torch.autograd import Variable
+from tqdm.auto import tqdm as tqdmauto
+import timeit
+```
+
+%% Cell type:code id: tags:
+
+``` python
+def set_seed(seed=None, seed_torch=True):
+  """
+  Handles variability by controlling sources of randomness
+  through set seed values
+
+  Args:
+    seed: Integer
+      Set the seed value to given integer.
+      If no seed, set seed value to random integer in the range 2^32
+    seed_torch: Bool
+      Seeds the random number generator for all devices to
+      offer some guarantees on reproducibility
+
+  Returns:
+    Nothing
+  """
+  if seed is None:
+    seed = np.random.choice(2 ** 32)
+  random.seed(seed)
+  np.random.seed(seed)
+  if seed_torch:
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.cuda.manual_seed(seed)
+    torch.backends.cudnn.benchmark = False
+    torch.backends.cudnn.deterministic = True
+  print(f'Random seed {seed} has been set.')
+SEED = 2021
+set_seed(seed=SEED)
+DEVICE = "cuda"
+
+def zero_grad(params):
+  """
+  Clear gradients as they accumulate on successive backward calls
+
+  Args:
+    params: an iterator over tensors
+      i.e., updating the Weights and biases
+
+  Returns:
+    Nothing
+  """
+  for par in params:
+    if not(par.grad is None):
+      par.grad.data.zero_()
+
+
+def print_params(model):
+  """
+  Lists the name and current value of the model's
+  named parameters
+
+  Args:
+    model: an nn.Module inherited model
+      Represents the ML/DL model
+
+  Returns:
+    Nothing
+  """
+  for name, param in model.named_parameters():
+    if param.requires_grad:
+      print(name, param.data)
+
+def sample_minibatch(input_data, target_data, num_points=100):
+  """
+  Sample a minibatch of size num_point from the provided input-target data
+
+  Args:
+    input_data: Tensor
+      Multi-dimensional tensor containing the input data
+    target_data: Tensor
+      1D tensor containing the class labels
+    num_points: Integer
+      Number of elements to be included in minibatch with default=100
+
+  Returns:
+    batch_inputs: Tensor
+      Minibatch inputs
+    batch_targets: Tensor
+      Minibatch targets
+  """
+  # Sample a collection of IID indices from the existing data
+  batch_indices = np.random.choice(len(input_data), num_points)
+  # Use batch_indices to extract entries from the input and target data tensors
+  batch_inputs = input_data[batch_indices, :]
+  batch_targets = target_data[batch_indices]
+
+  return batch_inputs, batch_targets
+
+
+def gradient_update(loss, params, lr=1e-3):
+  """
+  Perform a gradient descent update on a given loss over a collection of parameters
+
+  Args:
+    loss: Tensor
+      A scalar tensor containing the loss through which the gradient will be computed
+    params: List of iterables
+      Collection of parameters with respect to which we compute gradients
+    lr: Float
+      Scalar specifying the learning rate or step-size for the update
+
+  Returns:
+    Nothing
+  """
+  # Clear up gradients as Pytorch automatically accumulates gradients from
+  # successive backward calls
+  zero_grad(params)
+
+  # Compute gradients on given objective
+  loss.backward()
+
+  with torch.no_grad():
+    for par in params:
+      # Here we work with the 'data' attribute of the parameter rather than the
+      # parameter itself.
+      # Hence - use the learning rate and the parameter's .grad.data attribute to perform an update
+      par.data -= lr * par.grad.data
+```
+
+%% Output
+
+    Random seed 2021 has been set.
+
+%% Cell type:code id: tags:
+
+``` python
+(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000, maxlen=250,)
+
+# print the first comment
+word_indizes_orig = keras.datasets.imdb.get_word_index(path="imdb_word_index.json")
+word_indizes = {v: k for k, v in word_indizes_orig.items()}
+for i in x_train[0]:
+    print(f"{word_indizes.get(i-3, '')}", end=" ")
+print()
+
+def vectorize_sequences(sequences, dimension=10000):
+    # all zero matrix of shape (len(sequences), dimension)
+    result = np.zeros((len(sequences), dimension))
+    for i,sequence in enumerate(sequences):
+        result[i, sequence] = 1
+    return result
+
+print(len(x_train))
+print(len(x_test))
+
+x_train = vectorize_sequences(x_train)
+x_test = vectorize_sequences(x_test)
+#x_train = np.expand_dims(x_train, -1)
+#x_test = np.expand_dims(x_test, -1)
+
+x_train = Variable(torch.from_numpy(x_train)).float().to(DEVICE)
+y_train = Variable(torch.from_numpy(y_train)).long().to(DEVICE)
+x_test  = Variable(torch.from_numpy(x_test)).float().to(DEVICE)
+y_test  = Variable(torch.from_numpy(y_test)).long().to(DEVICE)
+
+print("x_train shape:", x_train.shape)
+print("y_train shape:", y_train.shape)
+print(x_train.shape[0], "train samples")
+print(x_test.shape[0], "test samples")
+```
+
+%% Output
+
+     this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert  is an amazing actor and now the same being director  father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for  and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also  to the two little boy's that played the  of norman and paul they were just brilliant children are often left out of the  list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all
+    17121
+    17588
+    x_train shape: torch.Size([17121, 10000])
+    y_train shape: torch.Size([17121])
+    17121 train samples
+    17588 test samples
+
+%% Cell type:code id: tags:
+
+``` python
+# Why so many data? I thought the imdb dataset consists only of 25000 reviews?
+```
+
+%% Cell type:markdown id: tags:
+
+# 1.&nbsp; Softmax Implementieren
+Implementieren Sie die Softmax Funktion mit Numpy und stellen Sie zunächst sicher, dass diese die selben Ergebnisse liefert wie die Pytorch-Funktion im Beispiel. Vergleichen Sie dann Ihre Implementierungen mit anderen Gruppen und diskutieren Sie auch über Performance und numerische Stabilität. Erstellen Sie ein kleines Benchmark, um Performance und numerische Stabilität zu testen.
+
+%% Cell type:code id: tags:
+
+``` python
+def softmax(vector):
+    exp_vec = np.exp(vector)
+    vec_sum = exp_vec.sum()
+    return exp_vec / vec_sum
+
+def softmax_save(vector):
+    norm_vec = vector - torch.max(vector)
+    exp_vec = np.exp(norm_vec)
+    vec_sum = exp_vec.sum()
+    return exp_vec / vec_sum
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# test softmax
+m = nn.Softmax(dim=1)
+tolerance = 1e-6
+for i in range(1000):
+    input = torch.randn(1, 3)
+    soft1 = softmax(input)
+    soft2 = m(input)
+    soft3 = softmax_save(input)
+    if not np.allclose(soft1, soft2, tolerance) or not np.allclose(soft2, soft3, tolerance):
+        raise Exception(f"Error with Tensor: {input}")
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# Numerical Stability
+info = torch.finfo(torch.float32)
+max_min_test = torch.tensor([info.max, info.min])
+print(max_min_test)
+print(softmax_save(max_min_test))
+
+# test performance
+counter = 1000
+times_torch = np.zeros(counter)
+times_own_safe = np.zeros(counter)
+times_own_unsafe = np.zeros(counter)
+m = nn.Softmax(dim=1)
+for i in range(counter):
+    input = torch.randn(1, 200000)
+    time_torch = timeit.timeit(lambda: m(input), number=1)
+    time_own_safe = timeit.timeit(lambda: softmax_save(input), number=1)
+    time_own = timeit.timeit(lambda: softmax(input), number=1)
+    times_torch[i] = time_torch
+    times_own_safe[i] = time_own_safe
+    times_own_unsafe[i] = time_own
+print(f"Avg time torch: {times_torch.mean()} vs own save implementation: {times_own_safe.mean()} vs unsafe: {times_own_unsafe.mean()}")
+```
+
+%% Output
+
+    tensor([ 3.4028e+38, -3.4028e+38])
+    tensor([1., 0.])
+    Avg time torch: 0.00021779541100002574 vs own save implementation: 0.0004932853010000429 vs unsafe: 0.00040290728599981664
+
+%% Cell type:markdown id: tags:
+
+# 2.&nbsp; Regularisierung Implementieren
+
+Unten finden Sie einen Pytorch-SGD Schritt mit eingebauter L2-Regularisierung und ohne. Interpretieren Sie die unterschiedlichen Ausgaben. Modifizieren Sie den ersten Codabschnitt mit einer eigenen L2-Regularisierung so, dass identische Ergebnisse erzeugt werden. Sie können dazu die noch nicht verwendete und noch falsch definierte Variable "regtermwrong" umdefinieren und zu einem späteren Zeitpunkt im Code darauf zurückgreifen. ACHTUNG: weight_decay*2=lambda.
+
+%% Cell type:code id: tags:
+
+``` python
+#Datendefinition
+np.random.seed(123)
+np.set_printoptions(8, suppress=True)
+
+x_numpy = np.random.random((3, 4)).astype(np.double)
+w_numpy = np.random.random((4, 5)).astype(np.double)
+w_numpy[0,0] =9.9
+x_torch = torch.tensor(x_numpy, requires_grad=True)
+```
+
+%% Cell type:code id: tags:
+
+``` python
+# ohne Regularisierung
+w_torch = torch.tensor(w_numpy, requires_grad=True)
+print('Original weights', w_torch)
+
+lr = 0.1
+sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=0)
+omega = w_torch.square().sum()
+y_torch = torch.matmul(x_torch, w_torch)
+loss = y_torch.sum() + 1 * omega #
+
+
+sgd.zero_grad()
+loss.backward()
+sgd.step()
+
+w_grad = w_torch.grad.data.numpy()
+print('0 weight decay', w_torch)
+```
+
+%% Output
+
+    Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],
+            [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],
+            [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],
+            [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,
+           requires_grad=True)
+    0 weight decay tensor([[ 7.7303, -0.1419,  0.1287,  0.4007, -0.0437],
+            [ 0.0302,  0.3151,  0.3153,  0.3974,  0.5694],
+            [ 0.4245,  0.3337,  0.4229,  0.1033,  0.1344],
+            [-0.0139,  0.0385,  0.3083, -0.1228,  0.1504]], dtype=torch.float64,
+           requires_grad=True)
+
+%% Cell type:code id: tags:
+
+``` python
+#mit Regularisierung
+
+
+w_torch = torch.tensor(w_numpy, requires_grad=True)
+
+print('Reset Original weights', w_torch)
+
+sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=2)
+
+y_torch = torch.matmul(x_torch, w_torch)
+loss = y_torch.sum()
+
+sgd.zero_grad()
+loss.backward()
+sgd.step()
+
+w_grad = w_torch.grad.data.numpy()
+print('1 weight decay', w_torch)
+```
+
+%% Output
+
+    Reset Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],
+            [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],
+            [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],
+            [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,
+           requires_grad=True)
+    1 weight decay tensor([[ 7.7303, -0.1419,  0.1287,  0.4007, -0.0437],
+            [ 0.0302,  0.3151,  0.3153,  0.3974,  0.5694],
+            [ 0.4245,  0.3337,  0.4229,  0.1033,  0.1344],
+            [-0.0139,  0.0385,  0.3083, -0.1228,  0.1504]], dtype=torch.float64,
+           requires_grad=True)
+
+%% Cell type:code id: tags:
+
+``` python
+# FRAGE:
+# Wieso ist der weight_decay hier doppelt? also warum etspricht alpha * 2 = lambda?
+```
+
+%% Cell type:markdown id: tags:
+
+# 3.&nbsp; Einfaches MLP in Pytorch
+Machen Sie sich ein wenig mit dem IMDB Datensatz und den für Sie erstellten Datenstrukturen in x/y_train/test vertraut.
+
+%% Cell type:markdown id: tags:
+
+## 3.1 Modell erstellen und  Angaben zur Modellgröße verstehen
+Definieren Sie ein Pytorch Multilayer Perzeptron mit der Größe des IMDB-Dictionaries für one-hot-encodierte Wörte als Eingabe (Sigmoid Aktivierung), 50 Neuronen im Hidden Layer und 2 Ausgabeneuronen. Layer 1 und 2 Ihres Netzes verwendet die Sigmoid-Aktivierungsfunktion, Layer 3 die Softmax-Aktivierungsfunktion.
+
+Generieren Sie Modell-Summary mit torchinfo und erklären Sie, was die ausgegebenen Werte bedeuten und wie diese zustande kommen.
+
+%% Cell type:code id: tags:
+
+``` python
+#Ihr Code hier
+class Model(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.layers = nn.Sequential(
+            nn.Linear(10000, 50),
+            nn.Sigmoid(),
+            nn.Linear(50,50),
+            nn.Sigmoid(),
+            nn.Linear(50,2),
+            nn.Softmax()
+        )
+    def forward(self, x):
+        return self.layers(x)
+```
+
+%% Cell type:markdown id: tags:
+
+## 3.2 Modell trainieren und Performancekurven interpretieren
+Nutzen Sie den untenstehenedn Code um Ihr Modell zu trainieren. Interpretieren und diskutieren Sie die entstehenden Performancekurven. Falls Sie einen unerwarteten Anstieg Ihres Losses beobachten, recherchieren Sie wie Sie diese mit dem Einbau einer einzelnen Verbesserung innerhalb des gegebenen SGD Lernverfahrens beheben können. ACHTUNG: Wenn Sie Ihr Modell nicht oben neu initialisieren, optimieren Sie weiter auf den schon veränderten Parametern.
+
+%% Cell type:code id: tags:
+
+``` python
+model = Model().to(DEVICE)
+
+EPOCHS  = 290 #@param {type:"slider", min:2, max:1000, step:1}
+RATE = 0.9 #@param {type:"slider", min:0.001, max:2, step:0.001}
+optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)
+loss_fn   = nn.CrossEntropyLoss()
+loss_list     = np.zeros((EPOCHS,))
+accuracy_list = np.zeros((EPOCHS,))
+accuracy_list_test = np.zeros((EPOCHS,))
+
+
+
+for epoch in tqdm.trange(EPOCHS):
+    y_pred = model(x_train)
+    #loss = loss_fn(y_pred, y_train)
+    loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)
+    loss_list[epoch] = loss.item()
+
+    # Zero gradients
+    optimizer.zero_grad()
+
+    loss.backward()
+    #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)
+    optimizer.step()
+
+    with torch.no_grad():
+        y_pred = model(x_train)
+        correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)
+        accuracy_list[epoch] = correct.mean()
+        y_pred = model(x_test)
+        correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)
+        accuracy_list_test[epoch] = correct.mean()
+
+
+
+
+fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)
+
+ax1.plot(accuracy_list)
+ax1.set_ylabel("train accuracy")
+ax2.plot(loss_list)
+ax2.set_ylabel("train loss")
+ax3.plot(accuracy_list_test)
+ax3.set_ylabel("test acc")
+ax3.set_xlabel("epochs");
+```
+
+%% Output
+
+    100%|█████████████████████████████████████████████████████████████████████████████████| 290/290 [00:06<00:00, 44.49it/s]
+
+
+
+%% Cell type:markdown id: tags:
+
+## 3.3.&nbsp;Momentum Implementieren
+Vervollständigen Sie Methode momentum_update. Überlegen Sie sich, wie Sie die Korrektheit mit einem Durchlauf inkl. Momentum Update auf Ihrem oben definierten Modell prüfen können
+
+%% Cell type:code id: tags:
+
+``` python
+def momentum_update(loss, params, grad_vel, lr=1e-3, beta=0.8):
+  # Clear up gradients as Pytorch automatically accumulates gradients from
+  # successive backward calls
+  zero_grad(params)
+  # Compute gradients on given objective
+  loss.backward()
+
+  with torch.no_grad():
+    for (par, vel) in zip(params, grad_vel):
+        if vel != None:
+            par.grad.data += beta * vel
+        par.data -= lr * par.grad.data
+```
+
+%% Cell type:code id: tags:
+
+``` python
+model = Model().to(DEVICE)
+
+EPOCHS  = 300 #@param {type:"slider", min:2, max:1000, step:1}
+RATE = 0.9 #@param {type:"slider", min:0.001, max:2, step:0.001}
+optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)
+loss_fn   = nn.CrossEntropyLoss()
+loss_list     = np.zeros((EPOCHS,))
+accuracy_list = np.zeros((EPOCHS,))
+accuracy_list_test = np.zeros((EPOCHS,))
+
+params = list(model.parameters())
+
+for epoch in tqdm.trange(EPOCHS):
+    y_pred = model(x_train)
+    #loss = loss_fn(y_pred, y_train)
+    loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)
+    loss_list[epoch] = loss.item()
+
+
+    vel = [param.grad for param in params]
+    # Zero gradients
+    optimizer.zero_grad()
+
+    #loss.backward()
+
+    #momentum_update(loss, params, vel)
+    gradient_update(loss, params)
+    #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)
+    #optimizer.step()
+
+    with torch.no_grad():
+        y_pred = model(x_train)
+        correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)
+        accuracy_list[epoch] = correct.mean()
+        y_pred = model(x_test)
+        correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)
+        accuracy_list_test[epoch] = correct.mean()
+
+
+
+
+fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)
+
+ax1.plot(accuracy_list)
+ax1.set_ylabel("train accuracy")
+ax2.plot(loss_list)
+ax2.set_ylabel("train loss")
+ax3.plot(accuracy_list_test)
+ax3.set_ylabel("test acc")
+ax3.set_xlabel("epochs");
+```
+
+%% Output
+
+    100%|█████████████████████████████████████████████████████████████████████████████████| 300/300 [00:06<00:00, 45.36it/s]
+
+
+
+%% Cell type:markdown id: tags:
+
+## 3.4 Experimente zum Lernverhalten mit Momentum und Batch Size
+Im folgenden können Sie für ein festgelegtes Zeitbudget schauen, wie sich der Loss Ihres neuronalen Netzes innerhalb dieser Zeit entwickelt.
+Experimentieren Sie zunächst mit den Voreinstellungen mit und ohne Momentum, probieren Sie dann eigene Einstellungen aus. Diskutieren Sie das visualisierte Lernverhalten insbesondere bzgl. unterschiedlicher Batch Sizes.
+
+%% Cell type:code id: tags:
+
+``` python
+@widgets.interact_manual
+def minibatch_experiment(batch_sizes='1, 20, 500, 17000',
+                         lrs='0.9, 0.9, 0.9, 0.9',
+                         time_budget=widgets.Dropdown(options=["0.05", "0.5",  "2.0", "5.0", "7.5"],
+                                                      value="5.0"),
+                         use_momentum = widgets.ToggleButton(value=True)):
+
+  """
+  Demonstration of minibatch experiment
+
+  Args:
+    batch_sizes: String
+      Size of minibatches
+    lrs: String
+      Different learning rates
+    time_budget: widget dropdown instance
+      Different time budgets with default=2.5s
+
+  Returns:
+    Nothing
+  """
+  batch_sizes = [int(s) for s in batch_sizes.split(',')]
+  lrs = [float(s) for s in lrs.split(',')]
+
+  LOSS_HIST = {_:[] for _ in batch_sizes}
+
+  #X, y = train_set.data, train_set.targets
+  base_model = Model().to(DEVICE)
+  #base_model = MLP(in_dim=784, out_dim=10, hidden_dims=[100, 100])
+
+  for id, batch_size in enumerate(tqdm.auto.tqdm(batch_sizes)):
+    start_time = time.time()
+    # Create a new copy of the model for each batch size
+    model = copy.deepcopy(base_model)
+    params = list(model.parameters())
+    lr = lrs[id]
+    # Fixed budget per choice of batch size
+    #initial_vel = [torch.randn_like(p) for p in model.parameters()]
+    aux_tensors = [torch.zeros_like(_) for _ in params]
+    while (time.time() - start_time) < float(time_budget):
+      data, labels = sample_minibatch(x_train, y_train, batch_size)
+      loss = loss_fn(model(data), labels)
+      if use_momentum:
+        momentum_update(loss, params, grad_vel=aux_tensors, lr=lr, beta=0.5)
+      else:
+        gradient_update(loss, params, lr=lr)
+      LOSS_HIST[batch_size].append([time.time() - start_time,
+                                    loss.item()])
+
+  fig, axs = plt.subplots(1, len(batch_sizes), figsize=(10, 3))
+  for ax, batch_size in zip(axs, batch_sizes):
+    plot_data = np.array(LOSS_HIST[batch_size])
+    ax.plot(plot_data[:, 0], plot_data[:, 1], label=batch_size,
+            alpha=0.8)
+    #ax.set_title('Batch size: ' + str(batch_size) + ' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))
+    ax.set_title(' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))
+    ax.set_xlabel('Seconds')
+    ax.set_ylabel('Loss')
+  plt.show()
+  #return(LOSS_HIST)
+```
+
+%% Output
+
+
+%% Cell type:markdown id: tags:
+
+![image.png](data:image/png;base64,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)
--- a/Notebooks/nikolai/prak3.ipynb
+++ b/Notebooks/nikolai/prak3.ipynb
--- a/Notebooks/nikolai/requirements.txt
+++ b/Notebooks/nikolai/requirements.txt
+absl-py==2.0.0
+aiohttp==3.8.6
+aiosignal==1.3.1
+anyio==4.0.0
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arrow==1.3.0
+asttokens==2.4.1
+astunparse==1.6.3
+async-lru==2.0.4
+async-timeout==4.0.3
+attrs==23.1.0
+Babel==2.13.1
+beautifulsoup4==4.12.2
+bleach==6.1.0
+blinker==1.4
+cachetools==5.3.2
+certifi==2023.7.22
+cffi==1.16.0
+charset-normalizer==3.3.2
+comm==0.2.0
+command-not-found==0.3
+contourpy==1.2.0
+cryptography==3.4.8
+cycler==0.12.1
+datasets==2.14.6
+dbus-python==1.2.18
+debugpy==1.8.0
+decorator==5.1.1
+defusedxml==0.7.1
+dill==0.3.7
+distro==1.7.0
+distro-info==1.1+ubuntu0.1
+dm-tree==0.1.8
+exceptiongroup==1.1.3
+executing==2.0.1
+fastjsonschema==2.18.1
+filelock==3.13.1
+flatbuffers==23.5.26
+fonttools==4.44.0
+fqdn==1.5.1
+frozenlist==1.4.0
+fsspec==2023.10.0
+gast==0.5.4
+google-auth==2.25.1
+google-auth-oauthlib==1.1.0
+google-pasta==0.2.0
+graphviz==0.20.1
+grpcio==1.60.0
+h5py==3.10.0
+httplib2==0.20.2
+huggingface-hub==0.18.0
+idna==3.4
+importlib-metadata==4.6.4
+ipykernel==6.26.0
+ipython==8.17.2
+ipywidgets==8.1.1
+isoduration==20.11.0
+jedi==0.19.1
+jeepney==0.7.1
+Jinja2==3.1.2
+joblib==1.3.2
+json5==0.9.14
+jsonpointer==2.4
+jsonschema==4.19.2
+jsonschema-specifications==2023.7.1
+jupyter==1.0.0
+jupyter-console==6.6.3
+jupyter-events==0.9.0
+jupyter-lsp==2.2.0
+jupyter_client==8.6.0
+jupyter_core==5.5.0
+jupyter_server==2.10.0
+jupyter_server_terminals==0.4.4
+jupyterlab==4.0.8
+jupyterlab-pygments==0.2.2
+jupyterlab-widgets==3.0.9
+jupyterlab_server==2.25.0
+keras==2.15.0
+keyring==23.5.0
+kiwisolver==1.4.5
+launchpadlib==1.10.16
+lazr.restfulclient==0.14.4
+lazr.uri==1.0.6
+libclang==16.0.6
+Mako==1.1.3
+Markdown==3.5.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.3
+matplotlib==3.8.1
+matplotlib-inline==0.1.6
+mdurl==0.1.2
+mistune==3.0.2
+ml-dtypes==0.2.0
+more-itertools==8.10.0
+mpmath==1.3.0
+multidict==6.0.4
+multiprocess==0.70.15
+namex==0.0.7
+nbclient==0.8.0
+nbconvert==7.11.0
+nbformat==5.9.2
+nest-asyncio==1.5.8
+netifaces==0.11.0
+networkx==3.2.1
+notebook==7.0.6
+notebook_shim==0.2.3
+numpy==1.26.1
+nvidia-cublas-cu12==12.2.5.6
+nvidia-cuda-cupti-cu12==12.2.142
+nvidia-cuda-nvcc-cu12==12.2.140
+nvidia-cuda-nvrtc-cu12==12.2.140
+nvidia-cuda-runtime-cu12==12.2.140
+nvidia-cudnn-cu12==8.9.4.25
+nvidia-cufft-cu12==11.0.8.103
+nvidia-curand-cu12==10.3.3.141
+nvidia-cusolver-cu12==11.5.2.141
+nvidia-cusparse-cu12==12.1.2.141
+nvidia-nccl-cu12==2.16.5
+nvidia-nvjitlink-cu12==12.2.140
+nvidia-nvtx-cu12==12.1.105
+oauthlib==3.2.0
+opt-einsum==3.3.0
+overrides==7.4.0
+packaging==23.2
+pandas==2.1.2
+pandocfilters==1.5.0
+parso==0.8.3
+pexpect==4.8.0
+Pillow==10.1.0
+platformdirs==3.11.0
+plotly==5.18.0
+prometheus-client==0.18.0
+prompt-toolkit==3.0.39
+protobuf==4.23.4
+psutil==5.9.6
+ptyprocess==0.7.0
+pure-eval==0.2.2
+pyarrow==14.0.0
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pycparser==2.21
+pyfiglet==1.0.2
+Pygments==2.16.1
+PyGObject==3.42.1
+PyJWT==2.3.0
+pyparsing==2.4.7
+python-apt==2.4.0+ubuntu2
+python-dateutil==2.8.2
+python-json-logger==2.0.7
+pytz==2023.3.post1
+PyYAML==5.4.1
+pyzmq==25.1.1
+qtconsole==5.5.0
+QtPy==2.4.1
+referencing==0.30.2
+requests==2.31.0
+requests-oauthlib==1.3.1
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.7.0
+rpds-py==0.12.0
+rsa==4.9
+scikit-learn==1.3.2
+scipy==1.11.3
+seaborn==0.13.0
+SecretStorage==3.3.1
+Send2Trash==1.8.2
+six==1.16.0
+sniffio==1.3.0
+soupsieve==2.5
+stack-data==0.6.3
+sympy==1.12
+systemd-python==234
+tenacity==8.2.3
+tensorboard==2.15.1
+tensorboard-data-server==0.7.2
+tensorflow==2.15.0.post1
+tensorflow-estimator==2.15.0
+tensorflow-io-gcs-filesystem==0.34.0
+termcolor==2.4.0
+terminado==0.17.1
+threadpoolctl==3.2.0
+tinycss2==1.2.1
+tomli==2.0.1
+torch==2.1.1
+torchinfo==1.8.0
+torchvision==0.16.1
+torchviz==0.0.2
+tornado==6.3.3
+tqdm==4.66.1
+traitlets==5.13.0
+triton==2.1.0
+types-python-dateutil==2.8.19.14
+typing_extensions==4.8.0
+tzdata==2023.3
+ubuntu-advantage-tools==8001
+ufw==0.36.1
+unattended-upgrades==0.1
+uri-template==1.3.0
+urllib3==2.0.7
+wadllib==1.3.6
+wcwidth==0.2.9
+webcolors==1.13
+webencodings==0.5.1
+websocket-client==1.6.4
+Werkzeug==3.0.1
+widgetsnbextension==4.0.9
+wrapt==1.14.1
+xxhash==3.4.1
+yarl==1.9.2
+zipp==1.0.0
No results found