From 30bee5ae3934abeeff2cba932db8aa500de3ec6e Mon Sep 17 00:00:00 2001
From: niko <nikolai.killer@stud.h-da.de>
Date: Sat, 9 Dec 2023 16:39:31 +0100
Subject: [PATCH] prak 3
---
.../.ipynb_checkpoints/prak3-checkpoint.ipynb | 869 ++++++++++++++++++
Notebooks/nikolai/prak3.ipynb | 869 ++++++++++++++++++
Notebooks/nikolai/requirements.txt | 212 +++++
3 files changed, 1950 insertions(+)
create mode 100644 Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb
create mode 100644 Notebooks/nikolai/prak3.ipynb
create mode 100644 Notebooks/nikolai/requirements.txt
diff --git a/Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb b/Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb
new file mode 100644
index 0000000..c637d31
--- /dev/null
+++ b/Notebooks/nikolai/.ipynb_checkpoints/prak3-checkpoint.ipynb
@@ -0,0 +1,869 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "194EMZeTSLIk"
+ },
+ "source": [
+ "#0. Imports und Helper"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6IoTrfAlzktH",
+ "outputId": "f9bdc25e-4895-436b-91ab-00d3a38af883"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Defaulting to user installation because normal site-packages is not writeable\n",
+ "Requirement already satisfied: torchinfo in /home/niko/.local/lib/python3.10/site-packages (1.8.0)\n",
+ "Defaulting to user installation because normal site-packages is not writeable\n",
+ "Requirement already satisfied: tqdm in /home/niko/.local/lib/python3.10/site-packages (4.66.1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install torchinfo\n",
+ "!pip install matplotlib --quiet\n",
+ "!pip install tqdm"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "id": "dPt0DPgfLjEQ"
+ },
+ "outputs": [],
+ "source": [
+ "# Imports\n",
+ "import copy\n",
+ "\n",
+ "import ipywidgets as widgets\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "import time\n",
+ "import torch\n",
+ "import torchvision\n",
+ "#import torchvision.datasets as datasets\n",
+ "import torch.nn.functional as F\n",
+ "import torch.nn as nn\n",
+ "import torch.optim as optim\n",
+ "import tqdm\n",
+ "\n",
+ "import random\n",
+ "import keras.datasets.imdb\n",
+ "\n",
+ "from torch.autograd import Variable\n",
+ "from tqdm.auto import tqdm as tqdmauto\n",
+ "import timeit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "U6niQp1RNHxp",
+ "outputId": "f07ba931-b6c5-4157-df21-91a429ff70a1"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Random seed 2021 has been set.\n"
+ ]
+ }
+ ],
+ "source": [
+ "def set_seed(seed=None, seed_torch=True):\n",
+ " \"\"\"\n",
+ " Handles variability by controlling sources of randomness\n",
+ " through set seed values\n",
+ "\n",
+ " Args:\n",
+ " seed: Integer\n",
+ " Set the seed value to given integer.\n",
+ " If no seed, set seed value to random integer in the range 2^32\n",
+ " seed_torch: Bool\n",
+ " Seeds the random number generator for all devices to\n",
+ " offer some guarantees on reproducibility\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " if seed is None:\n",
+ " seed = np.random.choice(2 ** 32)\n",
+ " random.seed(seed)\n",
+ " np.random.seed(seed)\n",
+ " if seed_torch:\n",
+ " torch.manual_seed(seed)\n",
+ " torch.cuda.manual_seed_all(seed)\n",
+ " torch.cuda.manual_seed(seed)\n",
+ " torch.backends.cudnn.benchmark = False\n",
+ " torch.backends.cudnn.deterministic = True\n",
+ " print(f'Random seed {seed} has been set.')\n",
+ "SEED = 2021\n",
+ "set_seed(seed=SEED)\n",
+ "DEVICE = \"cuda\"\n",
+ "\n",
+ "def zero_grad(params):\n",
+ " \"\"\"\n",
+ " Clear gradients as they accumulate on successive backward calls\n",
+ "\n",
+ " Args:\n",
+ " params: an iterator over tensors\n",
+ " i.e., updating the Weights and biases\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " for par in params:\n",
+ " if not(par.grad is None):\n",
+ " par.grad.data.zero_()\n",
+ "\n",
+ "\n",
+ "def print_params(model):\n",
+ " \"\"\"\n",
+ " Lists the name and current value of the model's\n",
+ " named parameters\n",
+ "\n",
+ " Args:\n",
+ " model: an nn.Module inherited model\n",
+ " Represents the ML/DL model\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " for name, param in model.named_parameters():\n",
+ " if param.requires_grad:\n",
+ " print(name, param.data)\n",
+ "\n",
+ "def sample_minibatch(input_data, target_data, num_points=100):\n",
+ " \"\"\"\n",
+ " Sample a minibatch of size num_point from the provided input-target data\n",
+ "\n",
+ " Args:\n",
+ " input_data: Tensor\n",
+ " Multi-dimensional tensor containing the input data\n",
+ " target_data: Tensor\n",
+ " 1D tensor containing the class labels\n",
+ " num_points: Integer\n",
+ " Number of elements to be included in minibatch with default=100\n",
+ "\n",
+ " Returns:\n",
+ " batch_inputs: Tensor\n",
+ " Minibatch inputs\n",
+ " batch_targets: Tensor\n",
+ " Minibatch targets\n",
+ " \"\"\"\n",
+ " # Sample a collection of IID indices from the existing data\n",
+ " batch_indices = np.random.choice(len(input_data), num_points)\n",
+ " # Use batch_indices to extract entries from the input and target data tensors\n",
+ " batch_inputs = input_data[batch_indices, :]\n",
+ " batch_targets = target_data[batch_indices]\n",
+ "\n",
+ " return batch_inputs, batch_targets\n",
+ "\n",
+ "\n",
+ "def gradient_update(loss, params, lr=1e-3):\n",
+ " \"\"\"\n",
+ " Perform a gradient descent update on a given loss over a collection of parameters\n",
+ "\n",
+ " Args:\n",
+ " loss: Tensor\n",
+ " A scalar tensor containing the loss through which the gradient will be computed\n",
+ " params: List of iterables\n",
+ " Collection of parameters with respect to which we compute gradients\n",
+ " lr: Float\n",
+ " Scalar specifying the learning rate or step-size for the update\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " # Clear up gradients as Pytorch automatically accumulates gradients from\n",
+ " # successive backward calls\n",
+ " zero_grad(params)\n",
+ "\n",
+ " # Compute gradients on given objective\n",
+ " loss.backward()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " for par in params:\n",
+ " # Here we work with the 'data' attribute of the parameter rather than the\n",
+ " # parameter itself.\n",
+ " # Hence - use the learning rate and the parameter's .grad.data attribute to perform an update\n",
+ " par.data -= lr * par.grad.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "tNDNF10dyqUm",
+ "outputId": "f654597c-411a-45ac-f694-aba79e025aa8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " 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 \n",
+ "17121\n",
+ "17588\n",
+ "x_train shape: torch.Size([17121, 10000])\n",
+ "y_train shape: torch.Size([17121])\n",
+ "17121 train samples\n",
+ "17588 test samples\n"
+ ]
+ }
+ ],
+ "source": [
+ "(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000, maxlen=250,)\n",
+ "\n",
+ "# print the first comment\n",
+ "word_indizes_orig = keras.datasets.imdb.get_word_index(path=\"imdb_word_index.json\")\n",
+ "word_indizes = {v: k for k, v in word_indizes_orig.items()}\n",
+ "for i in x_train[0]:\n",
+ " print(f\"{word_indizes.get(i-3, '')}\", end=\" \")\n",
+ "print()\n",
+ "\n",
+ "def vectorize_sequences(sequences, dimension=10000):\n",
+ " # all zero matrix of shape (len(sequences), dimension)\n",
+ " result = np.zeros((len(sequences), dimension))\n",
+ " for i,sequence in enumerate(sequences):\n",
+ " result[i, sequence] = 1\n",
+ " return result\n",
+ "\n",
+ "print(len(x_train))\n",
+ "print(len(x_test))\n",
+ "\n",
+ "x_train = vectorize_sequences(x_train)\n",
+ "x_test = vectorize_sequences(x_test)\n",
+ "#x_train = np.expand_dims(x_train, -1)\n",
+ "#x_test = np.expand_dims(x_test, -1)\n",
+ "\n",
+ "x_train = Variable(torch.from_numpy(x_train)).float().to(DEVICE)\n",
+ "y_train = Variable(torch.from_numpy(y_train)).long().to(DEVICE)\n",
+ "x_test = Variable(torch.from_numpy(x_test)).float().to(DEVICE)\n",
+ "y_test = Variable(torch.from_numpy(y_test)).long().to(DEVICE)\n",
+ "\n",
+ "print(\"x_train shape:\", x_train.shape)\n",
+ "print(\"y_train shape:\", y_train.shape)\n",
+ "print(x_train.shape[0], \"train samples\")\n",
+ "print(x_test.shape[0], \"test samples\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Why so many data? I thought the imdb dataset consists only of 25000 reviews?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tKJZz5YsSSyT"
+ },
+ "source": [
+ "# 1. Softmax Implementieren\n",
+ "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",
+ "execution_count": 8,
+ "metadata": {
+ "id": "_80I03V8ogds"
+ },
+ "outputs": [],
+ "source": [
+ "def softmax(vector):\n",
+ " exp_vec = np.exp(vector)\n",
+ " vec_sum = exp_vec.sum()\n",
+ " return exp_vec / vec_sum\n",
+ " \n",
+ "def softmax_save(vector):\n",
+ " norm_vec = vector - torch.max(vector)\n",
+ " exp_vec = np.exp(norm_vec)\n",
+ " vec_sum = exp_vec.sum()\n",
+ " return exp_vec / vec_sum"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# test softmax\n",
+ "m = nn.Softmax(dim=1)\n",
+ "tolerance = 1e-6\n",
+ "for i in range(1000):\n",
+ " input = torch.randn(1, 3)\n",
+ " soft1 = softmax(input)\n",
+ " soft2 = m(input)\n",
+ " soft3 = softmax_save(input)\n",
+ " if not np.allclose(soft1, soft2, tolerance) or not np.allclose(soft2, soft3, tolerance):\n",
+ " raise Exception(f\"Error with Tensor: {input}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "id": "x0VacAxQu5JS"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([ 3.4028e+38, -3.4028e+38])\n",
+ "tensor([1., 0.])\n",
+ "Avg time torch: 0.00021779541100002574 vs own save implementation: 0.0004932853010000429 vs unsafe: 0.00040290728599981664\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Numerical Stability\n",
+ "info = torch.finfo(torch.float32)\n",
+ "max_min_test = torch.tensor([info.max, info.min])\n",
+ "print(max_min_test)\n",
+ "print(softmax_save(max_min_test))\n",
+ "\n",
+ "# test performance\n",
+ "counter = 1000\n",
+ "times_torch = np.zeros(counter)\n",
+ "times_own_safe = np.zeros(counter)\n",
+ "times_own_unsafe = np.zeros(counter)\n",
+ "m = nn.Softmax(dim=1)\n",
+ "for i in range(counter):\n",
+ " input = torch.randn(1, 200000)\n",
+ " time_torch = timeit.timeit(lambda: m(input), number=1)\n",
+ " time_own_safe = timeit.timeit(lambda: softmax_save(input), number=1)\n",
+ " time_own = timeit.timeit(lambda: softmax(input), number=1)\n",
+ " times_torch[i] = time_torch\n",
+ " times_own_safe[i] = time_own_safe\n",
+ " times_own_unsafe[i] = time_own\n",
+ "print(f\"Avg time torch: {times_torch.mean()} vs own save implementation: {times_own_safe.mean()} vs unsafe: {times_own_unsafe.mean()}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "c0u-OqU8U-sL"
+ },
+ "source": [
+ "# 2. Regularisierung Implementieren\n",
+ "\n",
+ "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",
+ "execution_count": 14,
+ "metadata": {
+ "id": "O0Hn585ETRWD"
+ },
+ "outputs": [],
+ "source": [
+ "#Datendefinition\n",
+ "np.random.seed(123)\n",
+ "np.set_printoptions(8, suppress=True)\n",
+ "\n",
+ "x_numpy = np.random.random((3, 4)).astype(np.double)\n",
+ "w_numpy = np.random.random((4, 5)).astype(np.double)\n",
+ "w_numpy[0,0] =9.9\n",
+ "x_torch = torch.tensor(x_numpy, requires_grad=True)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "id": "S5XEpjWFTTzi"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],\n",
+ " [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],\n",
+ " [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],\n",
+ " [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,\n",
+ " requires_grad=True)\n",
+ "0 weight decay tensor([[ 7.7303, -0.1419, 0.1287, 0.4007, -0.0437],\n",
+ " [ 0.0302, 0.3151, 0.3153, 0.3974, 0.5694],\n",
+ " [ 0.4245, 0.3337, 0.4229, 0.1033, 0.1344],\n",
+ " [-0.0139, 0.0385, 0.3083, -0.1228, 0.1504]], dtype=torch.float64,\n",
+ " requires_grad=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# ohne Regularisierung\n",
+ "w_torch = torch.tensor(w_numpy, requires_grad=True)\n",
+ "print('Original weights', w_torch)\n",
+ "\n",
+ "lr = 0.1\n",
+ "sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=0)\n",
+ "omega = w_torch.square().sum()\n",
+ "y_torch = torch.matmul(x_torch, w_torch)\n",
+ "loss = y_torch.sum() + 1 * omega #\n",
+ "\n",
+ "\n",
+ "sgd.zero_grad()\n",
+ "loss.backward()\n",
+ "sgd.step()\n",
+ "\n",
+ "w_grad = w_torch.grad.data.numpy()\n",
+ "print('0 weight decay', w_torch)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "id": "WiQW-Y4VkH7v"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reset Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],\n",
+ " [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],\n",
+ " [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],\n",
+ " [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,\n",
+ " requires_grad=True)\n",
+ "1 weight decay tensor([[ 7.7303, -0.1419, 0.1287, 0.4007, -0.0437],\n",
+ " [ 0.0302, 0.3151, 0.3153, 0.3974, 0.5694],\n",
+ " [ 0.4245, 0.3337, 0.4229, 0.1033, 0.1344],\n",
+ " [-0.0139, 0.0385, 0.3083, -0.1228, 0.1504]], dtype=torch.float64,\n",
+ " requires_grad=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#mit Regularisierung\n",
+ "\n",
+ "\n",
+ "w_torch = torch.tensor(w_numpy, requires_grad=True)\n",
+ "\n",
+ "print('Reset Original weights', w_torch)\n",
+ "\n",
+ "sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=2)\n",
+ "\n",
+ "y_torch = torch.matmul(x_torch, w_torch)\n",
+ "loss = y_torch.sum()\n",
+ "\n",
+ "sgd.zero_grad()\n",
+ "loss.backward()\n",
+ "sgd.step()\n",
+ "\n",
+ "w_grad = w_torch.grad.data.numpy()\n",
+ "print('1 weight decay', w_torch)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# FRAGE:\n",
+ "# Wieso ist der weight_decay hier doppelt? also warum etspricht alpha * 2 = lambda?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sQk-ciLBYGnu"
+ },
+ "source": [
+ "# 3. Einfaches MLP in Pytorch\n",
+ "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",
+ "metadata": {
+ "id": "mLeOKvUxMunF"
+ },
+ "source": [
+ "## 3.1 Modell erstellen und Angaben zur Modellgröße verstehen\n",
+ "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.\n",
+ "\n",
+ "Generieren Sie Modell-Summary mit torchinfo und erklären Sie, was die ausgegebenen Werte bedeuten und wie diese zustande kommen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "id": "TikQht7LmNnc"
+ },
+ "outputs": [],
+ "source": [
+ "#Ihr Code hier\n",
+ "class Model(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.layers = nn.Sequential(\n",
+ " nn.Linear(10000, 50),\n",
+ " nn.Sigmoid(),\n",
+ " nn.Linear(50,50),\n",
+ " nn.Sigmoid(),\n",
+ " nn.Linear(50,2),\n",
+ " nn.Softmax()\n",
+ " )\n",
+ " def forward(self, x):\n",
+ " return self.layers(x)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GUoAJo8WMzfb"
+ },
+ "source": [
+ "## 3.2 Modell trainieren und Performancekurven interpretieren\n",
+ "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",
+ "execution_count": 45,
+ "metadata": {
+ "id": "JD2AkGHGrpGV"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|█████████████████████████████████████████████████████████████████████████████████| 290/290 [00:06<00:00, 44.49it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 1200x600 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model = Model().to(DEVICE)\n",
+ "\n",
+ "EPOCHS = 290 #@param {type:\"slider\", min:2, max:1000, step:1}\n",
+ "RATE = 0.9 #@param {type:\"slider\", min:0.001, max:2, step:0.001}\n",
+ "optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)\n",
+ "loss_fn = nn.CrossEntropyLoss()\n",
+ "loss_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list_test = np.zeros((EPOCHS,))\n",
+ "\n",
+ "\n",
+ "\n",
+ "for epoch in tqdm.trange(EPOCHS):\n",
+ " y_pred = model(x_train)\n",
+ " #loss = loss_fn(y_pred, y_train)\n",
+ " loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)\n",
+ " loss_list[epoch] = loss.item()\n",
+ "\n",
+ " # Zero gradients\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " loss.backward()\n",
+ " #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)\n",
+ " optimizer.step()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " y_pred = model(x_train)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)\n",
+ " accuracy_list[epoch] = correct.mean()\n",
+ " y_pred = model(x_test)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)\n",
+ " accuracy_list_test[epoch] = correct.mean()\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)\n",
+ "\n",
+ "ax1.plot(accuracy_list)\n",
+ "ax1.set_ylabel(\"train accuracy\")\n",
+ "ax2.plot(loss_list)\n",
+ "ax2.set_ylabel(\"train loss\")\n",
+ "ax3.plot(accuracy_list_test)\n",
+ "ax3.set_ylabel(\"test acc\")\n",
+ "ax3.set_xlabel(\"epochs\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "F3kyvbJaTjZ7"
+ },
+ "source": [
+ "## 3.3. Momentum Implementieren\n",
+ "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",
+ "execution_count": 46,
+ "metadata": {
+ "id": "36whMhqnMKuc"
+ },
+ "outputs": [],
+ "source": [
+ "def momentum_update(loss, params, grad_vel, lr=1e-3, beta=0.8):\n",
+ " # Clear up gradients as Pytorch automatically accumulates gradients from\n",
+ " # successive backward calls\n",
+ " zero_grad(params)\n",
+ " # Compute gradients on given objective\n",
+ " loss.backward()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " for (par, vel) in zip(params, grad_vel):\n",
+ " if vel != None:\n",
+ " par.grad.data += beta * vel\n",
+ " par.data -= lr * par.grad.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|█████████████████████████████████████████████████████████████████████████████████| 300/300 [00:06<00:00, 45.36it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 1200x600 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model = Model().to(DEVICE)\n",
+ "\n",
+ "EPOCHS = 300 #@param {type:\"slider\", min:2, max:1000, step:1}\n",
+ "RATE = 0.9 #@param {type:\"slider\", min:0.001, max:2, step:0.001}\n",
+ "optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)\n",
+ "loss_fn = nn.CrossEntropyLoss()\n",
+ "loss_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list_test = np.zeros((EPOCHS,))\n",
+ "\n",
+ "params = list(model.parameters())\n",
+ "\n",
+ "for epoch in tqdm.trange(EPOCHS):\n",
+ " y_pred = model(x_train)\n",
+ " #loss = loss_fn(y_pred, y_train)\n",
+ " loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)\n",
+ " loss_list[epoch] = loss.item()\n",
+ "\n",
+ "\n",
+ " vel = [param.grad for param in params]\n",
+ " # Zero gradients\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " #loss.backward()\n",
+ " \n",
+ " #momentum_update(loss, params, vel)\n",
+ " gradient_update(loss, params)\n",
+ " #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)\n",
+ " #optimizer.step()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " y_pred = model(x_train)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)\n",
+ " accuracy_list[epoch] = correct.mean()\n",
+ " y_pred = model(x_test)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)\n",
+ " accuracy_list_test[epoch] = correct.mean()\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)\n",
+ "\n",
+ "ax1.plot(accuracy_list)\n",
+ "ax1.set_ylabel(\"train accuracy\")\n",
+ "ax2.plot(loss_list)\n",
+ "ax2.set_ylabel(\"train loss\")\n",
+ "ax3.plot(accuracy_list_test)\n",
+ "ax3.set_ylabel(\"test acc\")\n",
+ "ax3.set_xlabel(\"epochs\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OPLRI_RKn2Mc"
+ },
+ "source": [
+ "## 3.4 Experimente zum Lernverhalten mit Momentum und Batch Size\n",
+ "Im folgenden können Sie für ein festgelegtes Zeitbudget schauen, wie sich der Loss Ihres neuronalen Netzes innerhalb dieser Zeit entwickelt.\n",
+ "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",
+ "execution_count": 30,
+ "metadata": {
+ "id": "ebevIBNQt4-l"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b30f006d8a304a5f9fc519439876c549",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "interactive(children=(Text(value='1, 20, 500, 17000', continuous_update=False, description='batch_sizes'), Tex…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "@widgets.interact_manual\n",
+ "def minibatch_experiment(batch_sizes='1, 20, 500, 17000',\n",
+ " lrs='0.9, 0.9, 0.9, 0.9',\n",
+ " time_budget=widgets.Dropdown(options=[\"0.05\", \"0.5\", \"2.0\", \"5.0\", \"7.5\"],\n",
+ " value=\"5.0\"),\n",
+ " use_momentum = widgets.ToggleButton(value=True)):\n",
+ "\n",
+ " \"\"\"\n",
+ " Demonstration of minibatch experiment\n",
+ "\n",
+ " Args:\n",
+ " batch_sizes: String\n",
+ " Size of minibatches\n",
+ " lrs: String\n",
+ " Different learning rates\n",
+ " time_budget: widget dropdown instance\n",
+ " Different time budgets with default=2.5s\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " batch_sizes = [int(s) for s in batch_sizes.split(',')]\n",
+ " lrs = [float(s) for s in lrs.split(',')]\n",
+ "\n",
+ " LOSS_HIST = {_:[] for _ in batch_sizes}\n",
+ "\n",
+ " #X, y = train_set.data, train_set.targets\n",
+ " base_model = Model().to(DEVICE)\n",
+ " #base_model = MLP(in_dim=784, out_dim=10, hidden_dims=[100, 100])\n",
+ "\n",
+ " for id, batch_size in enumerate(tqdm.auto.tqdm(batch_sizes)):\n",
+ " start_time = time.time()\n",
+ " # Create a new copy of the model for each batch size\n",
+ " model = copy.deepcopy(base_model)\n",
+ " params = list(model.parameters())\n",
+ " lr = lrs[id]\n",
+ " # Fixed budget per choice of batch size\n",
+ " #initial_vel = [torch.randn_like(p) for p in model.parameters()]\n",
+ " aux_tensors = [torch.zeros_like(_) for _ in params]\n",
+ " while (time.time() - start_time) < float(time_budget):\n",
+ " data, labels = sample_minibatch(x_train, y_train, batch_size)\n",
+ " loss = loss_fn(model(data), labels)\n",
+ " if use_momentum:\n",
+ " momentum_update(loss, params, grad_vel=aux_tensors, lr=lr, beta=0.5)\n",
+ " else:\n",
+ " gradient_update(loss, params, lr=lr)\n",
+ " LOSS_HIST[batch_size].append([time.time() - start_time,\n",
+ " loss.item()])\n",
+ "\n",
+ " fig, axs = plt.subplots(1, len(batch_sizes), figsize=(10, 3))\n",
+ " for ax, batch_size in zip(axs, batch_sizes):\n",
+ " plot_data = np.array(LOSS_HIST[batch_size])\n",
+ " ax.plot(plot_data[:, 0], plot_data[:, 1], label=batch_size,\n",
+ " alpha=0.8)\n",
+ " #ax.set_title('Batch size: ' + str(batch_size) + ' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))\n",
+ " ax.set_title(' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))\n",
+ " ax.set_xlabel('Seconds')\n",
+ " ax.set_ylabel('Loss')\n",
+ " plt.show()\n",
+ " #return(LOSS_HIST)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e9yCfSXR1The"
+ },
+ "source": [
+ ""
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "gpuType": "T4",
+ "provenance": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Notebooks/nikolai/prak3.ipynb b/Notebooks/nikolai/prak3.ipynb
new file mode 100644
index 0000000..40592da
--- /dev/null
+++ b/Notebooks/nikolai/prak3.ipynb
@@ -0,0 +1,869 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "194EMZeTSLIk"
+ },
+ "source": [
+ "#0. Imports und Helper"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "6IoTrfAlzktH",
+ "outputId": "f9bdc25e-4895-436b-91ab-00d3a38af883"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Defaulting to user installation because normal site-packages is not writeable\n",
+ "Requirement already satisfied: torchinfo in /home/niko/.local/lib/python3.10/site-packages (1.8.0)\n",
+ "Defaulting to user installation because normal site-packages is not writeable\n",
+ "Requirement already satisfied: tqdm in /home/niko/.local/lib/python3.10/site-packages (4.66.1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install torchinfo\n",
+ "!pip install matplotlib --quiet\n",
+ "!pip install tqdm"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {
+ "id": "dPt0DPgfLjEQ"
+ },
+ "outputs": [],
+ "source": [
+ "# Imports\n",
+ "import copy\n",
+ "\n",
+ "import ipywidgets as widgets\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "import time\n",
+ "import torch\n",
+ "import torchvision\n",
+ "#import torchvision.datasets as datasets\n",
+ "import torch.nn.functional as F\n",
+ "import torch.nn as nn\n",
+ "import torch.optim as optim\n",
+ "import tqdm\n",
+ "\n",
+ "import random\n",
+ "import keras.datasets.imdb\n",
+ "\n",
+ "from torch.autograd import Variable\n",
+ "from tqdm.auto import tqdm as tqdmauto\n",
+ "import timeit"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "U6niQp1RNHxp",
+ "outputId": "f07ba931-b6c5-4157-df21-91a429ff70a1"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Random seed 2021 has been set.\n"
+ ]
+ }
+ ],
+ "source": [
+ "def set_seed(seed=None, seed_torch=True):\n",
+ " \"\"\"\n",
+ " Handles variability by controlling sources of randomness\n",
+ " through set seed values\n",
+ "\n",
+ " Args:\n",
+ " seed: Integer\n",
+ " Set the seed value to given integer.\n",
+ " If no seed, set seed value to random integer in the range 2^32\n",
+ " seed_torch: Bool\n",
+ " Seeds the random number generator for all devices to\n",
+ " offer some guarantees on reproducibility\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " if seed is None:\n",
+ " seed = np.random.choice(2 ** 32)\n",
+ " random.seed(seed)\n",
+ " np.random.seed(seed)\n",
+ " if seed_torch:\n",
+ " torch.manual_seed(seed)\n",
+ " torch.cuda.manual_seed_all(seed)\n",
+ " torch.cuda.manual_seed(seed)\n",
+ " torch.backends.cudnn.benchmark = False\n",
+ " torch.backends.cudnn.deterministic = True\n",
+ " print(f'Random seed {seed} has been set.')\n",
+ "SEED = 2021\n",
+ "set_seed(seed=SEED)\n",
+ "DEVICE = \"cuda\"\n",
+ "\n",
+ "def zero_grad(params):\n",
+ " \"\"\"\n",
+ " Clear gradients as they accumulate on successive backward calls\n",
+ "\n",
+ " Args:\n",
+ " params: an iterator over tensors\n",
+ " i.e., updating the Weights and biases\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " for par in params:\n",
+ " if not(par.grad is None):\n",
+ " par.grad.data.zero_()\n",
+ "\n",
+ "\n",
+ "def print_params(model):\n",
+ " \"\"\"\n",
+ " Lists the name and current value of the model's\n",
+ " named parameters\n",
+ "\n",
+ " Args:\n",
+ " model: an nn.Module inherited model\n",
+ " Represents the ML/DL model\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " for name, param in model.named_parameters():\n",
+ " if param.requires_grad:\n",
+ " print(name, param.data)\n",
+ "\n",
+ "def sample_minibatch(input_data, target_data, num_points=100):\n",
+ " \"\"\"\n",
+ " Sample a minibatch of size num_point from the provided input-target data\n",
+ "\n",
+ " Args:\n",
+ " input_data: Tensor\n",
+ " Multi-dimensional tensor containing the input data\n",
+ " target_data: Tensor\n",
+ " 1D tensor containing the class labels\n",
+ " num_points: Integer\n",
+ " Number of elements to be included in minibatch with default=100\n",
+ "\n",
+ " Returns:\n",
+ " batch_inputs: Tensor\n",
+ " Minibatch inputs\n",
+ " batch_targets: Tensor\n",
+ " Minibatch targets\n",
+ " \"\"\"\n",
+ " # Sample a collection of IID indices from the existing data\n",
+ " batch_indices = np.random.choice(len(input_data), num_points)\n",
+ " # Use batch_indices to extract entries from the input and target data tensors\n",
+ " batch_inputs = input_data[batch_indices, :]\n",
+ " batch_targets = target_data[batch_indices]\n",
+ "\n",
+ " return batch_inputs, batch_targets\n",
+ "\n",
+ "\n",
+ "def gradient_update(loss, params, lr=1e-3):\n",
+ " \"\"\"\n",
+ " Perform a gradient descent update on a given loss over a collection of parameters\n",
+ "\n",
+ " Args:\n",
+ " loss: Tensor\n",
+ " A scalar tensor containing the loss through which the gradient will be computed\n",
+ " params: List of iterables\n",
+ " Collection of parameters with respect to which we compute gradients\n",
+ " lr: Float\n",
+ " Scalar specifying the learning rate or step-size for the update\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " # Clear up gradients as Pytorch automatically accumulates gradients from\n",
+ " # successive backward calls\n",
+ " zero_grad(params)\n",
+ "\n",
+ " # Compute gradients on given objective\n",
+ " loss.backward()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " for par in params:\n",
+ " # Here we work with the 'data' attribute of the parameter rather than the\n",
+ " # parameter itself.\n",
+ " # Hence - use the learning rate and the parameter's .grad.data attribute to perform an update\n",
+ " par.data -= lr * par.grad.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "tNDNF10dyqUm",
+ "outputId": "f654597c-411a-45ac-f694-aba79e025aa8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " 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 \n",
+ "17121\n",
+ "17588\n",
+ "x_train shape: torch.Size([17121, 10000])\n",
+ "y_train shape: torch.Size([17121])\n",
+ "17121 train samples\n",
+ "17588 test samples\n"
+ ]
+ }
+ ],
+ "source": [
+ "(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(num_words=10000, maxlen=250,)\n",
+ "\n",
+ "# print the first comment\n",
+ "word_indizes_orig = keras.datasets.imdb.get_word_index(path=\"imdb_word_index.json\")\n",
+ "word_indizes = {v: k for k, v in word_indizes_orig.items()}\n",
+ "for i in x_train[0]:\n",
+ " print(f\"{word_indizes.get(i-3, '')}\", end=\" \")\n",
+ "print()\n",
+ "\n",
+ "def vectorize_sequences(sequences, dimension=10000):\n",
+ " # all zero matrix of shape (len(sequences), dimension)\n",
+ " result = np.zeros((len(sequences), dimension))\n",
+ " for i,sequence in enumerate(sequences):\n",
+ " result[i, sequence] = 1\n",
+ " return result\n",
+ "\n",
+ "print(len(x_train))\n",
+ "print(len(x_test))\n",
+ "\n",
+ "x_train = vectorize_sequences(x_train)\n",
+ "x_test = vectorize_sequences(x_test)\n",
+ "#x_train = np.expand_dims(x_train, -1)\n",
+ "#x_test = np.expand_dims(x_test, -1)\n",
+ "\n",
+ "x_train = Variable(torch.from_numpy(x_train)).float().to(DEVICE)\n",
+ "y_train = Variable(torch.from_numpy(y_train)).long().to(DEVICE)\n",
+ "x_test = Variable(torch.from_numpy(x_test)).float().to(DEVICE)\n",
+ "y_test = Variable(torch.from_numpy(y_test)).long().to(DEVICE)\n",
+ "\n",
+ "print(\"x_train shape:\", x_train.shape)\n",
+ "print(\"y_train shape:\", y_train.shape)\n",
+ "print(x_train.shape[0], \"train samples\")\n",
+ "print(x_test.shape[0], \"test samples\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Why so many data? I thought the imdb dataset consists only of 25000 reviews?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tKJZz5YsSSyT"
+ },
+ "source": [
+ "# 1. Softmax Implementieren\n",
+ "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",
+ "execution_count": 8,
+ "metadata": {
+ "id": "_80I03V8ogds"
+ },
+ "outputs": [],
+ "source": [
+ "def softmax(vector):\n",
+ " exp_vec = np.exp(vector)\n",
+ " vec_sum = exp_vec.sum()\n",
+ " return exp_vec / vec_sum\n",
+ " \n",
+ "def softmax_save(vector):\n",
+ " norm_vec = vector - torch.max(vector)\n",
+ " exp_vec = np.exp(norm_vec)\n",
+ " vec_sum = exp_vec.sum()\n",
+ " return exp_vec / vec_sum"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# test softmax\n",
+ "m = nn.Softmax(dim=1)\n",
+ "tolerance = 1e-6\n",
+ "for i in range(1000):\n",
+ " input = torch.randn(1, 3)\n",
+ " soft1 = softmax(input)\n",
+ " soft2 = m(input)\n",
+ " soft3 = softmax_save(input)\n",
+ " if not np.allclose(soft1, soft2, tolerance) or not np.allclose(soft2, soft3, tolerance):\n",
+ " raise Exception(f\"Error with Tensor: {input}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "id": "x0VacAxQu5JS"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([ 3.4028e+38, -3.4028e+38])\n",
+ "tensor([1., 0.])\n",
+ "Avg time torch: 0.00021779541100002574 vs own save implementation: 0.0004932853010000429 vs unsafe: 0.00040290728599981664\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Numerical Stability\n",
+ "info = torch.finfo(torch.float32)\n",
+ "max_min_test = torch.tensor([info.max, info.min])\n",
+ "print(max_min_test)\n",
+ "print(softmax_save(max_min_test))\n",
+ "\n",
+ "# test performance\n",
+ "counter = 1000\n",
+ "times_torch = np.zeros(counter)\n",
+ "times_own_safe = np.zeros(counter)\n",
+ "times_own_unsafe = np.zeros(counter)\n",
+ "m = nn.Softmax(dim=1)\n",
+ "for i in range(counter):\n",
+ " input = torch.randn(1, 200000)\n",
+ " time_torch = timeit.timeit(lambda: m(input), number=1)\n",
+ " time_own_safe = timeit.timeit(lambda: softmax_save(input), number=1)\n",
+ " time_own = timeit.timeit(lambda: softmax(input), number=1)\n",
+ " times_torch[i] = time_torch\n",
+ " times_own_safe[i] = time_own_safe\n",
+ " times_own_unsafe[i] = time_own\n",
+ "print(f\"Avg time torch: {times_torch.mean()} vs own save implementation: {times_own_safe.mean()} vs unsafe: {times_own_unsafe.mean()}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "c0u-OqU8U-sL"
+ },
+ "source": [
+ "# 2. Regularisierung Implementieren\n",
+ "\n",
+ "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",
+ "execution_count": 14,
+ "metadata": {
+ "id": "O0Hn585ETRWD"
+ },
+ "outputs": [],
+ "source": [
+ "#Datendefinition\n",
+ "np.random.seed(123)\n",
+ "np.set_printoptions(8, suppress=True)\n",
+ "\n",
+ "x_numpy = np.random.random((3, 4)).astype(np.double)\n",
+ "w_numpy = np.random.random((4, 5)).astype(np.double)\n",
+ "w_numpy[0,0] =9.9\n",
+ "x_torch = torch.tensor(x_numpy, requires_grad=True)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "id": "S5XEpjWFTTzi"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],\n",
+ " [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],\n",
+ " [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],\n",
+ " [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,\n",
+ " requires_grad=True)\n",
+ "0 weight decay tensor([[ 7.7303, -0.1419, 0.1287, 0.4007, -0.0437],\n",
+ " [ 0.0302, 0.3151, 0.3153, 0.3974, 0.5694],\n",
+ " [ 0.4245, 0.3337, 0.4229, 0.1033, 0.1344],\n",
+ " [-0.0139, 0.0385, 0.3083, -0.1228, 0.1504]], dtype=torch.float64,\n",
+ " requires_grad=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# ohne Regularisierung\n",
+ "w_torch = torch.tensor(w_numpy, requires_grad=True)\n",
+ "print('Original weights', w_torch)\n",
+ "\n",
+ "lr = 0.1\n",
+ "sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=0)\n",
+ "omega = w_torch.square().sum()\n",
+ "y_torch = torch.matmul(x_torch, w_torch)\n",
+ "loss = y_torch.sum() + 1 * omega #\n",
+ "\n",
+ "\n",
+ "sgd.zero_grad()\n",
+ "loss.backward()\n",
+ "sgd.step()\n",
+ "\n",
+ "w_grad = w_torch.grad.data.numpy()\n",
+ "print('0 weight decay', w_torch)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "id": "WiQW-Y4VkH7v"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Reset Original weights tensor([[9.9000, 0.0597, 0.3980, 0.7380, 0.1825],\n",
+ " [0.1755, 0.5316, 0.5318, 0.6344, 0.8494],\n",
+ " [0.7245, 0.6110, 0.7224, 0.3230, 0.3618],\n",
+ " [0.2283, 0.2937, 0.6310, 0.0921, 0.4337]], dtype=torch.float64,\n",
+ " requires_grad=True)\n",
+ "1 weight decay tensor([[ 7.7303, -0.1419, 0.1287, 0.4007, -0.0437],\n",
+ " [ 0.0302, 0.3151, 0.3153, 0.3974, 0.5694],\n",
+ " [ 0.4245, 0.3337, 0.4229, 0.1033, 0.1344],\n",
+ " [-0.0139, 0.0385, 0.3083, -0.1228, 0.1504]], dtype=torch.float64,\n",
+ " requires_grad=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "#mit Regularisierung\n",
+ "\n",
+ "\n",
+ "w_torch = torch.tensor(w_numpy, requires_grad=True)\n",
+ "\n",
+ "print('Reset Original weights', w_torch)\n",
+ "\n",
+ "sgd = torch.optim.SGD([w_torch], lr=lr, weight_decay=2)\n",
+ "\n",
+ "y_torch = torch.matmul(x_torch, w_torch)\n",
+ "loss = y_torch.sum()\n",
+ "\n",
+ "sgd.zero_grad()\n",
+ "loss.backward()\n",
+ "sgd.step()\n",
+ "\n",
+ "w_grad = w_torch.grad.data.numpy()\n",
+ "print('1 weight decay', w_torch)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# FRAGE:\n",
+ "# Wieso ist der weight_decay hier doppelt? also warum etspricht alpha * 2 = lambda?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sQk-ciLBYGnu"
+ },
+ "source": [
+ "# 3. Einfaches MLP in Pytorch\n",
+ "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",
+ "metadata": {
+ "id": "mLeOKvUxMunF"
+ },
+ "source": [
+ "## 3.1 Modell erstellen und Angaben zur Modellgröße verstehen\n",
+ "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.\n",
+ "\n",
+ "Generieren Sie Modell-Summary mit torchinfo und erklären Sie, was die ausgegebenen Werte bedeuten und wie diese zustande kommen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "id": "TikQht7LmNnc"
+ },
+ "outputs": [],
+ "source": [
+ "#Ihr Code hier\n",
+ "class Model(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.layers = nn.Sequential(\n",
+ " nn.Linear(10000, 50),\n",
+ " nn.Sigmoid(),\n",
+ " nn.Linear(50,50),\n",
+ " nn.Sigmoid(),\n",
+ " nn.Linear(50,2),\n",
+ " nn.Softmax()\n",
+ " )\n",
+ " def forward(self, x):\n",
+ " return self.layers(x)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GUoAJo8WMzfb"
+ },
+ "source": [
+ "## 3.2 Modell trainieren und Performancekurven interpretieren\n",
+ "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",
+ "execution_count": 45,
+ "metadata": {
+ "id": "JD2AkGHGrpGV"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|█████████████████████████████████████████████████████████████████████████████████| 290/290 [00:06<00:00, 44.49it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 1200x600 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model = Model().to(DEVICE)\n",
+ "\n",
+ "EPOCHS = 290 #@param {type:\"slider\", min:2, max:1000, step:1}\n",
+ "RATE = 0.9 #@param {type:\"slider\", min:0.001, max:2, step:0.001}\n",
+ "optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)\n",
+ "loss_fn = nn.CrossEntropyLoss()\n",
+ "loss_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list_test = np.zeros((EPOCHS,))\n",
+ "\n",
+ "\n",
+ "\n",
+ "for epoch in tqdm.trange(EPOCHS):\n",
+ " y_pred = model(x_train)\n",
+ " #loss = loss_fn(y_pred, y_train)\n",
+ " loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)\n",
+ " loss_list[epoch] = loss.item()\n",
+ "\n",
+ " # Zero gradients\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " loss.backward()\n",
+ " #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)\n",
+ " optimizer.step()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " y_pred = model(x_train)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)\n",
+ " accuracy_list[epoch] = correct.mean()\n",
+ " y_pred = model(x_test)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)\n",
+ " accuracy_list_test[epoch] = correct.mean()\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)\n",
+ "\n",
+ "ax1.plot(accuracy_list)\n",
+ "ax1.set_ylabel(\"train accuracy\")\n",
+ "ax2.plot(loss_list)\n",
+ "ax2.set_ylabel(\"train loss\")\n",
+ "ax3.plot(accuracy_list_test)\n",
+ "ax3.set_ylabel(\"test acc\")\n",
+ "ax3.set_xlabel(\"epochs\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "F3kyvbJaTjZ7"
+ },
+ "source": [
+ "## 3.3. Momentum Implementieren\n",
+ "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",
+ "execution_count": 49,
+ "metadata": {
+ "id": "36whMhqnMKuc"
+ },
+ "outputs": [],
+ "source": [
+ "def momentum_update(loss, params, grad_vel, lr=1e-3, beta=0.8):\n",
+ " # Clear up gradients as Pytorch automatically accumulates gradients from\n",
+ " # successive backward calls\n",
+ " zero_grad(params)\n",
+ " # Compute gradients on given objective\n",
+ " loss.backward()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " for (par, vel) in zip(params, grad_vel):\n",
+ " if vel != None:\n",
+ " par.grad.data += beta * vel.data\n",
+ " par.data -= lr * par.grad.data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|█████████████████████████████████████████████████████████████████████████████████| 300/300 [00:06<00:00, 45.63it/s]\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "<Figure size 1200x600 with 3 Axes>"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "model = Model().to(DEVICE)\n",
+ "\n",
+ "EPOCHS = 300 #@param {type:\"slider\", min:2, max:1000, step:1}\n",
+ "RATE = 0.9 #@param {type:\"slider\", min:0.001, max:2, step:0.001}\n",
+ "optimizer = torch.optim.SGD(model.parameters(), lr=RATE, weight_decay=0)\n",
+ "loss_fn = nn.CrossEntropyLoss()\n",
+ "loss_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list = np.zeros((EPOCHS,))\n",
+ "accuracy_list_test = np.zeros((EPOCHS,))\n",
+ "\n",
+ "params = list(model.parameters())\n",
+ "\n",
+ "for epoch in tqdm.trange(EPOCHS):\n",
+ " y_pred = model(x_train)\n",
+ " #loss = loss_fn(y_pred, y_train)\n",
+ " loss = loss_fn(y_pred, y_train)# + 0.01 *l2_reg(model)\n",
+ " loss_list[epoch] = loss.item()\n",
+ "\n",
+ "\n",
+ " vel = [param.grad for param in params]\n",
+ " # Zero gradients\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " #loss.backward()\n",
+ " \n",
+ " momentum_update(loss, params, vel, lr=RATE)\n",
+ " #gradient_update(loss, params, lr=RATE)\n",
+ " #torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)#, args.clip)\n",
+ " #optimizer.step()\n",
+ "\n",
+ " with torch.no_grad():\n",
+ " y_pred = model(x_train)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_train).type(torch.FloatTensor)\n",
+ " accuracy_list[epoch] = correct.mean()\n",
+ " y_pred = model(x_test)\n",
+ " correct = (torch.argmax(y_pred, dim=1) == y_test).type(torch.FloatTensor)\n",
+ " accuracy_list_test[epoch] = correct.mean()\n",
+ "\n",
+ "\n",
+ "\n",
+ "\n",
+ "fig, (ax1, ax2, ax3) = plt.subplots(3, figsize=(12, 6), sharex=True)\n",
+ "\n",
+ "ax1.plot(accuracy_list)\n",
+ "ax1.set_ylabel(\"train accuracy\")\n",
+ "ax2.plot(loss_list)\n",
+ "ax2.set_ylabel(\"train loss\")\n",
+ "ax3.plot(accuracy_list_test)\n",
+ "ax3.set_ylabel(\"test acc\")\n",
+ "ax3.set_xlabel(\"epochs\");"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OPLRI_RKn2Mc"
+ },
+ "source": [
+ "## 3.4 Experimente zum Lernverhalten mit Momentum und Batch Size\n",
+ "Im folgenden können Sie für ein festgelegtes Zeitbudget schauen, wie sich der Loss Ihres neuronalen Netzes innerhalb dieser Zeit entwickelt.\n",
+ "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",
+ "execution_count": 53,
+ "metadata": {
+ "id": "ebevIBNQt4-l"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "60295975b505474888424296c58a4997",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "interactive(children=(Text(value='1, 20, 500, 17000', continuous_update=False, description='batch_sizes'), Tex…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "@widgets.interact_manual\n",
+ "def minibatch_experiment(batch_sizes='1, 20, 500, 17000',\n",
+ " lrs='0.9, 0.9, 0.9, 0.9',\n",
+ " time_budget=widgets.Dropdown(options=[\"0.05\", \"0.5\", \"2.0\", \"5.0\", \"7.5\"],\n",
+ " value=\"5.0\"),\n",
+ " use_momentum = widgets.ToggleButton(value=True)):\n",
+ "\n",
+ " \"\"\"\n",
+ " Demonstration of minibatch experiment\n",
+ "\n",
+ " Args:\n",
+ " batch_sizes: String\n",
+ " Size of minibatches\n",
+ " lrs: String\n",
+ " Different learning rates\n",
+ " time_budget: widget dropdown instance\n",
+ " Different time budgets with default=2.5s\n",
+ "\n",
+ " Returns:\n",
+ " Nothing\n",
+ " \"\"\"\n",
+ " batch_sizes = [int(s) for s in batch_sizes.split(',')]\n",
+ " lrs = [float(s) for s in lrs.split(',')]\n",
+ "\n",
+ " LOSS_HIST = {_:[] for _ in batch_sizes}\n",
+ "\n",
+ " #X, y = train_set.data, train_set.targets\n",
+ " base_model = Model().to(DEVICE)\n",
+ " #base_model = MLP(in_dim=784, out_dim=10, hidden_dims=[100, 100])\n",
+ "\n",
+ " for id, batch_size in enumerate(tqdm.auto.tqdm(batch_sizes)):\n",
+ " start_time = time.time()\n",
+ " # Create a new copy of the model for each batch size\n",
+ " model = copy.deepcopy(base_model)\n",
+ " params = list(model.parameters())\n",
+ " lr = lrs[id]\n",
+ " # Fixed budget per choice of batch size\n",
+ " #initial_vel = [torch.randn_like(p) for p in model.parameters()]\n",
+ " aux_tensors = [torch.zeros_like(_) for _ in params]\n",
+ " while (time.time() - start_time) < float(time_budget):\n",
+ " data, labels = sample_minibatch(x_train, y_train, batch_size)\n",
+ " loss = loss_fn(model(data), labels)\n",
+ " if use_momentum:\n",
+ " momentum_update(loss, params, grad_vel=aux_tensors, lr=lr, beta=0.5)\n",
+ " else:\n",
+ " gradient_update(loss, params, lr=lr)\n",
+ " LOSS_HIST[batch_size].append([time.time() - start_time,\n",
+ " loss.item()])\n",
+ "\n",
+ " fig, axs = plt.subplots(1, len(batch_sizes), figsize=(10, 3))\n",
+ " for ax, batch_size in zip(axs, batch_sizes):\n",
+ " plot_data = np.array(LOSS_HIST[batch_size])\n",
+ " ax.plot(plot_data[:, 0], plot_data[:, 1], label=batch_size,\n",
+ " alpha=0.8)\n",
+ " #ax.set_title('Batch size: ' + str(batch_size) + ' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))\n",
+ " ax.set_title(' #: ' + str(batch_size*len(LOSS_HIST[batch_size])))\n",
+ " ax.set_xlabel('Seconds')\n",
+ " ax.set_ylabel('Loss')\n",
+ " plt.show()\n",
+ " #return(LOSS_HIST)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "e9yCfSXR1The"
+ },
+ "source": [
+ ""
+ ]
+ }
+ ],
+ "metadata": {
+ "accelerator": "GPU",
+ "colab": {
+ "gpuType": "T4",
+ "provenance": [],
+ "toc_visible": true
+ },
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/Notebooks/nikolai/requirements.txt b/Notebooks/nikolai/requirements.txt
new file mode 100644
index 0000000..3f1adb6
--- /dev/null
+++ b/Notebooks/nikolai/requirements.txt
@@ -0,0 +1,212 @@
+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
--
GitLab