FashionMNIST_Dataset-Diffusion_Model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35952ab4",
   "metadata": {},
   "source": [
    "#### Getting Started with FashionMNIST\n",
    "\n",
    "This notebook shows how to load the FashionMNIST dataset in PyTorch and illustrates what kind of samples it contains."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9af543e8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision.datasets import FashionMNIST\n",
    "from torchvision.transforms import ToTensor\n",
    "from torch.utils.data import ConcatDataset\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "import torchvision.transforms as transforms\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm\n",
    "#from utils.dice_score import multiclass_dice_coeff, dice_coeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "601d7d78",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device cuda\n",
      "The combined dataset contains 70000 samples.\n",
      "It contains objects from the following 10 classes:\n",
      "['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] \n",
      "\n",
      "The shape of an image tensor is: torch.Size([1, 28, 28])\n",
      "The shape of a class label is: torch.Size([1])\n"
     ]
    }
   ],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "print(f'Using device {device}')\n",
    "\n",
    "# Transformationen definieren\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5,), (0.5,))  # Normalisiert Daten auf [-1, 1]\n",
    "])\n",
    "\n",
    "# Erstellen Sie eine Instanz des Trainingssplits des FashionMNIST-Datasets\n",
    "dataset_train = FashionMNIST(root='/data/FashionMNIST', train=True, download=True, \n",
    "                             transform=transform, target_transform=lambda x: torch.Tensor([x]).int())\n",
    "\n",
    "# Jetzt erstellen Sie eine Instanz des Testsplits\n",
    "dataset_valid = FashionMNIST(root='/data/FashionMNIST', train=False, download=True, \n",
    "                             transform=transform, target_transform=lambda x: torch.Tensor([x]).int())\n",
    "\n",
    "# Für unsere Zwecke können wir die 60k Training- und 10k Testbeispiele kombinieren\n",
    "from torch.utils.data import ConcatDataset\n",
    "dataset = ConcatDataset([dataset_train, dataset_valid])\n",
    "\n",
    "# Einige Informationen zum Datensatz anzeigen\n",
    "print(f'The combined dataset contains {len(dataset)} samples.')\n",
    "print(f'It contains objects from the following {len(dataset_train.classes)} classes:')\n",
    "print(dataset_train.classes, '\\n')\n",
    "# select a random sample index and load the corresponding data sample\n",
    "sample_idx = random.randrange(len(dataset))\n",
    "# \n",
    "img_tensor, class_label = dataset.__getitem__(sample_idx)\n",
    "trainloader = torch.utils.data.DataLoader(dataset_train, batch_size=256,\n",
    "                                          shuffle=True, num_workers=2)\n",
    "\n",
    "valloader = torch.utils.data.DataLoader(dataset_valid, batch_size=256,\n",
    "                                       shuffle=True, num_workers=2)\n",
    "\n",
    "\n",
    "\n",
    "print('The shape of an image tensor is:', img_tensor.shape)\n",
    "print('The shape of a class label is:', class_label.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9aa20a75",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGFCAYAAAASI+9IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAL3ElEQVR4nO3czYvX9bvH8Wt0HO9vEjMUNWhGE0LKRas2RYuiFv0LbYJq36raBBUURK2jfyGCIlq4CCkokMIoxO7zLm2kyZucGtH57V504Byc681x6nQej/W8+nzVbz77LLomFhcXFwsAqmrF3/0BAPjnEAUAQhQACFEAIEQBgBAFAEIUAAhRACAml/qDExMTN/NzAHCTLeX/VfamAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAxOTf/QH+Ths2bGhvLl++3N6sWrWqvXnnnXfam6qqmZmZ9ubFF19sbw4fPtzejPw+VFVdu3atvbl69eqyPGdqaqq9GfkOVY19vpUrVy7LZrl+76qqFhcXh3ZdI59v3bp1Q8+anZ1tb86fPz/0rBvxpgBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBATCwu8eTgihX9fizXNcPl9Mwzz7Q3r7zySnvz/vvvtzdVYxcuRy47Hjt2rL3ZtGlTe1M1doFz5Ps6Odk/Gjzy2UavxW7ZsqW9WVhYaG92797d3ly6dKm9+eOPP9qb5bR27dr2ZseOHUPP+vDDD9ubxx9/vL1Zyt/J3hQACFEAIEQBgBAFAEIUAAhRACBEAYAQBQBCFAAIUQAgRAGAEAUAYskXwP6Nx+1GDko9//zz7c3ExER7M2rz5s3tzYULF27CJ+F/Mvp9mJmZaW+++eaboWcth23btg3tzp8//7/8Sf5vGj2seCPeFAAIUQAgRAGAEAUAQhQACFEAIEQBgBAFAEIUAAhRACBEAYAQBQBiYnGJl+6W86jbiB07drQ3x44da2/uvPPO9ubcuXPtzd69e9ubqqrJySXfOIz5+fn25uGHH25vzpw5095UVb377rvtzaZNm9qbNWvWtDeXL19ub0b+jKqqVqzo/zfcwsJCe7Nnz5725uTJk+3N7t2725uqqq+//rq9WblyZXszPT3d3txyyy3tTVXVDz/80N6cPXu2vbl+/foNf8abAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAEAs+TLXyEG8Jd7a+y9WrVrV3lRVvfDCC+3Nq6++2t6MHLcbsXXr1qHd77//3t6cPn26vfnggw/am5HvQ1XVrl272puRI39zc3PtzcjBuVHPPvtse/Pee++1NyOH1u677772ZuTPtWrs6NzIwb6Ro4qj1q5d295s3779JnwSbwoA/IUoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAMSSr6SuWNHvx7Vr19qbp556qr2pGrv0eejQoaFnLYfRa6wjf0733ntvezNyqfKzzz5rb6qqLl682N6MXC+dmppqb95888325qeffmpvqqr279/f3rz99tvtzch37/jx4+3NJ5980t5UVc3MzLQ3O3fubG++/fbb9mZ6erq9qRq76rt+/fqhZ92INwUAQhQACFEAIEQBgBAFAEIUAAhRACBEAYAQBQBCFAAIUQAgRAGAWPJBvJHjdg899FB7M3LIrGrs83366adDz1oOa9asWdZd15EjR9qbAwcODD3r1KlT7c3IgbETJ060N6+99lp7c/Dgwfamqurll18e2nWNHDucnZ1tb0aO1FVV/fLLL+3N7t27l2WzevXq9qaqanJyyX8Vx/Xr14eedSPeFAAIUQAgRAGAEAUAQhQACFEAIEQBgBAFAEIUAAhRACBEAYAQBQCif4Wp4a677mpv5ubmhp51/Pjxod0/1ebNm5ftWWfOnGlv1q9f395cuXKlvakaO4i3bdu29ubBBx9sbw4dOtTeHD16tL2pqtq/f3978/3337c3V69ebW/Wrl3b3txxxx3tTVXVRx991N5s3bq1vRk5kDhyTLCq6uzZs+3Nhg0bhp51I94UAAhRACBEAYAQBQBCFAAIUQAgRAGAEAUAQhQACFEAIEQBgBAFAGLJB/GefPLJ9j98fn6+vZmenm5vqqqee+65od2/zeeff97e3H777e3Nvn372psvvviivamqOnjwYHuzevXq9mbkqOLIYcC77767vamq2rlzZ3uzadOm9ubnn39uby5evNjejBycqxo7bjdyVHHk1/TSSy+1N1Vj373XX3996Fk34k0BgBAFAEIUAAhRACBEAYAQBQBCFAAIUQAgRAGAEAUAQhQACFEAIJZ8EO+2225r/8N37drV3jz99NPtzb/RypUrh3ZTU1Ptzcjhry+//LK9mZuba2+qqq5cudLejBzEO3/+fHuzcePG9ubXX39tb6rGjh1eu3atvRn57o1872ZnZ9ub0Wc98MAD7c3HH3/c3rzxxhvtTVXVY4891t488cQTQ8+6EW8KAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAMTE4uLi4pJ+cGLiZn8W/uL+++8f2p0+fbq9OXXqVHuzsLDQ3hw4cKC9qao6d+5cezNy+XVmZqa9+e2339qbkWuso9auXdve/P777+3N9u3b25t77rmnvamqOnr0aHuzatWq9ubHH39sb0atW7euvdmyZUt7s5RfkzcFAEIUAAhRACBEAYAQBQBCFAAIUQAgRAGAEAUAQhQACFEAIEQBgJj8uz8A/72RI3BVY8fM9u3b196cOHGivdm4cWN7U1X1559/tjdXrlxpb/bu3dvefPXVV+3N5OTYv3aPPPJIe3PkyJH2Zm5urr0ZOZh5+PDh9qaq6vr160O7rltvvbW9mZ6eHnrWyZMn25v5+fmhZ92INwUAQhQACFEAIEQBgBAFAEIUAAhRACBEAYAQBQBCFAAIUQAgRAGAcBDvH2rbtm1Du2PHjrU3IwfxHn300fbmrbfeam+qqtavX9/ebNq0qb05evRoezNy3G7VqlXtTVXVd999196sXr26vRn57l26dKm9WbFi7L9JV65c2d4sLi62NyPfu5FDjFVVa9asaW82b9489Kwb8aYAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEBOLS7wUNTExcbM/C38xcoyrqmrPnj3tzcgRry1btrQ3I0fTqqquXr3a3oz8mkaOx424cOHC0G7k92Hk+N6GDRvam4sXL7Y3U1NT7U1V1fz8/NCua+TfwZHDdlVjf7/Ozs62NwsLCzf8GW8KAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCAOEgHsD/E0v5696bAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgAhCgCEKAAQogBAiAIAIQoAhCgAEKIAQEwu9QcXFxdv5ucA4B/AmwIAIQoAhCgAEKIAQIgCACEKAIQoABCiAECIAgDxH1z38eSMc928AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The image shows an instance of Bag.\n"
     ]
    }
   ],
   "source": [
    "# we can also visualize and describe a sample\n",
    "fig, ax = plt.subplots()\n",
    "ax.imshow(img_tensor.cpu().squeeze(), cmap='Greys_r')\n",
    "plt.axis('off')\n",
    "plt.show()\n",
    "print('The image shows an instance of ' + dataset_train.classes[class_label.item()] + '.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4c9f4bf8",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimaler Wert: -1.0\n",
      "Maximaler Wert: 1.0\n"
     ]
    }
   ],
   "source": [
    "min_value = torch.min(img_tensor)\n",
    "max_value = torch.max(img_tensor)\n",
    "\n",
    "print(f\"Minimaler Wert: {min_value.item()}\")\n",
    "print(f\"Maximaler Wert: {max_value.item()}\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7bd4b5c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "\n",
    "\n",
    "\n",
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(\n",
    "        self, in_channels, intermediate_channels, identity_downsample=None, stride=1\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.expansion = 4\n",
    "        self.conv2 = nn.Conv2d(\n",
    "            in_channels,\n",
    "            intermediate_channels,\n",
    "            kernel_size=3,\n",
    "            stride=stride,\n",
    "            padding=1,\n",
    "            bias=False,\n",
    "        )\n",
    "        self.bn2 = nn.BatchNorm2d(intermediate_channels)\n",
    "        self.conv3 = nn.Conv2d(\n",
    "            intermediate_channels,\n",
    "            intermediate_channels * self.expansion,\n",
    "            kernel_size=1,\n",
    "            stride=1,\n",
    "            padding=0,\n",
    "            bias=False,\n",
    "        )\n",
    "        self.bn3 = nn.BatchNorm2d(intermediate_channels * self.expansion)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.identity_downsample = identity_downsample\n",
    "        self.stride = stride\n",
    "\n",
    "    def forward(self, x):\n",
    "        identity = x.clone()\n",
    "\n",
    "        x = self.conv2(x)\n",
    "        x = self.bn2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.bn3(x)\n",
    "\n",
    "        if self.identity_downsample is not None:\n",
    "            identity = self.identity_downsample(identity)\n",
    "\n",
    "        x += identity\n",
    "        x = self.relu(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class ResNet(nn.Module):\n",
    "    def __init__(self, block, layers, image_channels, num_classes):\n",
    "        super(ResNet, self).__init__()\n",
    "        self.in_channels = 64\n",
    "        self.conv1 = nn.Conv2d(\n",
    "            image_channels, 64, kernel_size=7, stride=2, padding=3, bias=False\n",
    "        )\n",
    "        self.bn1 = nn.BatchNorm2d(64)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
    "\n",
    "        # Essentially the entire ResNet architecture are in these 4 lines below\n",
    "        self.layer1 = self._make_layer(\n",
    "            block, layers[0], intermediate_channels=64, stride=1\n",
    "        )\n",
    "        self.layer2 = self._make_layer(\n",
    "            block, layers[1], intermediate_channels=128, stride=2\n",
    "        )\n",
    "        self.layer3 = self._make_layer(\n",
    "            block, layers[2], intermediate_channels=256, stride=2\n",
    "        )\n",
    "        self.layer4 = self._make_layer(\n",
    "            block, layers[3], intermediate_channels=512, stride=2\n",
    "        )\n",
    "\n",
    "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        self.fc = nn.Linear(512 * 4, num_classes)\n",
    "\n",
    "        #self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
    "        #self.fc1 = nn.Linear(128 * 4, 128)\n",
    "        #self.fc2 = nn.Linear(128, 84)\n",
    "        #self.fc3 = nn.Linear(84, num_classes)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.bn1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.maxpool(x)\n",
    "        x = self.layer1(x)\n",
    "        x = self.layer2(x)\n",
    "        x = self.layer3(x)\n",
    "        x = self.layer4(x)\n",
    "\n",
    "        x = self.avgpool(x)\n",
    "        x = x.reshape(x.shape[0], -1)\n",
    "        x = self.fc(x)\n",
    "        #x = self.fc1(x)\n",
    "        #x = self.relu(x)\n",
    "        #x = self.fc2(x)\n",
    "        #x = self.relu(x)\n",
    "        #x = self.fc3(x)\n",
    "        \n",
    "\n",
    "        return x\n",
    "\n",
    "    def _make_layer(self, block, num_residual_blocks, intermediate_channels, stride):\n",
    "        identity_downsample = None\n",
    "        layers = []\n",
    "\n",
    "        # Either if we half the input space for ex, 56x56 -> 28x28 (stride=2), or channels changes\n",
    "        # we need to adapt the Identity (skip connection) so it will be able to be added\n",
    "        # to the layer that's ahead\n",
    "        if stride != 1 or self.in_channels != intermediate_channels * 4:\n",
    "            identity_downsample = nn.Sequential(\n",
    "                nn.Conv2d(\n",
    "                    self.in_channels,\n",
    "                    intermediate_channels * 4,\n",
    "                    kernel_size=1,\n",
    "                    stride=stride,\n",
    "                    bias=False,\n",
    "                ),\n",
    "                nn.BatchNorm2d(intermediate_channels * 4),\n",
    "            )\n",
    "\n",
    "        layers.append(\n",
    "            block(self.in_channels, intermediate_channels, identity_downsample, stride)\n",
    "        )\n",
    "\n",
    "        # The expansion size is always 4 for ResNet 50,101,152\n",
    "        self.in_channels = intermediate_channels * 4\n",
    "\n",
    "        # For example for first resnet layer: 256 will be mapped to 64 as intermediate layer,\n",
    "        # then finally back to 256. Hence no identity downsample is needed, since stride = 1,\n",
    "        # and also same amount of channels.\n",
    "        for i in range(num_residual_blocks - 1):\n",
    "            layers.append(block(self.in_channels, intermediate_channels))\n",
    "\n",
    "        return nn.Sequential(*layers)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "71a85073",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# handvoll resisdual basic blocks -> flatten -> handvoll fully conntected layers\n",
    "# resnet basic block : conv3x3 + norm_layer + non_lin + conv3x3 + normlayer\n",
    "# identity: conv1x1 + norm layer\n",
    "# output: non_lin(identity_layers(x) + [conv3x3 + norm_layer + non_lin + conv3x3 + normlayer](x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "be418e5d",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def create_linear_schedule(steps, start, end):\n",
    "    step_size = (end - start) / (steps - 1)  \n",
    "    linear_schedule = []\n",
    "    for i in range(steps):\n",
    "        linear_schedule.append(start + i * step_size)\n",
    "    return linear_schedule\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "40cc4ad2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def normalize_image(image):\n",
    "    min_value = torch.min(image)\n",
    "    max_value = torch.max(image)\n",
    "    \n",
    "    normalized_image = 2 * ((image - min_value) / (max_value - min_value)) - 1\n",
    "    return normalized_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b1f9834e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Function to add Gaussian noise to an image tensor\n",
    "def add_gaussian_noise(image, mean=0., std=1.):\n",
    "    eps = torch.empty_like(image).normal_(mean=0,std=1)\n",
    "    noise = eps * std + mean\n",
    "    # beta*eps + sqrt(1-beta)*image+std # (1-beta).sqrt()*image + beta*eps\n",
    "    # Clip the values to be between 0 and 1\n",
    "    # noisy_image = normalize_image(noisy_image)\n",
    "    return noise, eps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f0d61a99",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def one_forward_step(curr_image, beta):\n",
    "    std = np.sqrt(beta) #* np.random.normal()#* np.identity(like=curr_image) Nicht notwendig da äquivalent zu Skalar von Rechts\n",
    "    mean = np.sqrt(1-beta) * curr_image #+ std\n",
    "    image, eps = add_gaussian_noise(curr_image,mean=mean,std=std)\n",
    "    return image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "72186b88",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def mache_noise(image, anzahl_bilder):\n",
    "    # Convert the image to a PyTorch tensor\n",
    "    # transform = transforms.ToTensor()\n",
    "    # image_tensor = transform(image)\n",
    "    \n",
    "    # Display the original image\n",
    "    plt.imshow(image.cpu().squeeze())\n",
    "    plt.title(\"Original Image\")\n",
    "    plt.show()\n",
    "    \n",
    "    verrauschte_bilder = []\n",
    "    schedule = create_linear_schedule(anzahl_bilder, 0.0001, 0.02)\n",
    "    print(schedule)\n",
    "    noisy_image_tensor = image\n",
    "    for i in range(len(schedule)):\n",
    "        noisy_image_tensor = one_forward_step(noisy_image_tensor, schedule[i])\n",
    "        \n",
    "        # Convert the noisy image tensor back to a PIL image\n",
    "        noisy_image = ((noisy_image_tensor/2)+0.5).cpu().squeeze()\n",
    "        \n",
    "        verrauschte_bilder.append(noisy_image)\n",
    "        \n",
    "        # Optional: Display each noisy image if desired\n",
    "        plt.imshow(noisy_image, cmap='Greys_r')\n",
    "        plt.title(f\"Noisy Image {i+1}: {noisy_image_tensor.mean()}, {noisy_image_tensor.std()}\")\n",
    "        plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7ba15087",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def berechne_alpha_quer_x_forward_steps(anzahl_steps):\n",
    "    scheduler = create_linear_schedule(anzahl_steps, 0.0001, 0.02)\n",
    "    alphas = 1 - np.array(scheduler)\n",
    "    alphas_quer = []\n",
    "    for i in range(len(alphas)):\n",
    "        alphas_quer.append(np.prod(alphas[:i + 1]))\n",
    "    return alphas_quer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e189aa1c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def x_forward_steps(curr_image, alpha_quer):\n",
    "    alpha_quer = torch.tensor(alpha_quer, dtype=torch.float32).to(device)  # 'device' is your CUDA device\n",
    "    std = torch.sqrt(1 - alpha_quer)\n",
    "    mean = torch.sqrt(alpha_quer) * curr_image\n",
    "    new_image, eps = add_gaussian_noise(curr_image,mean=mean,std=std)\n",
    "    return new_image, eps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3a2d9217",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def mache_noise_direkt(image, anzahl_steps, total_steps=1000):\n",
    "    # Convert the image to a PyTorch tensor\n",
    "    # transform = transforms.ToTensor()\n",
    "    # image_tensor = transform(image)\n",
    "    \n",
    "    noisy_image_tensor = image\n",
    "    \n",
    "    alpha_quer = berechne_alpha_quer_x_forward_steps(total_steps)\n",
    "    \n",
    "    noisy_image_tensor, eps = x_forward_steps(noisy_image_tensor, alpha_quer[anzahl_steps-1])\n",
    "    noisy_image = ((noisy_image_tensor/2)+0.5).cpu().squeeze()\n",
    "    \n",
    "    return noisy_image_tensor, eps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f6c49460",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def mache_noise_direkt_random(batch_images, total_steps=1000, device=device):\n",
    "    # Verschieben Sie den Batch auf die GPU\n",
    "    batch_images = batch_images.to(device)\n",
    "    \n",
    "    # Annahme: batch_images hat die Form [batch_size, channels, height, width]\n",
    "    batch_size = batch_images.size(0)\n",
    "    \n",
    "    alpha_quer_list = berechne_alpha_quer_x_forward_steps(total_steps)\n",
    "    alpha_quer = torch.tensor(alpha_quer_list, device=device)\n",
    "\n",
    "    noisy_batch = []\n",
    "    epsilons = []\n",
    "    anzahl_steps_array = np.empty(batch_size)\n",
    "    # for loop vernichten\n",
    "    for i in range(batch_size):\n",
    "        anzahl_steps = np.random.randint(total_steps)\n",
    "        anzahl_steps_array[i] = anzahl_steps\n",
    "        \n",
    "        image = batch_images[i]\n",
    "        noisy_image, eps = x_forward_steps(image.unsqueeze(0).to(device), alpha_quer[anzahl_steps-1])  # Verschieben auf die GPU\n",
    "        \n",
    "        noisy_batch.append(noisy_image)\n",
    "        epsilons.append(eps)\n",
    "    \n",
    "    noisy_batch_tensor = torch.cat(noisy_batch, dim=0).to(device)  # Verschieben auf die GPU\n",
    "    epsilons_tensor = torch.cat(epsilons, dim=0).to(device)  # Verschieben auf die GPU\n",
    "    \n",
    "    return noisy_batch_tensor, epsilons_tensor, anzahl_steps_array\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a368202d",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "class DoubleConv(nn.Module):\n",
    "    \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\n",
    "\n",
    "    def __init__(self, in_channels, out_channels, mid_channels=None):\n",
    "        super().__init__()\n",
    "        if not mid_channels:\n",
    "            mid_channels = out_channels\n",
    "        self.double_conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(mid_channels),\n",
    "            nn.LeakyReLU(inplace=True),\n",
    "            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.LeakyReLU(inplace=True)\n",
    "            \n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.double_conv(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4f58bee0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class DownStride(nn.Module):\n",
    "    \"\"\"(convolution => [BN] => ReLU) * 2\"\"\"\n",
    "\n",
    "    def __init__(self, in_channels, out_channels, mid_channels=None):\n",
    "        super().__init__()\n",
    "        if not mid_channels:\n",
    "            mid_channels = out_channels\n",
    "        self.double_conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels, mid_channels, kernel_size=3, stride=2, padding=1),\n",
    "            nn.BatchNorm2d(mid_channels),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.double_conv(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "131a034f",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class Down(nn.Module):\n",
    "    \"\"\"Downscaling with maxpool then double conv\"\"\"\n",
    "\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super().__init__()\n",
    "        self.maxpool_conv = nn.Sequential(\n",
    "            #nn.MaxPool2d(2),\n",
    "            nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(in_channels),\n",
    "            nn.LeakyReLU(inplace=True),\n",
    "            DoubleConv(in_channels, out_channels)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.maxpool_conv(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "3b52c0ea",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def leaky_relu_init(m, negative_slope=0.2):\n",
    "    gain = np.sqrt(2.0 / (1.0 + negative_slope ** 2))\n",
    "    if isinstance(m, torch.nn.Conv1d):\n",
    "        ksize = m.kernel_size[0]\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.Conv2d):\n",
    "        ksize = m.kernel_size[0] * m.kernel_size[1]\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.Conv3d):\n",
    "        ksize = m.kernel_size[0] * m.kernel_size[1] * m.kernel_size[2]\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.ConvTranspose1d):\n",
    "        ksize = m.kernel_size[0] // 2\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.ConvTranspose2d):\n",
    "        ksize = m.kernel_size[0] * m.kernel_size[1] // 4\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.ConvTranspose3d):\n",
    "        ksize = m.kernel_size[0] * m.kernel_size[1] * m.kernel_size[2] // 8\n",
    "        n1 = m.in_channels\n",
    "        n2 = m.out_channels\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / ((n1 + n2) * ksize))\n",
    "    elif isinstance(m, torch.nn.Linear):\n",
    "        n1 = m.in_features\n",
    "        n2 = m.out_features\n",
    "\n",
    "        std = gain * np.sqrt(2.0 / (n1 + n2))\n",
    "    else:\n",
    "        return\n",
    "\n",
    "    # is_wnw = is_weight_norm_wrapped(m)\n",
    "    # if is_wnw:\n",
    "    #     m.fuse()\n",
    "\n",
    "    m.weight.data.uniform_(-std * np.sqrt(3.0), std * np.sqrt(3.0))\n",
    "    if m.bias is not None:\n",
    "        m.bias.data.zero_()\n",
    "\n",
    "\n",
    "    # blockwise initialization for transposed convs\n",
    "    if isinstance(m, torch.nn.ConvTranspose2d):\n",
    "        # hardcoded for stride=2 for now\n",
    "        m.weight.data[:, :, 0::2, 1::2] = m.weight.data[:, :, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 0::2] = m.weight.data[:, :, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 1::2] = m.weight.data[:, :, 0::2, 0::2]\n",
    "\n",
    "    if isinstance(m, torch.nn.ConvTranspose3d):\n",
    "        # hardcoded for stride=2 for now\n",
    "        m.weight.data[:, :, 0::2, 0::2, 1::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 0::2, 1::2, 0::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 0::2, 1::2, 1::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 0::2, 0::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 0::2, 1::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 1::2, 0::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "        m.weight.data[:, :, 1::2, 1::2, 1::2] = m.weight.data[:, :, 0::2, 0::2, 0::2]\n",
    "\n",
    "    # if is_wnw:\n",
    "        # m.unfuse()\n",
    "\n",
    "def apply_weight_init_fn(m, fn, negative_slope=1.0):\n",
    "    should_initialize_weight=True\n",
    "    if not hasattr(m, \"weights_initialized\"): #if we don't have this then we need to intiialzie\n",
    "        # fn(m, is_linear, scale)\n",
    "        should_initialize_weight=True\n",
    "    elif m.weights_initialized==False: #if we have it but it's set to false\n",
    "        # fn(m, is_linear, scale)\n",
    "        should_initialize_weight=True\n",
    "    else:\n",
    "        print(\"skipping weight init on \", m)\n",
    "        should_initialize_weight=False\n",
    "\n",
    "    if should_initialize_weight:\n",
    "        # fn(m, is_linear, scale)\n",
    "        fn(m,negative_slope)\n",
    "        # m.weights_initialized=True\n",
    "        for module in m.children():\n",
    "            apply_weight_init_fn(module, fn, negative_slope)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "15a5af25",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Comments inspired from https://distill.pub/2016/deconv-checkerboard/\n",
    "\n",
    "#Stride 1 deconvolutions — which we often see as the last layer in successful models \n",
    "#(eg. [2])  — are quite effective at dampening artifacts. \n",
    "#In particular, deconvolution has uneven overlap when the kernel size \n",
    "#(the output window size) is not divisible by the stride (the spacing between points on the top).\n",
    "\n",
    "class Up(nn.Module):\n",
    "    \"\"\"Upscaling then double conv\"\"\"\n",
    "\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super().__init__()\n",
    "\n",
    "        \n",
    "        self.up = nn.Sequential(\n",
    "            nn.ConvTranspose2d(in_channels, out_channels, kernel_size=4, stride=2, padding=1, bias=False),\n",
    "            nn.BatchNorm2d(out_channels),\n",
    "            nn.LeakyReLU(inplace=True))\n",
    "        self.conv = DoubleConv(in_channels, out_channels, in_channels // 2)\n",
    "\n",
    "    def forward(self, x1, x2):\n",
    "        x1 = self.up(x1)\n",
    "        # input is CHW\n",
    "        #Diese Zeilen berechnen die Größenunterschiede\n",
    "        #in den Höhen- und Breitenrichtungen zwischen x2 und dem upgesampleten x1.\n",
    "        diffY = x2.size()[2] - x1.size()[2]\n",
    "        diffX = x2.size()[3] - x1.size()[3]\n",
    "        \n",
    "        #Diese Zeile fügt x1 an den Rändern Polster hinzu, \n",
    "        #sodass es die gleiche räumliche Größe wie x2 hat. Das \n",
    "        #Padding sorgt dafür, dass die beiden Feature-Maps aneinander angehängt werden können.\n",
    "\n",
    "        x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,\n",
    "                        diffY // 2, diffY - diffY // 2])\n",
    "        x = torch.cat([x2, x1], dim=1)\n",
    "        return self.conv(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "110c86bc",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class OutConv(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels):\n",
    "        super(OutConv, self).__init__()\n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.conv(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "fd7cfd9b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def get_sinusoid_encoding_table(n_position, d_hid):\n",
    "    ''' Sinusoid position encoding table '''\n",
    "\n",
    "    def get_position_angle_vec(position):\n",
    "        return [position / np.power(10000, 2 * (hid_j // 2) / d_hid) for hid_j in range(d_hid)]\n",
    "\n",
    "    sinusoid_table = np.array([get_position_angle_vec(pos_i) for pos_i in range(n_position)])\n",
    "    sinusoid_table[:, 0::2] = np.sin(sinusoid_table[:, 0::2])  # dim 2i\n",
    "    sinusoid_table[:, 1::2] = np.cos(sinusoid_table[:, 1::2])  # dim 2i+1\n",
    "\n",
    "    return torch.FloatTensor(sinusoid_table)#.unsqueeze(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b468cb3f",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def concat_pos_param(x, enc):\n",
    "    if x.shape[0] == 1:\n",
    "        pos_enc_reshape = enc[None,:,None,None].expand((-1,-1,x.shape[-2],x.shape[-1]))\n",
    "        feature_map_with_encoding = torch.cat([x.to(device), pos_enc_reshape.to(device)], dim=1)\n",
    "    else: \n",
    "        pos_enc_reshape = enc[:,:,None,None].expand((-1,-1,x.shape[-2],x.shape[-1]))\n",
    "        feature_map_with_encoding = torch.cat([x.to(device), pos_enc_reshape.to(device)], dim=1)\n",
    "    return feature_map_with_encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4af2f519",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "class UNet(nn.Module):\n",
    "    def __init__(self, n_channels, n_classes, t_max=1000, d_hid=32, channels=[64,128,256,512,1024,2048]):\n",
    "        super(UNet, self).__init__()\n",
    "        assert len(channels) == 6\n",
    "        self.n_channels = n_channels\n",
    "        self.n_classes = n_classes\n",
    "        \n",
    "        factor = 2\n",
    "        self.pos_enc = nn.parameter.Parameter(get_sinusoid_encoding_table(t_max, d_hid), requires_grad=False)\n",
    "        #self.pos_enc.requires_grad = False \n",
    "        self.inc = (DoubleConv(n_channels + d_hid, channels[0]))\n",
    "        self.down1 = (Down(channels[0] + d_hid, channels[1]))\n",
    "        self.down2 = (Down(channels[1] + d_hid, channels[2]))\n",
    "        self.down3 = (Down(channels[2] + d_hid, channels[3]))\n",
    "        self.down4 = (Down(channels[3] + d_hid, channels[4]))\n",
    "        self.down5 = (Down(channels[4] + d_hid, channels[5]))\n",
    "        self.up1 = (Up(channels[-1], channels[-2]))\n",
    "        self.up2 = (Up(channels[-2], channels[-3]))\n",
    "        self.up3 = (Up(channels[-3], channels[-4]))\n",
    "        self.up4 = (Up(channels[-4], channels[-5]))\n",
    "        self.up5 = (Up(channels[-5], channels[-6]))\n",
    "        self.outc = (OutConv(channels[-6], n_channels))\n",
    "        apply_weight_init_fn(self, leaky_relu_init, negative_slope=0.0)\n",
    "\n",
    "    def forward(self, x, t):\n",
    "        enc = self.pos_enc[t]\n",
    "        #enc_reshape = enc[:,:,None,None].expand((-1,-1,x.shape[-2],x.shape[-1]))\n",
    "        #enc = self.pos_enc[t]\n",
    "        #print(torch.cat([x, enc_reshape],dim=1).shape)\n",
    "        x1 = self.inc(concat_pos_param(x,enc))\n",
    "        x2 = self.down1(concat_pos_param(x1, enc))\n",
    "        x3 = self.down2(concat_pos_param(x2, enc))\n",
    "        x4 = self.down3(concat_pos_param(x3, enc))\n",
    "        x5 = self.down4(concat_pos_param(x4, enc))\n",
    "        x6 = self.down5(concat_pos_param(x5, enc))\n",
    "        #x7 = self.bottleneck(x7)\n",
    "        #x4 = self.down3(x3)\n",
    "        #x5 = self.down4(x4)\n",
    "        #x = self.up1(x5, x4)\n",
    "        \n",
    "        x = self.up1(x6, x5)\n",
    "        x = self.up2(x, x4)\n",
    "        x = self.up3(x, x3)\n",
    "        x = self.up4(x, x2)\n",
    "        x = self.up5(x, x1)\n",
    "        logits = self.outc(x)\n",
    "        return logits\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "28e8967a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# LeakyRelu\n",
    "unet = UNet(1,100)\n",
    "unet = unet.to(device)\n",
    "dataiter = iter(trainloader)\n",
    "i, data = next(dataiter)\n",
    "i = i.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e474746d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([5, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "unet.to(device)\n",
    "B, H, W = 5, 28, 28\n",
    "ts = torch.randint(0,1001, size=(B,)).long().to(device)\n",
    "xs = torch.randn(size=(B,1,H,W)).to(device)\n",
    "test = unet(xs, ts)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bb60c80c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([5, 32])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pos_enc_func = unet.pos_enc\n",
    "print(pos_enc_func[torch.tensor([10,5,3,1,42]).long()].shape)\n",
    "for fingerprint in pos_enc_func[torch.tensor([10,5,3,1,42]).long()]:\n",
    "    plt.plot(fingerprint.cpu())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c5ddbcd3",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "for j in range(1):\n",
    "    img = unet(i, 5).to(device)\n",
    "    img = img.cpu().detach().numpy()[0, j, :, :]\n",
    "    plt.imshow(img, cmap='gray')  # `cmap='gray'` wird verwendet, da es sich um ein Graustufenbild handelt\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "3dd41728",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(i[0, 0, :, :].cpu(), cmap='gray')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "83b93ba2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "learning_rate = 0.002\n",
    "criterion = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(unet.parameters(), lr=learning_rate, weight_decay = 0.001)\n",
    "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.5, patience=10, verbose=True)\n",
    "\n",
    "def evaluate(net, dataloader, device):\n",
    "    net.eval()\n",
    "    num_val_batches = len(dataloader)\n",
    "    \n",
    "\n",
    "    \n",
    "    progress_bar = tqdm(dataloader, total=num_val_batches, desc='Validation round', unit='batch', leave=False)\n",
    "    for batch in progress_bar:\n",
    "        image, mask_true = batch[0], batch[1]\n",
    "\n",
    "            # move images and labels to correct device and type\n",
    "        image = image.to(dtype=torch.float32, memory_format=torch.channels_last).cpu()\n",
    "        noisy_image, eps, anzahl_schritte = mache_noise_direkt_random(image)\n",
    "        mask_true = mask_true.to(dtype=torch.long)\n",
    "        \n",
    "        mask_pred = net(noisy_image, anzahl_schritte).to(device)\n",
    "        \n",
    "        loss = criterion(mask_pred, eps)\n",
    "        \n",
    "        \n",
    "\n",
    "\n",
    "    net.train()\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "28bb522f",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#unet = torch.load('best_fmnist_model_vol2.pt')\n",
    "#unet.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1f5632aa",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def train_model(\n",
    "        model,\n",
    "        device,\n",
    "        epochs: int = 0,\n",
    "        learning_rate: float = 1e-2,\n",
    "        val_percent: float = 0.1,\n",
    "        img_scale: float = 0.5,\n",
    "        weight_decay: float = 1e-8,\n",
    "        gradient_clipping: float = 1.0,\n",
    "):\n",
    "    \n",
    "    min_loss = 1e25\n",
    "    progress_bar = tqdm(range(epochs), total=epochs, position=0, leave=True)\n",
    "    for epoch in progress_bar:\n",
    "        mean_epoch_loss = []\n",
    "        model.train()\n",
    "        running_loss = 0.0\n",
    "        for i, data in enumerate(trainloader):\n",
    "            image, mask_true = [t.to(device) for t in data]\n",
    "            progress_bar.set_postfix({f'T of {[len(trainloader)]}' : i+1, 'Best loss': min_loss}, refresh=True)\n",
    "            optimizer.zero_grad()\n",
    "                # move images and labels to correct device and type\n",
    "            image = image.to(dtype=torch.float32, memory_format=torch.channels_last)\n",
    "            noisy_image, eps, anzahl_schritte = mache_noise_direkt_random(image)\n",
    "            mask_true = mask_true.to(dtype=torch.long)\n",
    "\n",
    "            mask_pred = model(noisy_image, anzahl_schritte).to(device)\n",
    "\n",
    "            loss = criterion(mask_pred, eps)\n",
    "            mean_epoch_loss.append(loss.item())\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            \n",
    "            running_loss += loss.item()\n",
    "        \n",
    "        loss_mean = np.mean(mean_epoch_loss)\n",
    "        # scheduler on loss_mean with patience 10 with more aggressive learning rate\n",
    "        scheduler.step(loss_mean)\n",
    "        if loss_mean < min_loss:\n",
    "            min_loss = loss_mean\n",
    "            #torch.save(model, 'fmnist_model_latent.pt')\n",
    "        if epoch%100==0:\n",
    "            print('---')\n",
    "            print(f\"Epoch: {epoch} | Train Loss: {loss_mean} | Best Loss: {min_loss}\")\n",
    "\n",
    "                \n",
    "    evaluate(model, valloader, device) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "2a4a8046",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0it [00:00, ?it/s]\n",
      "Validation round:   0%|                                                                                                                                                                  | 0/40 [00:00<?, ?batch/s]/tmp/ipykernel_233722/1524519049.py:2: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  alpha_quer = torch.tensor(alpha_quer, dtype=torch.float32).to(device)  # 'device' is your CUDA device\n",
      "                                                                                                                                                                                                                   \r"
     ]
    }
   ],
   "source": [
    "train_model(unet, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d0d5135b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def try_to_revert(noise, eps, anzahl_schritte, total_schritte=1000):\n",
    "    alpha_quers = berechne_alpha_quer_x_forward_steps(total_schritte)\n",
    "    return (noise - eps * np.sqrt(1-alpha_quers[anzahl_schritte - 1]))/np.sqrt(alpha_quers[anzahl_schritte - 1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "adee373c",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UNet(\n",
       "  (inc): DoubleConv(\n",
       "    (double_conv): Sequential(\n",
       "      (0): Conv2d(33, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (down1): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): Conv2d(96, 96, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "          (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down2): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): Conv2d(160, 160, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(160, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "          (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down3): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): Conv2d(288, 288, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(288, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "          (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down4): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): Conv2d(544, 544, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(544, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "          (3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down5): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): Conv2d(1056, 1056, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(1056, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      (3): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(1056, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "          (3): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "          (4): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up1): Up(\n",
       "    (up): Sequential(\n",
       "      (0): ConvTranspose2d(2048, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(2048, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        (3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up2): Up(\n",
       "    (up): Sequential(\n",
       "      (0): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up3): Up(\n",
       "    (up): Sequential(\n",
       "      (0): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up4): Up(\n",
       "    (up): Sequential(\n",
       "      (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up5): Up(\n",
       "    (up): Sequential(\n",
       "      (0): ConvTranspose2d(128, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "    )\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "        (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): LeakyReLU(negative_slope=0.01, inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (outc): OutConv(\n",
       "    (conv): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unet = torch.load('best_fmnist_model_vol2.pt')\n",
    "unet.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "1b53b845",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGzCAYAAABpdMNsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+B0lEQVR4nO3deVyU5f4//hciDIgsKnuCIiiouCQpmmuJopl75dZJzdJOWC7f02J5XDoLZX3MU7kcO4XaCbdjRnpKcwNLwRQ1M8sFcQsFN3ZZhOv3hz/mOAIy7zvwQn09H495PGDmes19zT338Oae+5732CilFIiIiO6wOronQERE9ycWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAyO3XqFGxsbPDee+/pnkq1WbZsGWxsbHDq1Cnzdb169UKvXr2qzMbHx8PGxgbx8fFWLWvevHkICQlBaWmpeJ7jxo1D06ZNxbmaYmNjg8mTJ9f4cpo2bYpx48bV+HJq2/rVpbi4GH5+fli0aJHuqQC4jwrQoEGDUK9ePeTk5FQ6ZsyYMbC3t8fly5fv4MzuTl9//TXmzJmjZdm9evWCjY2N+WJvb4+AgABMnDgRZ8+e1TKn7OxsvPPOO3jttddQp87/XlY3z/PWywsvvKBlrnRnNG3aFDY2NnjppZfK3Vb2z81//vMf8f2mpaVhzpw5OHjwoDhrZ2eH6dOn429/+xsKCgrE+epWV/cE7pQxY8Zgw4YNWL9+PZ555plyt+fn5yMuLg79+vVDo0aNNMzw7vL1119j4cKF2opQ48aNER0dDQAoKirCkSNHsGTJEmzevBm//PIL6tWrBwD4wx/+gJEjR8JkMtXofD799FNcv34do0aNKndbnz59KtzmWrRoYf75448/NrTndLc7evSoRcG+F3388ceYMWMGfH19q+X+0tLSMHfuXDRt2hTt27cX58ePH4/XX38dsbGxePbZZ6tlTkbdNwVo0KBBcHZ2RmxsbIV/DOLi4pCXl4cxY8b8ruVcv34dpaWlsLe3L3dbXl4enJycftf90w2urq54+umnLa4LCAjA5MmTsWvXLvTp0wcAYGtrC1tb2xqfT0xMDAYNGgQHB4dyt7Vo0aLcXG9lZ2dXU1Or1Wr6HwPdWrdujaNHj+Ltt9/GBx98oHs6AAA3Nzf07dsXy5Yt016A7u1/PW7i6OiIYcOGYdu2bcjIyCh3e2xsLJydnTFo0CAAQGZmJqZOnQo/Pz+YTCYEBQXhnXfesfgv9eZjJgsWLEBgYCBMJhOOHDmCOXPmwMbGBkeOHMHo0aPRoEEDdOvWDQBw6NAhjBs3Ds2aNYODgwO8vb3x7LPPlnvrr7L3rcvu+2ZbtmxBt27d4Obmhvr16yM4OBhvvPGGxZiCggLMmTMHLVq0gIODA3x8fDBs2DCkpKSUW8bSpUvNj6djx47Yu3evxbwWLlwIwPItpjKlpaVYsGABWrduDQcHB3h5eWHSpEm4evWqxTL27duHyMhIuLu7w9HREQEBAb/rBeHt7Q0AqFv3f/9XVXQMqCLnzp3DkCFD4OTkBE9PT0ybNg2FhYVWLTc1NRWHDh1CRESE4bnf+lzfvG3d7rkos3btWrRq1QoODg4IDQ3F+vXrK9x+3nvvPTz88MNo1KgRHB0dERYWdtu3gT7//HMEBwfDwcEBYWFh2LlzZ7kxv/32G5599ll4eXnBZDKhdevW+PTTT6163LceAyp7vnbt2oXp06fDw8MDTk5OGDp0KC5evGjVfX755ZcIDQ21WBcVsXZdWPPaut3je+aZZ/Dxxx8jLS2tyvFVrcv4+Hh07NgRwI09mbLX3rJly8zrrqLLrcc8+/Tpg++//x5Xrlyx6nHUlPtmDwi48Tbc8uXLsWbNGosDrFeuXMHmzZsxatQoODo6Ij8/Hz179sRvv/2GSZMmwd/fH7t378aMGTNw/vx5LFiwwOJ+Y2JiUFBQgIkTJ8JkMqFhw4bm25588kk0b94cf//731H2zRdbtmzByZMnMX78eHh7e+Pnn3/G0qVL8fPPPyMpKalccanKzz//jMcffxxt27bFW2+9BZPJhBMnTmDXrl3mMSUlJXj88cexbds2jBw5ElOmTEFOTg62bNmCw4cPIzAw0Dw2NjYWOTk5mDRpEmxsbDBv3jwMGzYMJ0+ehJ2dHSZNmoS0tDRs2bIFn332Wbn5TJo0CcuWLcP48ePx8ssvIzU1FR999BEOHDiAXbt2wc7ODhkZGejbty88PDzw+uuvw83NDadOncIXX3xh1WMuKSnBpUuXANw4sPrLL79g9uzZCAoKQteuXUXr79q1a+jduzfOnDmDl19+Gb6+vvjss8+wfft2q/K7d+8GAHTo0KHC2wsKCsxzvZmLi0uFe8o3q+q5AID//ve/GDFiBNq0aYPo6GhcvXoVEyZMwAMPPFDu/v7xj39g0KBBGDNmDIqKirBq1So8+eST2LhxIwYMGGAxNiEhAatXr8bLL78Mk8mERYsWoV+/fvjhhx8QGhoKAEhPT0fnzp3NJy14eHjgm2++wYQJE5CdnY2pU6dWuf4q8tJLL6FBgwaYPXs2Tp06hQULFmDy5MlYvXr1bXPffvsthg8fjlatWiE6OhqXL1/G+PHj0bhxY0PrwprXVlXefPNNrFixosq9IGvWZcuWLfHWW29h1qxZmDhxIrp37w4AePjhhwGg3Ovx9OnTmDlzJjw9PS2uDwsLg1IKu3fvxuOPP271Y6l26j5y/fp15ePjo7p06WJx/ZIlSxQAtXnzZqWUUn/5y1+Uk5OTOnbsmMW4119/Xdna2qozZ84opZRKTU1VAJSLi4vKyMiwGDt79mwFQI0aNarcPPLz88tdt3LlSgVA7dy503zd2LFjVZMmTcqNLbvvMu+//74CoC5evFjpY//0008VADV//vxyt5WWllo8nkaNGqkrV66Yb4+Li1MA1IYNG8zXRUVFqYo2n++++04BUJ9//rnF9Zs2bbK4fv369QqA2rt3b6VzrkzPnj0VgHKXli1bqpMnT1qMjYmJUQBUamqqRb5nz57m3xcsWKAAqDVr1pivy8vLU0FBQQqA2rFjx23nM3PmTAVA5eTklLutonmWXVauXGked+tzLXku2rRpoxo3bmyx/Pj4eAWg3PZz67ZXVFSkQkND1aOPPlrhvPft22e+7vTp08rBwUENHTrUfN2ECROUj4+PunTpkkV+5MiRytXVtcJt/WZNmjRRY8eONf9e9nxFRESYt0ullJo2bZqytbVVmZmZt72/9u3bKx8fH4tx3377reF1Yc1r63aPbcCAAUoppcaPH68cHBxUWlqaUkqpHTt2KABq7dq15vHWrsu9e/cqAComJua2y7927ZoKCwtTvr6+6vz58xa3paWlKQDqnXfeET+u6nTfvAUH3DgeMHLkSCQmJlq8JRMbGwsvLy/07t0bwI23M7p3744GDRrg0qVL5ktERARKSkrKvQ0xfPhweHh4VLjMis50cnR0NP9c9t9x586dAQD79+8XPy43NzcAN45jVXYge926dXB3d6/wjJxb97hGjBiBBg0amH8v+y/r5MmTVc5l7dq1cHV1RZ8+fSzWXVhYGOrXr48dO3ZYzHnjxo0oLi6u8n5v1bRpU2zZsgVbtmzBN998gwULFiArKwv9+/e3+q2aMl9//TV8fHzwxBNPmK+rV68eJk6caFX+8uXLqFu3LurXr1/h7YMHDzbP9ebLI488UuV9V/VcpKWl4aeffsIzzzxjsfyePXuiTZs25e7v5m3v6tWryMrKQvfu3Svc7rp06YKwsDDz7/7+/hg8eDA2b96MkpISKKWwbt06DBw4EEopi+c7MjISWVlZhrZnAJg4caLFdtm9e3eUlJTg9OnTlWbOnz+PgwcPYuzYsXB1dTVf36dPH7Rq1arceGvWhTWvLWvMnDkT169fx9tvv13h7TWxLl988UX89NNPWLdunfnt6TJl21RFe+Z30n1VgACYTzKIjY0FcOO9/++++w4jR440H6w+fvw4Nm3aBA8PD4tL2Xv8tx5DCggIqHR5Fd125coVTJkyBV5eXnB0dISHh4d5XFZWlvgxjRgxAl27dsVzzz0HLy8vjBw5EmvWrLF4waSkpCA4ONji+Ehl/P39LX4v21hvPYZTkePHjyMrKwuenp7l1l9ubq553fXs2RPDhw/H3Llz4e7ujsGDByMmJsbq4y5OTk6IiIhAREQE+vXrhylTpuCrr74yH/CVOH36NIKCgsoV4uDgYNH9VKZx48bmud588fLyqjJb1XNR9gc5KCioXLai6zZu3IjOnTvDwcEBDRs2hIeHBxYvXlzhdte8efNy17Vo0QL5+fm4ePEiLl68iMzMTCxdurTccz1+/HgA5V8r1jKyDZati4rmXdFzac26sOa1ZY1mzZrhD3/4A5YuXYrz58+Xu7261+U///lPxMTE4MMPPzT/c3sz9f8fDpC+3V/d7qtjQMCN9z5DQkKwcuVKvPHGG1i5ciWUUhZnv5WWlqJPnz549dVXK7yPm0+fBSz/k7pVRbc99dRT2L17N1555RW0b98e9evXR2lpKfr162exYVe2cZSUlJRbxs6dO7Fjxw7897//xaZNm7B69Wo8+uij+Pbbb8VngVU2Xlnx7e2lpaXw9PTE559/XuHtZXuKZZ+BSEpKwoYNG7B582Y8++yz+L//+z8kJSVVujdxO2FhYXB1da3wQHlNatSoEa5fv46cnBw4OztX633/nufiVt999x0GDRqEHj16YNGiRfDx8YGdnR1iYmLM/5BJlG2rTz/9NMaOHVvhmLZt24rvF6jex10Ra9dFdb623nzzTXz22Wd45513MGTIEIvbqnNd/vDDD5gyZQqee+65Svfiywq5u7u7lbOvGfddAQJu7AX9+c9/xqFDhxAbG4vmzZubzywBgMDAQOTm5v6us5oqc/XqVWzbtg1z587FrFmzzNcfP3683NgGDRogMzOz3PUVvQ1Rp04d9O7dG71798b8+fPx97//HW+++SZ27NiBiIgIBAYGYs+ePSguLq6WU34rK46BgYHYunUrunbtetvCXKZz587o3Lkz/va3vyE2NhZjxozBqlWr8NxzzxmaV0lJCXJzc0WZJk2a4PDhw1BKWTyuo0ePWpUPCQkBcONsOKN/cI1q0qQJAODEiRPlbrv1unXr1sHBwQGbN2+2OP05JiamwvuuaJs8duwY6tWrZ/5HwtnZGSUlJTXyWpEqWxcVzfvW51KyLqp6bVkrMDAQTz/9NP75z38iPDzc4jYPDw+r1+Xt9louXryIJ554Au3btzefqVqR1NRUAEDLli2tnn9NuO/eggP+9zbcrFmzcPDgwXKf/XnqqaeQmJiIzZs3l8tmZmbi+vXrhpdd9h/Trf/J3XpmHXBjg83KysKhQ4fM150/f77caaUVnUpZ9gG1sre0hg8fjkuXLuGjjz4qN9bIf5Vln2e6tUA+9dRTKCkpwV/+8pdymevXr5vHX716tdxyb52z1I4dO5Cbm4t27dqJco899hjS0tIsTsHNz8/H0qVLrcp36dIFwI3Tyu80X19fhIaGYsWKFRaFNyEhAT/99JPFWFtbW9jY2FjsQZ86dQpffvllhfedmJhocdzh7NmziIuLQ9++fc2frxo+fDjWrVuHw4cPl8tLj8X9Xj4+Pmjfvj2WL19u8Tbali1bcOTIEYux1q4La15bEjNnzkRxcTHmzZtXbj7WrsvKXnslJSUYOXIkioqKsG7dutueYZmcnAwbGxvztqvLfbkHFBAQgIcffhhxcXEAUK4AvfLKK/jqq6/w+OOPY9y4cQgLC0NeXh5++ukn/Oc//8GpU6cM77q6uLigR48emDdvHoqLi/HAAw/g22+/Nf9HcrORI0fitddew9ChQ/Hyyy8jPz8fixcvRosWLSz+MLz11lvYuXMnBgwYgCZNmiAjIwOLFi1C48aNzZ89euaZZ7BixQpMnz4dP/zwA7p37468vDxs3boVL774IgYPHix6HGUHp19++WVERkaaT/Do2bMnJk2ahOjoaBw8eBB9+/aFnZ0djh8/jrVr1+If//gHnnjiCSxfvhyLFi3C0KFDERgYiJycHHz88cdwcXHBY489VuXys7Ky8O9//xvAjcJ29OhRLF68GI6Ojnj99ddFj+X555/HRx99hGeeeQbJycnw8fHBZ599Zu6mUJVmzZohNDQUW7durfBzTMeOHTPP9WZeXl7mD8z+Hn//+98xePBgdO3aFePHj8fVq1fx0UcfITQ01KIoDRgwAPPnz0e/fv0wevRoZGRkYOHChQgKCrL4J6dMaGgoIiMjLU7DBoC5c+eax7z99tvYsWMHwsPD8fzzz6NVq1a4cuUK9u/fj61bt97xz5lER0djwIAB6NatG5599llcuXIFH374IVq3bm1oXVjz2pIo2wtavnx5udusXZeBgYFwc3PDkiVL4OzsDCcnJ4SHh+Prr7/G9u3b8cILL5hP9ilz67a2ZcsWdO3aVX/XFy3n3tUCCxcuVABUp06dKrw9JydHzZgxQwUFBSl7e3vl7u6uHn74YfXee++poqIipdT/TpV99913y+XLTpWu6PTNc+fOqaFDhyo3Nzfl6uqqnnzySfNpkbNnz7YY++2336rQ0FBlb2+vgoOD1b///e9yp2Fv27ZNDR48WPn6+ip7e3vl6+urRo0aVe408vz8fPXmm2+qgIAAZWdnp7y9vdUTTzyhUlJSqnw8t87t+vXr6qWXXlIeHh7Kxsam3CnZS5cuVWFhYcrR0VE5OzurNm3aqFdffdV8Gur+/fvVqFGjlL+/vzKZTMrT01M9/vjjFqf9VubW07BtbGxUw4YN1aBBg1RycrLFWGtOw1bqxinGgwYNUvXq1VPu7u5qypQp5lPHqzoNWyml5s+fr+rXr1/u1N6b53nr5eY5VHYatjXPhVJKrVq1SoWEhCiTyaRCQ0PVV199pYYPH65CQkIsxn3yySeqefPmymQyqZCQEBUTE1NueypbRlRUlPr3v/9tHv/ggw9WuC7S09NVVFSU8vPzM29XvXv3VkuXLq1yvVV2Gvatp+eXnbZszXOxbt061bJlS2UymVSrVq3UF198UeFHGqxZF9a+tip7bGWnYd/s+PHjytbWttxp2EpZvy7j4uJUq1atVN26dc2nZJfNvaptLTMzU9nb26t//etfVT6GmmajVDUd1SO6j2VlZaFZs2aYN28eJkyYoHs6AG68VeTh4YEtW7bongrVIgsWLMC8efOQkpJi1XHamnRfHgMiqm6urq549dVX8e67797xpqLFxcXljkvGx8fjxx9/tOprJ+j+UVxcjPnz52PmzJnaiw8AcA+I6C536tQpRERE4Omnn4avry9+/fVXLFmyBK6urjh8+LD+9/mJKnFfnoRAdC9p0KABwsLC8K9//QsXL16Ek5MTBgwYgLfffpvFh2o17gEREZEWPAZERERasAAREZEWte4YUGlpKdLS0uDs7Ky9UR4REckppZCTkwNfX9/bfuV6rStAaWlp8PPz0z0NIiL6nc6ePVvhlwGWqXUFqKyb8IgRI6r8tsib3dpOxxq3tquwVlVf71yRilrtVOXmbym11q3f+2ENoy3zR48eLc78+OOP4szBgwfFmYq+/8UaRrpwS5ufArD4vhprGTlf6NavebdWRd+mWhUjr4uKWgBVpaioSJx56qmnxBkA+PXXX8WZm78R2VpG/um25utRKmKkY3tZo1dr5eXlYejQoVUuq8YK0MKFC/Huu+/iwoULaNeuHT788EN06tSpylzZ22729vaiAlTWoE/i5i64EpJ5lbHme3iqYzlGHpOR5QDG1rmDg4M4Y2R+RpYD3P6rNSpjpDmtkeUYKUB3cj0Y2faMdGY38kFfox+6NPKYjKxza/sO3qygoECcMbosI691oOrvG6qRkxBWr16N6dOnY/bs2di/fz/atWuHyMhIw/9pExHRvadGCtD8+fPx/PPPY/z48WjVqhWWLFmCevXq4dNPP62JxRER0V2o2gtQUVERkpOTLb5UqU6dOoiIiEBiYmK58YWFhcjOzra4EBHRva/aC9ClS5dQUlJS7vvuvby8cOHChXLjo6Oj4erqar7wDDgiovuD9g+izpgxA1lZWebL2bNndU+JiIjugGo/C87d3R22trZIT0+3uD49Pb3CU4RNJpPhs9GIiOjuVe17QPb29ggLC8O2bdvM15WWlmLbtm3av3+ciIhqjxr5HND06dMxduxYPPTQQ+jUqRMWLFiAvLw8jB8/viYWR0REd6EaKUAjRozAxYsXMWvWLFy4cAHt27fHpk2byp2YQERE968a64QwefJkTJ482XD+/Pnzou4B3333nXgZvr6+4gxgrN1NRWcAVuV2PZQqY6TlSHJysjgDALGxseJMSkqKOBMSEiLOREZGijMAcObMGXHGSCuew4cPizNGWry4u7uLM4Cx9kxGXhdGukgYabu1ceNGcQYARo4cKc4Y6dRg5OMnbm5u4gwAfPvtt+KMi4uLaHxhYaFV47SfBUdERPcnFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0YAEiIiItaqwZ6e/VunVr0RfV1a9fX7yM4uJicQYArly5Is48+OCD4sypU6fEmU8++UScMdI8EQAmTZokzuzYsUOcMdLss0+fPuIMAERERIgzs2bNEmd+++03ccbI8yRtIlnm5MmT4kxwcLA4M2LECHHGSMPYhx9+WJwBgISEBHHGSCPXRo0aiTM5OTniDADY2dmJM9LGp2xGSkREtRoLEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpEWt7Ybdtm1b1KtXz+rxv/76q3gZRrpNA0CHDh3EGQcHB3HGSPdjf39/ccZoV117e3txpqioSJyRdEUv88Ybb4gzANCqVStx5sCBA+JM3759xZmff/5ZnDl37pw4AwCenp7izNWrV8UZGxsbcebEiRPizLBhw8QZ4MbfIaktW7aIM0a65WdmZoozANC9e3dxZvPmzaLxBQUFVo3jHhAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKRFrW1GWlpaKmrG6erqKl6GkcaTgLHGp0YaBzZr1kyc+eWXX8QZI80+ASA7O1ucMdIIMT8/X5yJj48XZwBg5cqV4kxQUJA4Y6ShrbUNHm9mpGEsAEybNk2c+eSTT8SZjRs3ijPPPfecOHPlyhVxBgDS0tLEGSNNhI38TVFKiTMAsHz5cnFG2jS2sLDQqnHcAyIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLSotc1I9+7dK2qkGB4eLl5GamqqOAMA3t7e4kz//v3FmX379okzhw4dEmfatm0rzgDAf/7zH3GmdevW4oy1jQ1vZrT5ZN268pdEr169xJnDhw+LM3v37hVnnJ2dxRkAWLFihTiTnp4uzhjZ9nbu3CnOXL9+XZwBgObNm4szRp4nIw1WjWxDgLGmti4uLqLx1jZk5R4QERFpwQJERERaVHsBmjNnDmxsbCwuISEh1b0YIiK6y9XIMaDWrVtj69at/1uIgffViYjo3lYjlaFu3bqGDtQTEdH9o0aOAR0/fhy+vr5o1qwZxowZgzNnzlQ6trCwENnZ2RYXIiK691V7AQoPD8eyZcuwadMmLF68GKmpqejevTtycnIqHB8dHQ1XV1fzxc/Pr7qnREREtVC1F6D+/fvjySefRNu2bREZGYmvv/4amZmZWLNmTYXjZ8yYgaysLPPl7Nmz1T0lIiKqhWr87AA3Nze0aNECJ06cqPB2k8kEk8lU09MgIqJapsY/B5Sbm4uUlBT4+PjU9KKIiOguUu0F6E9/+hMSEhJw6tQp7N69G0OHDoWtrS1GjRpV3YsiIqK7WLW/BXfu3DmMGjUKly9fhoeHB7p164akpCR4eHhU96KIiOguVu0FaNWqVdVyP8OGDYOTk5PV47dv3y5eRkpKijgDAO3atRNnYmJixBkjH+AdP368OGO0YeV3330nzvz888/ijJHGot26dRNnAGPNXOvVqyfOSLbtMh06dBBnKjv2WpVTp06JM0aO5dapI38TJiwsTJz57LPPxBngxjFsqVatWokz165dE2c2bNggzgDAwIEDxRnp6ykvL8+qcewFR0REWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERaVHjX0hn1MyZM0XNON98803xMuzs7MQZo7lHH31UnNm5c6c4k5aWJs5cvHhRnAGATp06iTNGvhfKSNPYo0ePijOAsXVuZD0YaZ5rpMml0e/h6tq1qzhjZJ0baUb63//+V5wZM2aMOAMACQkJhnJSWVlZ4kxoaKihZRlpart//37R+IKCAqvGcQ+IiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0sFFKKd2TuFl2djZcXV0RGxuLevXqWZ3btWuXeFlGugsDwN/+9jdxplmzZuJMYGCgOOPg4CDOuLu7izMAMGTIEHHm119/FWd++uknccbIugOAwsJCcWbv3r3ijJFu0ydPnhRnbG1txRkAuH79ujjTtm1bcSYjI0Oc8fDwEGeM/H0AgKKiInEmNzdXnDGZTOJMcHCwOAMA0dHR4syMGTNE4wsKCvDmm28iKysLLi4ulY7jHhAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKRFXd0TqMxXX30Fe3t7q8cbaT65c+dOcQYAYmNjxZm4uDhxxkiT0JKSEnHm+PHj4gwAvPjii+JMVFSUOGOkkau/v784AwD79u0TZy5duiTOXLhwQZwx0ig1Ly9PnAFw2waSlTly5Ig4k5ycLM706dNHnAkPDxdnAGONcHv06CHOGFkPp06dEmcAYNGiReLM4cOHReOt3Va5B0RERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWlRa5uRent7w2QyWT2+Th15LZXc/80+/PBDcaZDhw7iTHZ2tjhTWloqzvz1r38VZwCgS5cu4swvv/xiaFlStra2hnKNGzcWZ4w0S83IyBBnunfvLs60b99enAGAJUuWiDNGmrL269dPnFm9erU4Y6SBKQA0atRInElKShJnevXqJc4YaRgLAHXryv/sL1++XDS+uLjYqnHcAyIiIi1YgIiISAtxAdq5cycGDhwIX19f2NjY4Msvv7S4XSmFWbNmwcfHB46OjoiIiDD8fTNERHTvEhegvLw8tGvXDgsXLqzw9nnz5uGDDz7AkiVLsGfPHjg5OSEyMhIFBQW/e7JERHTvEB+N6t+/P/r371/hbUopLFiwADNnzsTgwYMBACtWrICXlxe+/PJLjBw58vfNloiI7hnVegwoNTUVFy5cQEREhPk6V1dXhIeHIzExscJMYWEhsrOzLS5ERHTvq9YCVPY9915eXhbXe3l5mW+7VXR0NFxdXc0XPz+/6pwSERHVUtrPgpsxYwaysrLMl7Nnz+qeEhER3QHVWoC8vb0BAOnp6RbXp6enm2+7lclkgouLi8WFiIjufdVagAICAuDt7Y1t27aZr8vOzsaePXsMfWqeiIjuXeKz4HJzc3HixAnz76mpqTh48CAaNmwIf39/TJ06FX/961/RvHlzBAQE4M9//jN8fX0xZMiQ6pw3ERHd5cQFaN++fXjkkUfMv0+fPh0AMHbsWCxbtgyvvvoq8vLyMHHiRGRmZqJbt27YtGkTHBwcqm/WRER017NRSindk7hZdnY2XF1dMWPGDFHRcnR0FC+rslPDq9KqVStxxkjTxU8//VScMdIY8/Lly+IMYKzhp52dnTjTokULcebq1aviDADY29uLM+3atRNnfv75Z3HGw8NDnDlw4IA4Axhrnpufny/OVHZ27O2cO3dOnImMjBRnACAuLk6cMbKNBwcHizNGD2skJyeLM9LXU0FBAebMmYOsrKzbHtfXfhYcERHdn1iAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLcRfx3CnZGVloaCgwOrx169fFy9j6NCh4gwArFixQpwJCQkRZ0pKSu5IZuXKleIMAIwePVqcGTNmjDhz8/dPWSsvL0+cAYCGDRuKMxs2bBBnnJycxJmOHTuKM0Y7nefm5oozly5dEmcaN24szmRmZoozu3btEmcA4MyZM+LMQw89JM4Y6fC9Zs0acQYA/Pz8xBnpOi8sLLRqHPeAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLWptM9IGDRrAwcHB6vFFRUXiZSQmJoozANCzZ09xZvfu3eJMQECAOLNnzx5xxkijVACIiIgQZy5cuCDO5OTkiDNGtgfAWFPbevXqiTOhoaHijJGGlWfPnhVnAMDGxkacadmypThz5MgRccbX11ec8ff3F2cA4NSpU+KMke1h37594kzTpk3FGcBYU9vg4GDR+Ly8PLz//vtVjuMeEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpEWtbUbapEkTODo6Wj3+hx9+EC/DxcVFnAGA9PR0cSYoKEicadeunThjpLljZGSkOAMAEyZMEGdee+01cebAgQPizLBhw8QZANiwYYM406xZM3Fm79694kzjxo3FGSONXAHggQceEGeOHTsmzrRt21ackTQpLvPFF1+IM4CxpqzdunUTZ1JTU8WZPn36iDMAsGjRInHGyclJNN7aZsDcAyIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLSotc1Ii4qKYGtra/V4abM8ALh8+bI4AwABAQHiTKNGjcSZZcuWiTNGmjtK1vPNjDQjdXZ2FmeKi4vFmcTERHEGMNaEMzs7W5zp3LmzOHPy5ElxJjw8XJwBgJSUFHHG29tbnOnQoYM4895774kzJpNJnAGMNSzetWuXODN48GBxxt7eXpwBAC8vL3HGzc1NNL6goMCqcdwDIiIiLViAiIhIC3EB2rlzJwYOHAhfX1/Y2Njgyy+/tLh93LhxsLGxsbj069evuuZLRET3CHEBysvLQ7t27bBw4cJKx/Tr1w/nz583X1auXPm7JklERPce8UkI/fv3R//+/W87xmQyGTogSURE948aOQYUHx8PT09PBAcH449//ONtzzYrLCxEdna2xYWIiO591V6A+vXrhxUrVmDbtm145513kJCQgP79+6OkpKTC8dHR0XB1dTVf/Pz8qntKRERUC1X754BGjhxp/rlNmzZo27YtAgMDER8fj969e5cbP2PGDEyfPt38e3Z2NosQEdF9oMZPw27WrBnc3d1x4sSJCm83mUxwcXGxuBAR0b2vxgvQuXPncPnyZfj4+NT0ooiI6C4ifgsuNzfXYm8mNTUVBw8eRMOGDdGwYUPMnTsXw4cPh7e3N1JSUvDqq68iKCgIkZGR1TpxIiK6u4kL0L59+/DII4+Yfy87fjN27FgsXrwYhw4dwvLly5GZmQlfX1/07dsXf/nLXwz3YiIionuTuAD16tULSqlKb9+8efPvmlCZS5cuwcHBwerxRpouJiUliTOAseaTOTk54oyRBqu5ubnizOrVq8UZABg4cKA4k5ycLM4Y2XveuHGjOAMAQUFB4oyR7eh2r6HKNGvWTJyJj48XZwDgiSeeEGe2bt0qznz00UfijOTvQpnGjRuLMwBw5MgRcSY1NVWcMdLgeP/+/eIMcONvq5R0fteuXbNqHHvBERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFtX+ldzVJTExEXZ2dlaPt7b76s2MdLUGgGPHjokzo0ePFmcuX74szkjWWZkuXbqIMwAsvpbDWqdPnxZnjHQ/fvDBB8UZAHB2dhZnhg8fLs5069ZNnNm1a5c4Y3Q9GOkKXlhYKM4sW7bsjiynRYsW4gwANGrUSJx55513xJm33npLnMnPzxdnAKB///7izPfffy8ab+1zxD0gIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhIi1rbjLR3795wdHS0enx8fLx4GUYaDQJA27ZtxZnc3Fxx5sqVK+LMwIEDxZlz586JMwBw/vx5cUYpJc5kZWWJM0bWN2BsmyguLhZnVq1aJc6MHDlSnDl8+LA4AwD79u0TZ4w0uTTyuu3Ro4c4s2DBAnEGAAYMGCDOfPTRR+KMvb29ONOgQQNxBgDeeOMNcWbo0KGGllUV7gEREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERa1NpmpAkJCbCzs7N6/KOPPipeRn5+vjgDAL/++qs44+/vL860bt1anFm9erU4c+HCBXEGMDY/GxsbcSYuLk6cGTdunDgDACdOnBBnjGxHtra24sz169fFmYceekicAYC3337bUE7q0qVL4szChQvFmbp1jf2pc3V1FWeaNGkizrz77rviTLt27cQZwNhz++OPP4rGW/s65x4QERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkRa1tRurv7w+TyWT1+EceeUS8jIyMDHEGgGheZby8vMQZI00ug4ODxRkjDRcBYOnSpeKMkeepZ8+e4szx48fFGQBwdnYWZwoKCsSZ7du3izO+vr7izLPPPivOAMArr7wizpw7d06cCQkJEWcaN24szqSnp4szALB7925xxshrvXfv3uLMyZMnxRnA2Po7e/asaLy1rwnuARERkRYsQEREpIWoAEVHR6Njx45wdnaGp6cnhgwZgqNHj1qMKSgoQFRUFBo1aoT69etj+PDhhnd/iYjo3iUqQAkJCYiKikJSUhK2bNmC4uJi9O3bF3l5eeYx06ZNw4YNG7B27VokJCQgLS0Nw4YNq/aJExHR3U10EsKmTZssfl+2bBk8PT2RnJyMHj16ICsrC5988gliY2PN31AaExODli1bIikpCZ07d66+mRMR0V3tdx0DysrKAgA0bNgQAJCcnIzi4mJERESYx4SEhMDf3x+JiYkV3kdhYSGys7MtLkREdO8zXIBKS0sxdepUdO3aFaGhoQCACxcuwN7eHm5ubhZjvby8cOHChQrvJzo6Gq6uruaLn5+f0SkREdFdxHABioqKwuHDh7Fq1arfNYEZM2YgKyvLfJGeb05ERHcnQx9EnTx5MjZu3IidO3dafKjJ29sbRUVFyMzMtNgLSk9Ph7e3d4X3ZTKZDH2wk4iI7m6iPSClFCZPnoz169dj+/btCAgIsLg9LCwMdnZ22LZtm/m6o0eP4syZM+jSpUv1zJiIiO4Joj2gqKgoxMbGIi4uDs7OzubjOq6urnB0dISrqysmTJiA6dOno2HDhnBxccFLL72ELl268Aw4IiKyICpAixcvBgD06tXL4vqYmBiMGzcOAPD++++jTp06GD58OAoLCxEZGYlFixZVy2SJiOjeISpASqkqxzg4OGDhwoVYuHCh4UkBQElJCa5fv271+G+++Ua8DKOnfNvZ2Ykz+/fvF2cGDBggzkjWWRmje6d168oPIdapIz/v5erVq+KMkQahRp04cUKcmTp1qjhjZBtas2aNOAP87yMWEra2tuKMkS4pDzzwgDiTkJAgzgD/+6dbwsjfFSN/Uzw8PMQZADh27Jg4I31MbEZKRES1GgsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkhaFvRL0TXFxcRN+UmpKSIl6G0S7QSUlJ4ky3bt3EmeLiYnFm9erV4kz//v3FGcBYN+zTp0+LM48//rg4Y6TLMgBcuXJFnBk7dqw4Y6Rb/K1fAGkNJycncQYwtv5GjBghzuzZs0ecOX78uDgzbdo0cQYA9u3bJ840bdpUnGnevLk4U1RUJM4Axtaf9G+RtV35uQdERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpAULEBERacECREREWrAAERGRFixARESkBQsQERFpUWubkRYXF6NOHevro7XN7262c+dOcQYA2rZtK84cPnxYnGncuLE4M2XKFHEmOTlZnAGMNUt97LHHxJmCggJxxsbGRpwBAG9vb3HGwcFBnDHSnNaIDh06GMpdunRJnPnnP/8pzjzwwAPizI8//ijOfPfdd+IMYKxRr5HGyL/99ps489BDD4kzAHDt2jVxprCwsEbGcw+IiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSotY2I7127RpKSkqsHt+lSxfxMnr27CnOAMCaNWvEmbp15au6RYsW4oy9vb04Y2dnJ84AgFJKnNm3b584Y2TddezYUZwBgG+++UaciY2NFWeMPCYjzSczMjLEGQAoKioSZ06dOiXO/OEPfxBnjDQerlevnjgDAElJSeJM69atxZkrV66IM7NnzxZnAODBBx8UZ6Tzs7ZRMfeAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1YgIiISAsWICIi0oIFiIiItGABIiIiLWptM9LLly+LmmT+9ttv4mWMHz9enAGACRMmiDMnTpwQZ+Li4sQZIw1Mjx8/Ls4AgMlkEmeMNEK8cOGCOHPy5ElxBgD8/PzEmaCgIHEmPT1dnImIiBBnjGx3gLFmrra2tuLM3r17xRkjDVZzc3PFGcBYU1ZrG3HezMg29Msvv4gzgLGmtt9//71ovLXrjXtARESkBQsQERFpISpA0dHR6NixI5ydneHp6YkhQ4bg6NGjFmN69eoFGxsbi8sLL7xQrZMmIqK7n6gAJSQkICoqCklJSdiyZQuKi4vRt29f5OXlWYx7/vnncf78efNl3rx51TppIiK6+4lOQti0aZPF78uWLYOnpyeSk5PRo0cP8/X16tWDt7d39cyQiIjuSb/rGFBWVhYAoGHDhhbXf/7553B3d0doaChmzJiB/Pz8Su+jsLAQ2dnZFhciIrr3GT4Nu7S0FFOnTkXXrl0RGhpqvn706NFo0qQJfH19cejQIbz22ms4evQovvjiiwrvJzo6GnPnzjU6DSIiuksZLkBRUVE4fPhwufPDJ06caP65TZs28PHxQe/evZGSkoLAwMBy9zNjxgxMnz7d/Ht2drahz2IQEdHdxVABmjx5MjZu3IidO3eicePGtx0bHh4O4MYH4ioqQCaTydAHGomI6O4mKkBKKbz00ktYv3494uPjERAQUGXm4MGDAAAfHx9DEyQionuTqABFRUUhNjYWcXFxcHZ2NrdIcXV1haOjI1JSUhAbG4vHHnsMjRo1wqFDhzBt2jT06NEDbdu2rZEHQEREdydRAVq8eDGAGx82vVlMTAzGjRsHe3t7bN26FQsWLEBeXh78/PwwfPhwzJw5s9omTERE9wbxW3C34+fnh4SEhN81ISIiuj/U2m7Y6enpqFvX+ul5enqKl+Hh4SHOALjt55oq06dPH3EmJSVFnLG3txdnvLy8xBmjuStXrogzBQUF4kzLli3FGeB/e/kSRjpHnzlzRpzZsWOHOFNYWCjOAMY6Oh85ckSccXJyEmesOfZ8KwcHB3EGMNZV/dChQ+KMkfn169dPnAGMdfiuU0f2kVFrx7MZKRERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFqwABERkRYsQEREpEWtbUYaGBgoaqzp5uYmXoarq6s4AwAhISHizPr168UZd3d3cSYpKUmcad26tTgDGGsseunSJXGmqm/drcjChQvFGQAICgoSZ4w8JiNNOJs0aSLOGNkeAMDGxkacad68uTiTnp4uznTq1EmcMdIgFACOHTsmzkgbdwJAcHCwOJORkSHOAMDXX38tzrz00kui8deuXcPKlSurHMc9ICIi0oIFiIiItGABIiIiLViAiIhICxYgIiLSggWIiIi0YAEiIiItWICIiEgLFiAiItKCBYiIiLRgASIiIi1qXS84pRQAoKioSJQrLCw0vCypvLw8cUb6eACgoKBAnCkuLhZnjKw7wNhjqs3rAbhz25GR9XDt2rU7shzA2How8jwZWU5ubq44Y2TdAca2IyO94O7UugOAkpIScUa6/srGV/XasFFG/wrXkHPnzsHPz0/3NIiI6Hc6e/bsbZsJ17oCVFpairS0NDg7O5fryJudnQ0/Pz+cPXsWLi4ummaoH9fDDVwPN3A93MD1cENtWA9KKeTk5MDX1/e2e4S17i24OnXqVNl+38XF5b7ewMpwPdzA9XAD18MNXA836F4P1nzdDU9CICIiLViAiIhIi7uqAJlMJsyePRsmk0n3VLTieriB6+EGrocbuB5uuJvWQ607CYGIiO4Pd9UeEBER3TtYgIiISAsWICIi0oIFiIiItGABIiIiLe6aArRw4UI0bdoUDg4OCA8Pxw8//KB7SnfcnDlzYGNjY3EJCQnRPa0at3PnTgwcOBC+vr6wsbHBl19+aXG7UgqzZs2Cj48PHB0dERERgePHj+uZbA2qaj2MGzeu3PbRr18/PZOtIdHR0ejYsSOcnZ3h6emJIUOG4OjRoxZjCgoKEBUVhUaNGqF+/foYPnw40tPTNc24ZlizHnr16lVue3jhhRc0zbhid0UBWr16NaZPn47Zs2dj//79aNeuHSIjI5GRkaF7andc69atcf78efPl+++/1z2lGpeXl4d27dph4cKFFd4+b948fPDBB1iyZAn27NkDJycnREZGGuowXJtVtR4AoF+/fhbbx8qVK+/gDGteQkICoqKikJSUhC1btqC4uBh9+/a16FA/bdo0bNiwAWvXrkVCQgLS0tIwbNgwjbOuftasBwB4/vnnLbaHefPmaZpxJdRdoFOnTioqKsr8e0lJifL19VXR0dEaZ3XnzZ49W7Vr1073NLQCoNavX2/+vbS0VHl7e6t3333XfF1mZqYymUxq5cqVGmZ4Z9y6HpRSauzYsWrw4MFa5qNLRkaGAqASEhKUUjeeezs7O7V27VrzmF9++UUBUImJibqmWeNuXQ9KKdWzZ081ZcoUfZOyQq3fAyoqKkJycjIiIiLM19WpUwcRERFITEzUODM9jh8/Dl9fXzRr1gxjxozBmTNndE9Jq9TUVFy4cMFi+3B1dUV4ePh9uX3Ex8fD09MTwcHB+OMf/4jLly/rnlKNysrKAgA0bNgQAJCcnIzi4mKL7SEkJAT+/v739PZw63oo8/nnn8Pd3R2hoaGYMWMG8vPzdUyvUrWuG/atLl26hJKSEnh5eVlc7+XlhV9//VXTrPQIDw/HsmXLEBwcjPPnz2Pu3Lno3r07Dh8+DGdnZ93T0+LChQsAUOH2UXbb/aJfv34YNmwYAgICkJKSgjfeeAP9+/dHYmIibG1tdU+v2pWWlmLq1Kno2rUrQkNDAdzYHuzt7eHm5mYx9l7eHipaDwAwevRoNGnSBL6+vjh06BBee+01HD16FF988YXG2Vqq9QWI/qd///7mn9u2bYvw8HA0adIEa9aswYQJEzTOjGqDkSNHmn9u06YN2rZti8DAQMTHx6N3794aZ1YzoqKicPjw4fviOOjtVLYeJk6caP65TZs28PHxQe/evZGSkoLAwMA7Pc0K1fq34Nzd3WFra1vuLJb09HR4e3trmlXt4ObmhhYtWuDEiRO6p6JN2TbA7aO8Zs2awd3d/Z7cPiZPnoyNGzdix44dFt8f5u3tjaKiImRmZlqMv1e3h8rWQ0XCw8MBoFZtD7W+ANnb2yMsLAzbtm0zX1daWopt27ahS5cuGmemX25uLlJSUuDj46N7KtoEBATA29vbYvvIzs7Gnj177vvt49y5c7h8+fI9tX0opTB58mSsX78e27dvR0BAgMXtYWFhsLOzs9gejh49ijNnztxT20NV66EiBw8eBIDatT3oPgvCGqtWrVImk0ktW7ZMHTlyRE2cOFG5ubmpCxcu6J7aHfX//t//U/Hx8So1NVXt2rVLRUREKHd3d5WRkaF7ajUqJydHHThwQB04cEABUPPnz1cHDhxQp0+fVkop9fbbbys3NzcVFxenDh06pAYPHqwCAgLUtWvXNM+8et1uPeTk5Kg//elPKjExUaWmpqqtW7eqDh06qObNm6uCggLdU682f/zjH5Wrq6uKj49X58+fN1/y8/PNY1544QXl7++vtm/frvbt26e6dOmiunTponHW1a+q9XDixAn11ltvqX379qnU1FQVFxenmjVrpnr06KF55pbuigKklFIffvih8vf3V/b29qpTp04qKSlJ95TuuBEjRigfHx9lb2+vHnjgATVixAh14sQJ3dOqcTt27FAAyl3Gjh2rlLpxKvaf//xn5eXlpUwmk+rdu7c6evSo3knXgNuth/z8fNW3b1/l4eGh7OzsVJMmTdTzzz9/z/2TVtHjB6BiYmLMY65du6ZefPFF1aBBA1WvXj01dOhQdf78eX2TrgFVrYczZ86oHj16qIYNGyqTyaSCgoLUK6+8orKysvRO/Bb8PiAiItKi1h8DIiKiexMLEBERacECREREWrAAERGRFixARESkBQsQERFpwQJERERasAAREZEWLEBERKQFCxAREWnBAkRERFr8f4JDg6Tt0fgiAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 1, 28, 28])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataiter = iter(trainloader)\n",
    "i, data = next(dataiter)\n",
    "t_zahl = 400\n",
    "\n",
    "plt.imshow(i[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "plt.title(\"Original Bild\")\n",
    "plt.show()\n",
    "\n",
    "img_noise, eps = mache_noise_direkt(i[0:1].to(device), t_zahl)\n",
    "\n",
    "plt.imshow(img_noise[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "plt.title(\"Verrauschtes Bild (Eingabe in das Netz)\")\n",
    "plt.show()\n",
    "print(img_noise.shape)\n",
    "img_pred = unet(img_noise, t_zahl)\n",
    "\n",
    "\n",
    "\n",
    "plt.imshow(img_pred[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "plt.title(\"Geschätztes Epsilon (Ausgabe vom Netz)\")\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "plt.imshow(eps[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "plt.title(\"Richtiges Epsilon\")\n",
    "plt.show()\n",
    "\n",
    "reverted_img = try_to_revert(img_noise, img_pred, t_zahl)\n",
    "\n",
    "plt.imshow(reverted_img[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "plt.title(\"Umkehrung des Rauschens mit Prediction\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "c2e965b7",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 5, figsize=(20, 4))  # 1 Reihe, 5 Spalten\n",
    "\n",
    "# Original Bild\n",
    "axs[0].imshow(i[0, 0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "axs[0].set_title(\"Original Bild\")\n",
    "axs[0].axis('off')\n",
    "\n",
    "# Verrauschtes Bild\n",
    "img_noise, eps = mache_noise_direkt(i[0:1].to(device), t_zahl)\n",
    "axs[1].imshow(img_noise[0, 0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "axs[1].set_title(\"Verrauschtes Bild\")\n",
    "axs[1].axis('off')\n",
    "\n",
    "# Geschätztes Epsilon\n",
    "img_pred = unet(img_noise, t_zahl)\n",
    "axs[2].imshow(img_pred[0, 0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "axs[2].set_title(\"Geschätztes Epsilon\")\n",
    "axs[2].axis('off')\n",
    "\n",
    "# Richtiges Epsilon\n",
    "axs[3].imshow(eps[0, 0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "axs[3].set_title(\"Richtiges Epsilon\")\n",
    "axs[3].axis('off')\n",
    "\n",
    "# Naive Umkehrung des Rauschens\n",
    "reverted_img = try_to_revert(img_noise, img_pred, t_zahl)\n",
    "axs[4].imshow(reverted_img[0, 0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "axs[4].set_title(\"Umkehrung des Rauschens\")\n",
    "axs[4].axis('off')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "25f88e45",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import display, clear_output\n",
    "\n",
    "betas = create_linear_schedule(1000, 0.0001, 0.02)\n",
    "alphas = 1 - np.array(betas)\n",
    "alphas_quer = []\n",
    "for k in range(len(alphas)):\n",
    "    alphas_quer.append(np.prod(alphas[:k + 1]))\n",
    "\n",
    "img_noise, eps = mache_noise_direkt(i[0:1].to(device), 1000)\n",
    "img_noise = torch.randn_like(img_noise)\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for j in reversed(range(999)):    \n",
    "    img_pred = unet(img_noise, j)\n",
    "    if j > 1:\n",
    "        z = torch.randn_like(img_noise)\n",
    "    else:\n",
    "        z = torch.zeros_like(img_noise)\n",
    "    #ausführliche Definition von Sigma:   \n",
    "    #img_noise = (1/np.sqrt(alphas[j+1])) * (img_noise - ((1- alphas[j+1])/(np.sqrt(1-alphas_quer[j+1]))) * img_pred) + np.sqrt((1-alphas_quer[j])/(1-alphas_quer[j+1]) *betas[j+1])*z\n",
    "    #Sigma^2 = beta:\n",
    "    # Alter Ansatz: DDPM\n",
    "    img_noise = (1/np.sqrt(alphas[j+1])) * (img_noise - ((1- alphas[j+1])/(np.sqrt(1-alphas_quer[j+1]))) * img_pred) + np.sqrt(betas[j+1])*z\n",
    "    \n",
    "    \n",
    "    if j % 100 == 0:\n",
    "        clear_output(wait=True)  # Löscht die vorherige Ausgabe\n",
    "        plt.imshow(img_noise[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "        plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "db7721d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ResNet(\n",
       "  (conv1): Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU()\n",
       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
       "  (layer1): Sequential(\n",
       "    (0): ResidualBlock(\n",
       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "      (identity_downsample): Sequential(\n",
       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): ResidualBlock(\n",
       "      (conv2): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (2): ResidualBlock(\n",
       "      (conv2): Conv2d(256, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (layer2): Sequential(\n",
       "    (0): ResidualBlock(\n",
       "      (conv2): Conv2d(256, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "      (identity_downsample): Sequential(\n",
       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): ResidualBlock(\n",
       "      (conv2): Conv2d(512, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (2): ResidualBlock(\n",
       "      (conv2): Conv2d(512, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (3): ResidualBlock(\n",
       "      (conv2): Conv2d(512, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (layer3): Sequential(\n",
       "    (0): ResidualBlock(\n",
       "      (conv2): Conv2d(512, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "      (identity_downsample): Sequential(\n",
       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (2): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (3): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (4): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (5): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (6): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (7): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (8): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (9): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (10): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (11): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (12): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (13): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (14): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (15): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (16): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (17): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (18): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (19): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (20): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (21): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (22): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (layer4): Sequential(\n",
       "    (0): ResidualBlock(\n",
       "      (conv2): Conv2d(1024, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "      (identity_downsample): Sequential(\n",
       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
       "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      )\n",
       "    )\n",
       "    (1): ResidualBlock(\n",
       "      (conv2): Conv2d(2048, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "    (2): ResidualBlock(\n",
       "      (conv2): Conv2d(2048, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (relu): ReLU()\n",
       "    )\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
       "  (fc): Linear(in_features=2048, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resnet = torch.load(\"Fashion_MNIST_Res_Noise.pt\")\n",
    "resnet.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ff1c6cb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display, clear_output\n",
    "coole_generierte_bilder = []\n",
    "\n",
    "def wir_generieren_gerne_bilder():\n",
    "    coole_generierte_bilder.clear()\n",
    "    betas = create_linear_schedule(1000, 0.0001, 0.02)\n",
    "    alphas = 1 - np.array(betas)\n",
    "    alphas_quer = []\n",
    "    for k in range(len(alphas)):\n",
    "        alphas_quer.append(np.prod(alphas[:k + 1]))\n",
    "\n",
    "    img_noise, eps = mache_noise_direkt(i[0:1].to(device), 1000)\n",
    "    img_noise = torch.randn_like(img_noise)\n",
    "    fig, ax = plt.subplots()\n",
    "    label = -10\n",
    "    scale = 5\n",
    "    resnet.requires_grad_(False)\n",
    "    for j in reversed(range(999)):\n",
    "        with torch.no_grad():\n",
    "            img_pred = unet(img_noise, j)\n",
    "        if j < 1000:\n",
    "            img_noise.requires_grad_(requires_grad=True)\n",
    "            img_noise.grad = torch.zeros_like(img_noise)\n",
    "            out = resnet(img_noise)\n",
    "            log_out = torch.log(out[0,label])\n",
    "            log_out.backward(retain_graph=True)\n",
    "            dummer_gradient = img_noise.grad\n",
    "        #ausführliche Definition von Sigma:   \n",
    "        #img_noise = (1/np.sqrt(alphas[j+1])) * (img_noise - ((1- alphas[j+1])/(np.sqrt(1-alphas_quer[j+1]))) * img_pred) + np.sqrt((1-alphas_quer[j])/(1-alphas_quer[j+1]) *betas[j+1])*z\n",
    "        #Sigma^2 = beta:\n",
    "            with torch.no_grad():\n",
    "                z = torch.randn_like(img_noise)\n",
    "                eps_hat = img_pred - (np.sqrt(1-alphas_quer[j+1])) * scale * dummer_gradient\n",
    "                #img_noise = np.sqrt(alphas_quer[j]) * ((img_noise - (np.sqrt(1 - alphas_quer[j + 1]) * eps_hat) / np.sqrt(alphas_quer[j + 1]))) + np.sqrt(1 - alphas_quer[j]) * eps_hat\n",
    "                img_noise = (1/np.sqrt(alphas[j+1])) * (img_noise - ((1- alphas[j+1])/(np.sqrt(1-alphas_quer[j+1]))) * eps_hat) + np.sqrt(betas[j+1])*z\n",
    "                if j%50 == 0:\n",
    "                    coole_generierte_bilder.append(img_noise)\n",
    "        else:\n",
    "            z = torch.randn_like(img_noise)\n",
    "            img_noise = (1/np.sqrt(alphas[j+1])) * (img_noise - ((1- alphas[j+1])/(np.sqrt(1-alphas_quer[j+1]))) * img_pred) + np.sqrt(betas[j+1])*z\n",
    "\n",
    "        if j % 100 == 0:\n",
    "            #print(dummer_gradient.min(), dummer_gradient.max(), dummer_gradient.mean(), dummer_gradient.std())\n",
    "            clear_output(wait=True)  # Löscht die vorherige Ausgabe\n",
    "            plt.imshow(img_noise[0,0].cpu().detach().numpy(), cmap=\"gray\")\n",
    "            plt.show()\n",
    "    \n",
    "    return img_noise\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8effd5ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ich_checke_gerne_ob_richtig():\n",
    "    label = 0\n",
    "    index = 0\n",
    "    img_gen = wir_generieren_gerne_bilder()\n",
    "    pred = resnet(img_gen)\n",
    "    for g in range(10):\n",
    "        if dataset_train.classes[g] == dataset_valid.classes[pred.argmax().cpu()]:\n",
    "            index = g\n",
    "    if index == label:\n",
    "        print(\"Vallah gut!\")\n",
    "    else:\n",
    "        ich_checke_gerne_ob_richtig()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "28c85d52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vallah gut!\n"
     ]
    }
   ],
   "source": [
    "ich_checke_gerne_ob_richtig()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "2e25c144",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.animation as animation\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "for m in range(10):\n",
    "    coole_generierte_bilder.append(coole_generierte_bilder[-1])\n",
    "# Ihr Array coole_generierte_bilder\n",
    "# Beispiel: coole_generierte_bilder = [np.random.rand(100, 100) for _ in range(10)]\n",
    "\n",
    "im = ax.imshow(coole_generierte_bilder[0].cpu().detach().numpy()[0,0], cmap='gray', vmin=-1, vmax=1)\n",
    "\n",
    "def update(num):\n",
    "    im.set_array(coole_generierte_bilder[num].cpu().detach().numpy()[0,0])\n",
    "    return im,\n",
    "\n",
    "ani = animation.FuncAnimation(fig, update, frames=range(len(coole_generierte_bilder)), blit=True)\n",
    "\n",
    "ani.save('animation.gif', writer='pillow')\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a4e4c36c",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "from IPython.display import display, clear_output\n",
    "\n",
    "betas = create_linear_schedule(1000, 0.0001, 0.02)\n",
    "alphas = 1 - np.array(betas)\n",
    "alphas_quer = []\n",
    "for k in range(len(alphas)):\n",
    "    alphas_quer.append(np.prod(alphas[:k + 1]))\n",
    "\n",
    "img_noise, eps = mache_noise_direkt(i[0:1].to(device), 1000)\n",
    "img_noise = torch.randn_like(img_noise)\n",
    "\n",
    "\n",
    "fig, axs = plt.subplots(1, 5, figsize=(20, 4)) \n",
    "axs = axs.flatten()\n",
    "ims = []\n",
    "noisy_images = np.empty((10,28,28))\n",
    "\n",
    "# Init images\n",
    "for k in range(5):\n",
    "    temp = torch.randn_like(img_noise)\n",
    "    noisy_images[k] = temp.cpu()\n",
    "print(noisy_images.shape)\n",
    "# Initialisieren der Bilder in den Subplots\n",
    "\n",
    "for z in range(5):\n",
    "    my_img = noisy_images[z]\n",
    "    im = axs[z].imshow(my_img, cmap=\"gray\")  # Ersetzen Sie 32x32 durch die tatsächliche Größe Ihrer Bilder\n",
    "    axs[z].axis('off')  \n",
    "plt.show()\n",
    "\n",
    "for j in reversed(range(999)): \n",
    "    noise_index = 0\n",
    "    for noisy_image in noisy_images:\n",
    "        # Ersetzen Sie dies durch Ihre eigene Noise-Generation\n",
    "        img_pred = unet(img_noise, j)\n",
    "\n",
    "        if j > 1:\n",
    "            z = torch.randn_like(img_noise)\n",
    "        else:\n",
    "            z = torch.zeros_like(img_noise)\n",
    "\n",
    "        img_noise = (1 / np.sqrt(alphas[j + 1])) * (\n",
    "            img_noise - ((1 - alphas[j + 1]) / (np.sqrt(1 - alphas_quer[j + 1]))) * img_pred\n",
    "        ) + np.sqrt(betas[j + 1]) * z\n",
    "        noisy_images[noise_index] = img_noise.detach().cpu().numpy()\n",
    "        del img_pred\n",
    "        noise_index += 1\n",
    "        \n",
    "    if j % 100 == 0:\n",
    "        clear_output(wait=True) \n",
    "        for o in range(5):\n",
    "            z = 0\n",
    "            my_img = noisy_images[o]\n",
    "            im = axs[o].imshow(my_img, cmap=\"gray\")  # Ersetzen Sie 32x32 durch die tatsächliche Größe Ihrer Bilder\n",
    "            axs[o].axis('off')\n",
    "        plt.show()\n",
    "    torch.cuda.empty_cache()\n"
   ]
  },
  {
   "cell_type": "raw",
   "id": "a8327007",
   "metadata": {},
   "source": [
    "pos_enc_example = _get_sinusoid_encoding_table(1000, 32) #1000 maximale Zeitschritte, 32 willkürlich gewählte Länge des 'Fingerabdrucks von t'\n",
    "#print(pos_enc_example.shape)\n",
    "#plt.imshow(pos_enc_example[0], cmap='Greys_r')\n",
    "#plt.show()\n",
    "pos_enc_mlp = nn.Sequential(nn.Linear(32,1)) # Eingabedim: Länge Fingerabdrucks, Ausgabedim:Anzahl Kanäle Feature-Map\n",
    "\n",
    "#for t in [0, 10, 42, 500, 800, 999]:\n",
    "#    enc_for_time_t = pos_enc_example[:,t]\n",
    "#    #print(enc_for_time_t.shape)\n",
    "#    plt.plot(enc_for_time_t.squeeze())\n",
    "#    plt.show()\n",
    "#print(enc_for_time_t.shape)\n",
    "enc_for_time_t = pos_enc_example[42]\n",
    "print(enc_for_time_t.shape) #32\n",
    "encoded_pos_enc_for_time_t = pos_enc_mlp(enc_for_time_t.unsqueeze(0)) #in (1,32) out (1,1)\n",
    "B, C, W, H = 5, 1, 28, 28\n",
    "example_feature_map = torch.ones((B,C,H,W))\n",
    "pos_enc_reshape = enc_for_time_t.reshape(1,-1,1,1).expand((B,-1,H,W))\n",
    "encoded_pos_enc_for_time_t_reshape = encoded_pos_enc_for_time_t.reshape(1,-1,1,1).expand((B,-1,H,W)) #5,1,28,28\n",
    "print(example_feature_map.shape)\n",
    "print(enc_for_time_t.shape)\n",
    "print(pos_enc_reshape.shape)\n",
    "feature_map_with_encoding = torch.cat([example_feature_map, pos_enc_reshape], dim=1)\n",
    "alt_feature_map_with_encoding = example_feature_map + encoded_pos_enc_for_time_t_reshape\n",
    "print(feature_map_with_encoding.shape) # erst das hier\n",
    "print(alt_feature_map_with_encoding.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fba93233",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}