diff --git a/docker/Dockerfile b/docker/Dockerfile
index f7abd485039336560f6acfa14265339dce7d3584..645737d087b1f7318b2a800639d1a143f359f645 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,15 +1,15 @@
 # syntax = docker/dockerfile:1.3
-FROM nvidia/cuda:11.6.2-base-ubuntu20.04
+FROM pytorch/pytorch:2.1.2-cuda11.8-cudnn8-runtime
 RUN apt update && apt install -y \
-    pip \
+    git \
     && rm -rf /var/lib/apt/lists/*
-COPY requirements.txt /tmp/requirements.txt
+COPY ../requirements.txt /tmp/requirements.txt
 RUN pip install --upgrade pip && \
     pip install --no-cache-dir -r /tmp/requirements.txt
-WORKDIR /home/wavo-torch/notebooks
-CMD jupyter-lab --no-browser --ip 0.0.0.0 --port 8888 --allow-root
-#--notebook-dir=/tf 
-LABEL name="kiwavo-tk" version="0.0.4" maintainer="Michel Spils <msp@informatik.uni-kiel.de>"
-# docker run -u $(id -u):$(id -g) --gpus all --rm -it -p 9999:9999 --name wln --workdir /../app/ki-wavo/notebooks 
-# --mount type=bind,source="$(pwd)",target=/app  kiwavo/notebook:latest jupyter-lab --ip 0.0.0.0 --port 9999
-#pytorch-forecasting==1.0.0
+ARG USERNAME=mspils
+ARG USER_UID=5006
+ARG USER_GID=$USER_UID
+# Create the user
+RUN groupadd --gid $USER_GID $USERNAME \
+    && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME
+LABEL name="wavo-dev" version="0.0.2" maintainer="Michel Spils <msp@informatik.uni-kiel.de>"
\ No newline at end of file
diff --git a/docker/Dockerfile_devcontainer b/docker/Dockerfile_devcontainer
deleted file mode 100644
index df457b74297ed213207cf3db05efe025fa366713..0000000000000000000000000000000000000000
--- a/docker/Dockerfile_devcontainer
+++ /dev/null
@@ -1,15 +0,0 @@
-# syntax = docker/dockerfile:1.3
-FROM pytorch/pytorch:2.1.2-cuda11.8-cudnn8-runtime
-RUN apt update && apt install -y \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install --upgrade pip && \
-    pip install --no-cache-dir -r /tmp/requirements.txt
-ARG USERNAME=mspils
-ARG USER_UID=5006
-ARG USER_GID=$USER_UID
-# Create the user
-RUN groupadd --gid $USER_GID $USERNAME \
-    && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME
-LABEL name="wavo-dev" version="0.0.2" maintainer="Michel Spils <msp@informatik.uni-kiel.de>"
\ No newline at end of file
diff --git a/docker/Dockerfile_old b/docker/Dockerfile_old
new file mode 100644
index 0000000000000000000000000000000000000000..f7abd485039336560f6acfa14265339dce7d3584
--- /dev/null
+++ b/docker/Dockerfile_old
@@ -0,0 +1,15 @@
+# syntax = docker/dockerfile:1.3
+FROM nvidia/cuda:11.6.2-base-ubuntu20.04
+RUN apt update && apt install -y \
+    pip \
+    && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt /tmp/requirements.txt
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -r /tmp/requirements.txt
+WORKDIR /home/wavo-torch/notebooks
+CMD jupyter-lab --no-browser --ip 0.0.0.0 --port 8888 --allow-root
+#--notebook-dir=/tf 
+LABEL name="kiwavo-tk" version="0.0.4" maintainer="Michel Spils <msp@informatik.uni-kiel.de>"
+# docker run -u $(id -u):$(id -g) --gpus all --rm -it -p 9999:9999 --name wln --workdir /../app/ki-wavo/notebooks 
+# --mount type=bind,source="$(pwd)",target=/app  kiwavo/notebook:latest jupyter-lab --ip 0.0.0.0 --port 9999
+#pytorch-forecasting==1.0.0
diff --git a/notebooks/scraping.ipynb b/notebooks/scraping.ipynb
index cdc55f1c38bd128f28d085047336b27af766a273..01b1858fea8bac1ba899f71f743daaa93c3ec830 100644
--- a/notebooks/scraping.ipynb
+++ b/notebooks/scraping.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 113,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -11,12 +11,20 @@
     "from pathlib import Path\n",
     "import pandas as pd\n",
     "from tqdm import tqdm\n",
-    "import matplotlib.pyplot as plt"
+    "import matplotlib.pyplot as plt\n",
+    "import requests\n",
+    "import os\n",
+    "from bs4 import BeautifulSoup\n",
+    "from urllib.parse import urljoin\n",
+    "import zipfile\n",
+    "import io\n",
+    "import pandas as pd\n",
+    "from datetime import datetime, timedelta\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": []
@@ -33,17 +41,206 @@
    "execution_count": null,
    "metadata": {},
    "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "dwd_base_url = \"https://opendata.dwd.de/climate_environment/CDC/observations_germany/climate/hourly/\"\n",
-    "sensor_types = [\"air_temperature\",\"dew_point\",\"moisture\",\"precipitation\",\"pressure\",\"sun\",\"wind\"]\n"
+    "\n",
+    "def read_and_filter_stations(url):\n",
+    "    response = requests.get(url)\n",
+    "    soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "    meta_data = [link.get('href') for link in soup.find_all('a') if link.get('href', '').endswith('.txt')][0]\n",
+    "    f = requests.get(urljoin(url, meta_data))\n",
+    "\n",
+    "\n",
+    "\n",
+    "    df = pd.read_fwf(io.StringIO(f.text), colspecs=[(0, 5), (6, 14), (15, 29), (30, 40), (42, 52), (53, 60), (61, 102), (102, 128), (129, 148)],\n",
+    "                        names=['Stations_id', 'von_datum', 'bis_datum', 'Stationshoehe', 'geoBreite', 'geoLaenge', 'Stationsname', 'Bundesland', 'Abgabe'],\n",
+    "                        skiprows=2,\n",
+    "                        dtype={0: \"str\"})\n",
+    "    # Convert date columns to datetime\n",
+    "    df['von_datum'] = pd.to_datetime(df['von_datum'], format='%Y%m%d')\n",
+    "    df['bis_datum'] = pd.to_datetime(df['bis_datum'], format='%Y%m%d')\n",
+    "\n",
+    "    # Calculate the date 5 years ago from today\n",
+    "    five_years_ago = datetime.now() - timedelta(days=5*365)\n",
+    "\n",
+    "    # Filter rows where 'bis_datum' is within the last 5 years\n",
+    "    df = df[df['von_datum'] < five_years_ago]\n",
+    "    df = df[df['bis_datum'] > five_years_ago]\n",
+    "    return df\n",
+    "\n",
+    "def download_and_extract_data(url, output_dir, stations_df):\n",
+    "    # Create output directory if it doesn't exist\n",
+    "    output_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "    # Fetch the webpage content\n",
+    "    response = requests.get(url)\n",
+    "    soup = BeautifulSoup(response.content, 'html.parser')\n",
+    "\n",
+    "    # Find all links to zip files\n",
+    "    zip_links = [link.get('href') for link in soup.find_all('a') if link.get('href', '').endswith('.zip')]\n",
+    "\n",
+    "    for zip_link in  tqdm(zip_links):\n",
+    "        # Extract station ID from the zip file name\n",
+    "        station_id = zip_link.split('_')[2]#.split('.')[0]\n",
+    "        # Check if this station ID is in our filtered dataframe\n",
+    "        if station_id in stations_df['Stations_id'].values:\n",
+    "            full_url = urljoin(url, zip_link)\n",
+    "            # Download the zip file\n",
+    "            zip_response = requests.get(full_url)\n",
+    "            \n",
+    "            # Extract the zip file in memory\n",
+    "            with zipfile.ZipFile(io.BytesIO(zip_response.content)) as zip_ref:\n",
+    "                # Find the file starting with 'produkt_'\n",
+    "                produkt_file = next((name for name in zip_ref.namelist() if name.startswith('produkt_')), None)\n",
+    "                if produkt_file:\n",
+    "                    # Extract, process and save the 'produkt_' file\n",
+    "                    with zip_ref.open(produkt_file) as source:\n",
+    "                        process_csv(source,url,output_dir,station_id)\n",
+    "                    print(f\"Extracted: {produkt_file}\")\n",
+    "                    break #TODO remove, this is for testing\n",
+    "                else:\n",
+    "                    print(f\"No 'produkt_' file found in {zip_link}\")\n",
+    "        else:\n",
+    "            print(f\"Skipping {zip_link} as it's not in the filtered station list\")\n",
+    "\n",
+    "def process_csv(source,url,output_dir,station_id):\n",
+    "    #Cases data loading \n",
+    "    if url.split(\"/\")[-3] == \"air_temperature\":\n",
+    "        usecols = [1,3,4]\n",
+    "    #TODO elif for the other directories. Some contain more than one feature. air_temperature for example has the air_temperature AND the air humidity\n",
+    "    df = pd.read_csv(source, delimiter=';', encoding='utf-8',usecols=usecols,index_col=0,parse_dates=True,date_format=\"%Y%m%d%H\")\n",
+    "\n",
+    "    #TODO i would suggest filtering the data to values in the last 20 years at most here\n",
+    "\n",
+    "    #cases saving\n",
+    "    if url.split(\"/\")[-3] == \"air_temperature\":\n",
+    "        (output_dir / \"air_temperature\").mkdir(exist_ok=True)\n",
+    "        (output_dir / \"air_humidity\").mkdir(exist_ok=True)\n",
+    "        df[[\"TT_TU\"]].to_csv(output_dir / \"air_temperature\" / f\"{station_id}.csv\")\n",
+    "        df[[\"RF_TU\"]].to_csv(output_dir / \"air_humidity\" / f\"{station_id}.csv\")\n",
+    "    #TODO elif for the other directories. Some contain more than one feature. air_temperature for example has the air_temperature AND the air humidity\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Usage\n",
+    "output_dir = Path(\"data/climate_data\")\n",
+    "\n",
+    "# Read and filter stations\n",
+    "#TODO choose which ones you want.\n",
+    "potential_sensors = [\"air_temperature\",\"cloud_type\",\"cloudiness\",\"dew_point\",\"global_radiation\",\"precipitation\",\"pressure\",\"soil_temperature\",\"solar\",\"sun\",\"visibility\",\"wind\"]\n",
+    "\n",
+    "for dir_part in potential_sensors:\n",
+    "    url = \"https://opendata.dwd.de/climate_environment/CDC/observations_germany/climate/hourly/\"+dir_part+\"/historical/\"\n",
+    "    print(f\"Processing {dir_part}\")\n",
+    "\n",
+    "    df_filtered_stations = read_and_filter_stations(url)\n",
+    "    #print(f\"Number of stations with data in the last 5 years: {len(df_filtered_stations)}\")\n",
+    "    download_and_extract_data(url, output_dir, df_filtered_stations)\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
+    "output_dir"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with zipfile.ZipFile(io.BytesIO(zip_response.content)) as zip_ref:\n",
+    "    with zip_ref.open(produkt_file) as source:\n",
+    "        df2 = process_csv(source,url,output_dir,station_id)\n",
+    "df2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Download and process data for filtered stations\n",
+    "download_and_extract_data(url, output_dir, filtered_stations)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.to_datetime(df['von_datum'], format='%Y%m%d')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_filtered"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dwd_base_url = \"https://opendata.dwd.de/climate_environment/CDC/observations_germany/climate/hourly/\"\n",
+    "sensor_types = [\"air_temperature\",\"dew_point\",\"moisture\",\"precipitation\",\"pressure\",\"sun\",\"wind\"]\n",
+    "\n",
     "start_list = []\n",
     "\n",
     "for sensor_type in sensor_types:\n",
@@ -100,6 +297,13 @@
     "fig.savefig(\"dwd_data_availability.png\")"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -559,6 +763,440 @@
     "Counter([x[\"DataUnit\"] for station in stations_by_region for x in station[\"tslist\"]])\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_135949/3569064465.py:1: DeprecationWarning: \n",
+      "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n",
+      "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n",
+      "but was not found to be installed on your system.\n",
+      "If this would cause problems for you,\n",
+      "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n",
+      "        \n",
+      "  import pandas as pd\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from os.path import dirname, abspath\n",
+    "import statistics\n",
+    "from torch.utils.data import Dataset\n",
+    "from sklearn.manifold import TSNE\n",
+    "from sklearn.decomposition import PCA\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import plotly.graph_objects as go\n",
+    "from plotly.subplots import make_subplots\n",
+    "\n",
+    "def fill_missing_values(df: pd.DataFrame, max_fill=10) -> pd.DataFrame:\n",
+    "    \"\"\"\n",
+    "    Fills values in a DataFrame.\n",
+    "    First columns recognized as Precipitation columns (containing NEW or NVh) are filled with 0,\n",
+    "    other columns are filled linear with a limit of 24, with warning if more than 5 continuos values are missing\n",
+    "\n",
+    "    Args:\n",
+    "        df : DataFrame that might be missing values\n",
+    "        max_fill : How many continuosly missing values are allowed\n",
+    "    Returns:\n",
+    "        DataFrame: Filled DataFrame (if possible)\n",
+    "    \"\"\"\n",
+    "    old_size = df.shape[0]\n",
+    "\n",
+    "    df = df.resample(\"h\").mean()  # TODO maybe not 'h' for other datasets?\n",
+    "    na_count = df.isna().sum(axis=0)\n",
+    "\n",
+    "    # get all columns with precipitation and fill missing values with 0\n",
+    "    mask = df.columns.str.contains(\"NEW\") | df.columns.str.contains(\"NVh\")\n",
+    "\n",
+    "    prec_cols = list(na_count[mask][na_count[mask] > 0].index)\n",
+    "    if len(prec_cols) > 0:\n",
+    "        df.loc[:, mask] = df.loc[:, mask].fillna(0)\n",
+    "\n",
+    "    # interpolate data in all other columns\n",
+    "    df = df.interpolate(limit=max_fill, limit_direction=\"both\")\n",
+    "\n",
+    "    if df.isna().sum().sum() > 0:\n",
+    "        raise ValueError(\n",
+    "            f\"Some columns were missing more than {max_fill} continuous values, either raise the limit or fill values manually.\"\n",
+    "            + f\"{df.isna().sum().sum()} still missing, maybe due to {len(df)-old_size} missing timestamps?\"\n",
+    "        )\n",
+    "    return df\n",
+    "\n",
+    "class TimeSeriesDataSetGAN(Dataset):\n",
+    "    \"\"\"\n",
+    "    Custom trivial Dataset, just takes a rolling window of X with length in_size and y with length out_size (shifted by in_size)\n",
+    "\n",
+    "    Args:\n",
+    "        X (Tensor): Input values\n",
+    "        y (Tensor): Target values\n",
+    "        in_size (int): input length in hours\n",
+    "        out_size (int): output length in hours\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, X, seq_len) -> None:\n",
+    "        self.X = X\n",
+    "        self.seq_len = seq_len\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        return len(self.X) - self.seq_len\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        if idx >= len(self):\n",
+    "            raise IndexError(\n",
+    "                f\"Index {idx} is out of range, dataset has length {len(self)}\"\n",
+    "            )\n",
+    "        return self.X[idx : idx + self.seq_len].values\n",
+    "\n",
+    "def plot_tsne_plotly(real_tsne_results: np.ndarray, fake_tsne_results: np.ndarray, window_size: int):\n",
+    "    \"\"\"Plot t-SNE results using Plotly.\"\"\"\n",
+    "    fig = go.Figure()\n",
+    "\n",
+    "    # Add t-SNE scatter plot\n",
+    "    fig.add_trace(\n",
+    "        go.Scatter(\n",
+    "            x=real_tsne_results[:, 0],\n",
+    "            y=real_tsne_results[:, 1],\n",
+    "            mode='markers',\n",
+    "            marker=dict(\n",
+    "                size=5,\n",
+    "                color=\"blue\"\n",
+    "            ),\n",
+    "            name='Real Data'\n",
+    "        )\n",
+    "    )\n",
+    "    fig.add_trace(\n",
+    "        go.Scatter(\n",
+    "            x=fake_tsne_results[:, 0],\n",
+    "            y=fake_tsne_results[:, 1],\n",
+    "            mode='markers',\n",
+    "            marker=dict(\n",
+    "                size=5,\n",
+    "                color=\"red\"\n",
+    "            ),\n",
+    "            name='Fake Data'\n",
+    "        )\n",
+    "    )\n",
+    "\n",
+    "    # Update layout\n",
+    "    fig.update_layout(\n",
+    "        title=f't-SNE of Multivariate Time Series (Window Size: {window_size})',\n",
+    "        height=900,\n",
+    "        hovermode='closest'\n",
+    "    )\n",
+    "\n",
+    "    # Update axes\n",
+    "    fig.update_xaxes(title_text='t-SNE 1')\n",
+    "    fig.update_yaxes(title_text='t-SNE 2')\n",
+    "    \n",
+    "    fig.show()\n",
+    "    \n",
+    "def my_load_data_gan(\n",
+    "    data_path,\n",
+    "    filter=None,\n",
+    "):\n",
+    "    df = pd.read_csv(data_path, index_col=0, parse_dates=True)\n",
+    "    df = fill_missing_values(df)\n",
+    "\n",
+    "    # TODO spaltenname generieren\n",
+    "    dataset = TimeSeriesDataSetGAN(df, 144 + 48)\n",
+    "\n",
+    "    return dataset\n",
+    "    # TODO 2. Klasse bauen die filtert\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ds = my_load_data_gan(\"../KIWaVo/data/input/Hollingstedt8.csv\")\n",
+    "real_data = np.array([ds[i] for i in range(len(ds))])\n",
+    "real_data2 = real_data.reshape(real_data.shape[0],-1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_samples=10000\n",
+    "tsne = TSNE(n_components=2, random_state=42)\n",
+    "real_data_tsne = tsne.fit_transform(real_data2[:num_samples])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plot_tsne_plotly(real_data_tsne,real_data_tsne,ds.seq_len)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"../KIWaVo/data/input/Hollingstedt8.csv\", index_col=0, parse_dates=True)\n",
+    "df = fill_missing_values(df)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch \n",
+    "hours = df.index.hour\n",
+    "hour_rad = torch.tensor(2*torch.pi*hours/24)\n",
+    "df[\"h_sin\"] = torch.sin(hour_rad)\n",
+    "df[\"h_cos\"] = torch.cos(hour_rad)\n",
+    "\n",
+    "days = df.index.day_of_year + hours / 24\n",
+    "days_rad = torch.tensor(2*torch.pi*days/365)\n",
+    "df[\"d_sin\"] = torch.sin(days_rad)\n",
+    "df[\"d_cos\"] = torch.cos(days_rad)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='tstamp'>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df[[\"h_sin\",\"h_cos\",\"d_sin\",\"d_cos\"]][:1000].plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 147,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "windows[0].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "anal_sample_no = 1000\n",
+    "seq_len = ds.seq_len\n",
+    "for i in range(anal_sample_no):\n",
+    "    if (i == 0):\n",
+    "        prep_data = np.reshape(np.mean(real_data[0,:,:], 1), [1,seq_len])\n",
+    "        #prep_data_hat = np.reshape(np.mean(generated_data[0,:,:],1), [1,seq_len])\n",
+    "    else:\n",
+    "        prep_data = np.concatenate((prep_data, \n",
+    "                                    np.reshape(np.mean(real_data[i,:,:],1), [1,seq_len])))\n",
+    "        #prep_data_hat = np.concatenate((prep_data_hat, \n",
+    "        #                                np.reshape(np.mean(generated_data[i,:,:],1), [1,seq_len])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prep_data.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\"\"\"Time-series Generative Adversarial Networks (TimeGAN) Codebase.\n",
+    "\n",
+    "Reference: Jinsung Yoon, Daniel Jarrett, Mihaela van der Schaar, \n",
+    "\"Time-series Generative Adversarial Networks,\" \n",
+    "Neural Information Processing Systems (NeurIPS), 2019.\n",
+    "\n",
+    "Paper link: https://papers.nips.cc/paper/8789-time-series-generative-adversarial-networks\n",
+    "\n",
+    "Last updated Date: April 24th 2020\n",
+    "Code author: Jinsung Yoon (jsyoon0823@gmail.com)\n",
+    "\n",
+    "-----------------------------\n",
+    "\n",
+    "visualization_metrics.py\n",
+    "\n",
+    "Note: Use PCA or tSNE for generated and original data visualization\n",
+    "\"\"\"\n",
+    "\n",
+    "# Necessary packages\n",
+    "from sklearn.manifold import TSNE\n",
+    "from sklearn.decomposition import PCA\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "   \n",
+    "def visualization (ori_data, generated_data, analysis):\n",
+    "  \"\"\"Using PCA or tSNE for generated and original data visualization.\n",
+    "  \n",
+    "  Args:\n",
+    "    - ori_data: original data\n",
+    "    - generated_data: generated synthetic data\n",
+    "    - analysis: tsne or pca\n",
+    "  \"\"\"  \n",
+    "  # Analysis sample size (for faster computation)\n",
+    "  anal_sample_no = min([1000, len(ori_data)])\n",
+    "  idx = np.random.permutation(len(ori_data))[:anal_sample_no]\n",
+    "    \n",
+    "  # Data preprocessing\n",
+    "  ori_data = np.asarray(ori_data)\n",
+    "  generated_data = np.asarray(generated_data)  \n",
+    "  \n",
+    "  ori_data = ori_data[idx]\n",
+    "  generated_data = generated_data[idx]\n",
+    "  \n",
+    "  no, seq_len, dim = ori_data.shape  \n",
+    "  \n",
+    "  for i in range(anal_sample_no):\n",
+    "    if (i == 0):\n",
+    "      prep_data = np.reshape(np.mean(ori_data[0,:,:], 1), [1,seq_len])\n",
+    "      prep_data_hat = np.reshape(np.mean(generated_data[0,:,:],1), [1,seq_len])\n",
+    "    else:\n",
+    "      prep_data = np.concatenate((prep_data, \n",
+    "                                  np.reshape(np.mean(ori_data[i,:,:],1), [1,seq_len])))\n",
+    "      prep_data_hat = np.concatenate((prep_data_hat, \n",
+    "                                      np.reshape(np.mean(generated_data[i,:,:],1), [1,seq_len])))\n",
+    "    \n",
+    "  # Visualization parameter        \n",
+    "  colors = [\"red\" for i in range(anal_sample_no)] + [\"blue\" for i in range(anal_sample_no)]    \n",
+    "    \n",
+    "  if analysis == 'pca':\n",
+    "    # PCA Analysis\n",
+    "    pca = PCA(n_components = 2)\n",
+    "    pca.fit(prep_data)\n",
+    "    pca_results = pca.transform(prep_data)\n",
+    "    pca_hat_results = pca.transform(prep_data_hat)\n",
+    "    \n",
+    "    # Plotting\n",
+    "    f, ax = plt.subplots(1)    \n",
+    "    plt.scatter(pca_results[:,0], pca_results[:,1],\n",
+    "                c = colors[:anal_sample_no], alpha = 0.2, label = \"Original\")\n",
+    "    plt.scatter(pca_hat_results[:,0], pca_hat_results[:,1], \n",
+    "                c = colors[anal_sample_no:], alpha = 0.2, label = \"Synthetic\")\n",
+    "  \n",
+    "    ax.legend()  \n",
+    "    plt.title('PCA plot')\n",
+    "    plt.xlabel('x-pca')\n",
+    "    plt.ylabel('y_pca')\n",
+    "    plt.show()\n",
+    "    \n",
+    "  elif analysis == 'tsne':\n",
+    "    \n",
+    "    # Do t-SNE Analysis together       \n",
+    "    prep_data_final = np.concatenate((prep_data, prep_data_hat), axis = 0)\n",
+    "    \n",
+    "    # TSNE anlaysis\n",
+    "    tsne = TSNE(n_components = 2, verbose = 1, perplexity = 40, n_iter = 300)\n",
+    "    tsne_results = tsne.fit_transform(prep_data_final)\n",
+    "      \n",
+    "    # Plotting\n",
+    "    f, ax = plt.subplots(1)\n",
+    "      \n",
+    "    plt.scatter(tsne_results[:anal_sample_no,0], tsne_results[:anal_sample_no,1], \n",
+    "                c = colors[:anal_sample_no], alpha = 0.2, label = \"Original\")\n",
+    "    plt.scatter(tsne_results[anal_sample_no:,0], tsne_results[anal_sample_no:,1], \n",
+    "                c = colors[anal_sample_no:], alpha = 0.2, label = \"Synthetic\")\n",
+    "  \n",
+    "    ax.legend()\n",
+    "      \n",
+    "    plt.title('t-SNE plot')\n",
+    "    plt.xlabel('x-tsne')\n",
+    "    plt.ylabel('y_tsne')\n",
+    "    plt.show()    "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/src/main_hyper.py b/src/main_hyper.py
index 03a514d7553324e37fc2ee7ed634a32ee230388e..015ff821af0fe3125a2c4708b725411e42e944fe 100644
--- a/src/main_hyper.py
+++ b/src/main_hyper.py
@@ -140,11 +140,11 @@ class Objective:
 
     def _get_model_params(self,trial : optuna.Trial):
         #differencing = 0
-        differencing = trial.suggest_int("differencing", 0, 1)
+        differencing = trial.suggest_int("differencing", 1, 1)
         learning_rate = trial.suggest_float("lr", 0.00001, 0.01)
-        # optimizer = trial.suggest_categorical("optimizer", ["adam","adamw"])
+        # optimizer = trial.suggest_categorical("optimizer", ["adam","adamw"])  
         optimizer = trial.suggest_categorical("optimizer", ["adam"])
-        embed_time = trial.suggest_categorical("embed_time", [True,False])
+        embed_time = trial.suggest_categorical("embed_time", [False])
         #model_architecture = trial.suggest_categorical("model_architecture", ["classic_lstm"])
         #model_architecture = trial.suggest_categorical("model_architecture", ["transformer","autoformer"]) #TODO add models here
         #model_architecture = trial.suggest_categorical("model_architecture", ["autoformer"])
@@ -174,7 +174,7 @@ class Objective:
         if model_architecture in ["classic_lstm", "last_lstm"]:
             model_params = dict(
                 hidden_size_lstm=trial.suggest_int("hidden_size_lstm", 32, 512),
-                num_layers_lstm=trial.suggest_int("n_layers_lstm", 1, 3),
+                num_layers_lstm=trial.suggest_int("n_layers_lstm", 1, 2),#3
                 # num_layers_lstm = trial.suggest_int("n_layers_lstm", 1, 1),
                 hidden_size=trial.suggest_int("hidden_size", 32, 512),
                 num_layers=trial.suggest_int("n_layers", 2, 4),
diff --git a/src/utils/utility.py b/src/utils/utility.py
index 71e2ea1123674cbde055bdeb71b42f276c94dd21..954e1253f69577c17d0cd8b1e571e6140f752eff 100644
--- a/src/utils/utility.py
+++ b/src/utils/utility.py
@@ -8,7 +8,7 @@ import torch
 import pandas as pd
 from utils.timefeatures import time_features
 
-def fill_missing_values(df: pd.DataFrame, max_fill=10) -> pd.DataFrame:
+def fill_missing_values(df: pd.DataFrame, max_fill=200) -> pd.DataFrame:
     """
     Fills values in a DataFrame.
     First columns recognized as Precipitation columns (containing NEW or NVh) are filled with 0,
@@ -26,7 +26,7 @@ def fill_missing_values(df: pd.DataFrame, max_fill=10) -> pd.DataFrame:
     na_count = df.isna().sum(axis=0)
 
     # get all columns with precipitation and fill missing values with 0
-    mask = df.columns.str.contains('NEW') | df.columns.str.contains('NVh')
+    mask = df.columns.str.contains('NEW') | df.columns.str.contains('NVh') | (df.columns.str.startswith('N') & df.columns.str.endswith('_mm'))
 
     prec_cols = list(na_count[mask][na_count[mask] > 0].index)
     if len(prec_cols) > 0: