diff --git a/hopfield/hopfield.ipynb b/hopfield/hopfield.ipynb index 04485ea..44375a8 100644 --- a/hopfield/hopfield.ipynb +++ b/hopfield/hopfield.ipynb @@ -6,28 +6,23 @@ "metadata": {}, "outputs": [], "source": [ - "from typing import List, Optional, Callable, Iterable\n", + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", "from itertools import islice" ] }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "from tqdm.auto import tqdm" - ] - }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "from matplotlib import pyplot as plt\n", - "import matplotlib.dates as mdates\n", - "import json" + "from gluonts.evaluation import make_evaluation_predictions, Evaluator\n", + "from gluonts.dataset.repository.datasets import get_dataset\n", + "\n", + "from estimator import HopfieldEstimator" ] }, { @@ -36,40 +31,7 @@ "metadata": {}, "outputs": [], "source": [ - "import torch" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from gluonts.dataset.repository.datasets import get_dataset\n", - "from gluonts.dataset.util import to_pandas\n", - "from gluonts.evaluation import Evaluator\n", - "from gluonts.evaluation.backtest import make_evaluation_predictions" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from pts.model.hopfield import HopfieldEstimator\n", - "from pts.dataset.repository.datasets import dataset_recipes\n", - "from pts.modules import ZeroInflatedNegativeBinomialOutput, NegativeBinomialOutput\n", - "from pts import Trainer" + "dataset = get_dataset(\"electricity\")" ] }, { @@ -78,7 +40,22 @@ "metadata": {}, "outputs": [], "source": [ - "dataset = get_dataset(\"electricity\", regenerate=False)" + "estimator = HopfieldEstimator(\n", + " freq=dataset.metadata.freq,\n", + " prediction_length=dataset.metadata.prediction_length,\n", + " num_feat_static_cat=1,\n", + " cardinality=[321],\n", + " embedding_dimension=[3],\n", + " dim_feedforward=32,\n", + " num_encoder_layers=2,\n", + " num_decoder_layers=2,\n", + " nhead=2,\n", + " activation=\"relu\",\n", + "\n", + " batch_size=128,\n", + " num_batches_per_epoch=100,\n", + " trainer_kwargs=dict(max_epochs=50, accelerator='gpu', gpus=1),\n", + ")" ] }, { @@ -90,4022 +67,412 @@ "name": "stderr", "output_type": "stream", "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/common.py:321: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", - " timestamp = pd.Timestamp(string, freq=freq)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/common.py:324: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", + "GPU available: True, used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "/home/kashif/.env/pytorch/lib/python3.8/site-packages/pytorch_lightning/trainer/configuration_validator.py:122: UserWarning: You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\n", + " rank_zero_warn(\"You defined a `validation_step` but have no `val_dataloader`. Skipping val loop.\")\n", + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:324: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " timestamp = pd.Timestamp(timestamp_input, freq=freq)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " if isinstance(timestamp.freq, Tick):\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/common.py:326: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", " timestamp.floor(timestamp.freq), timestamp.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/common.py:325: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:327: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " if isinstance(timestamp.freq, Tick):\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", " return pd.Timestamp(\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/util.py:128: FutureWarning: Timestamp.freqstr is deprecated and will be removed in a future version.\n", - " freq = start.freqstr\n" + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:329: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " timestamp.floor(timestamp.freq), timestamp.freq\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/dataset/common.py:328: FutureWarning: The 'freq' argument in Timestamp is deprecated and will be removed in a future version.\n", + " return pd.Timestamp(\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:343: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base = start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " return _shift_timestamp_helper(ts, ts.freq, offset)\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:384: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " ..., i0 : i0 + length * start.freq.n : start.freq.n\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "/home/kashif/gluon-ts-PR/src/gluonts/transform/feature.py:340: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version.\n", + " self._freq_base is None or self._freq_base == start.freq.base\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------\n", + "0 | model | HopfieldModel | 78.2 K\n", + "1 | loss | NegativeLogLikelihood | 0 \n", + "------------------------------------------------\n", + "78.2 K Trainable params\n", + "0 Non-trainable params\n", + "78.2 K Total params\n", + "0.313 Total estimated model params size (MB)\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEUCAYAAADQoHYKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABBBklEQVR4nO2deZwU1bX4v2cGmGHYdxAUUFZBAUERURzEBWOemuW9FxMTzYsh+T1fJMl7RkzMMzHRmGcSTaJRMRpNVNyNKIgC0oLsO7IP+z6sM8wMzH5/f3T3TM9Mb9Vd1VXdc76fDx96qk7de6rq1rnbueeKMQZFURQls8hyWwFFURTFftS4K4qiZCBq3BVFUTIQNe6KoigZiBp3RVGUDESNu6IoSgaixl1RFCUDUeOuKBEQkc4i8q6IlInIXhH5uts6KUq8tHBbAUXxME8BlUAPYCQwS0TWG2M2uaqVosSB6ApVRWmKiLQBTgHDjTHbA8f+ARw0xkxzVTlFiQMdllGU8AwCqoOGPcB6YJhL+iiKJdS4K0p42gKnGx0rBtq5oIuiWEaNu6KEpxRo3+hYe6DEBV0UxTJq3BUlPNuBFiIyMOTYCEAnU5W0QCdUFSUCIvIaYIC78HvLzAauUG8ZJR3QlruiROY/gdbAUWAG8P/UsCvpgrbcFUVRMhBtuSuKomQgatwVRVEyEDXuiqIoGYgad0VRlAxEjbuiKEoG4omokB07djQDBgyIW76srIw2bdrYLuultJ2WV128q0ci8s1FF73Phqxevfq4MaZb2JPGGNf/DRo0yFhhwYIFjsh6KW2n5VUX7+qRiHxz0UXvsyHAKhPBrsYclhGRF0TkqIhsDHPuv0XEiEjXwN8iIn8SkR0iskFELolZ9SiKoii2E8+Y+4vA5MYHReRc4HpgX8jhG4GBgX9TgKeTV1FRFEWxSkzjboxZCJwMc+px4Cf4Y28EuQX4e6DHsAzoKCK9bNFUURRFiZu4wg+ISD/gA2PM8MDftwDXGGOmisgeYIwx5riIfAA8aoz5LCA3H7jPGLMqTJpT8Lfu6dat2+g33nij8XnatGlDdnZ2E32MMYhIXDdoRdZLaTstHypbU1NDWVkZ0cpCaWkpbdu2jVsXK/JOpm1F3it6JCLfXHTR+2zIxIkTVxtjxoQ9GWkwPvQf0A/YGPidBywHOgT+3gN0Dfz+ALgy5Lr5+A2/5QnVXbt2mWPHjpna2tom506fPh3XZINVWS+l7bR8ULa2ttYcO3bM7Nq1K6q8FyaPnJb3ih6JyDcXXfQ+G0IyE6phuADoD6wPtNr7AGtEpCdwEDg3RLZP4JhlysvL6dKli6WWq2IdEaFLly6Ul5e7rYqiKDZi2bgbYz43xnQ3xvQzxvQDDgCXGGOOADOBbwW8Zi4Hio0xhxNVzg7Dbup7EUoEtAJVlMwjHlfIGcBSYLCIHBCR70QRnw3sAnYAz+GPh+0qe07XcqjYequ0qKiIv/zlLwnl+YUvfIGioqKErk2EK664ImV5KYqSHsTjLXObMaaXMaalMaaPMeb5Ruf7GWOOB34bY8zdxpgLjDEXmTATqW5worTC8jXRjHt1dXXUa2fPnk3Hjh0t52mVoB5LlixxPC9FUdILjS0TgWnTprFz505GjhzJvffei8/n46qrruLmm2/mwgsvBOC2225j9OjRDBs2jOnTp9dd269fP44fP86ePXsYOnQo3/3udxk2bBi33HILZ8+ebZLXm2++yfDhwxkxYgQTJkwA/B4sDzzwAJdeeikXX3wxzz77LEBYPUJn1R977LG6ax588EHAv5T5pptuYsSIEQwfPpzXX3/dmYemKIpn8ERsmVj88v1NbD50uu7vmpqasC6S4Sir8Ldu2+Q0vNULz2nPg/8yLOJ1jz76KBs3bmTdunWA36iuWbOGjRs30r9/fwCeeuop+vbty9mzZ7n00kv5yle+QpcuXRqkU1BQwIwZM3juuef48pe/zNtvv83tt9/eQOahhx7io48+onfv3nXDOc8//zzt27dn5cqVVFRUMH78eK6//nqAJnoEmT9/PgUFBaxYsQJjDDfffDMLFy7k2LFjnHPOOcyaNQuA4uLiuJ6doijpi7bcLXDZZZc1MKjPPPMMI0aM4PLLL2f//v0UFBQ0uaZ///6MHDkSgJEjR7Jnz54mMuPHj+fOO+/kueeeo6amBoCPP/6YGTNmMHLkSMaOHcuJEyfq0m+sR5BPPvmEjz/+mFGjRnHJJZewdetWCgoKuOiii5g7dy733XcfixYtokOHDjY8DcUJlu06wS9m6jatSvJ4ruVefKaKk2cqGxxr3MIuKSmhXbt2caW34UARABf36Zi0bqFR2nw+Hz6fj6VLl5KXl0d+fn5Yd8KcnJy639nZ2VRVVTWReeaZZ1i+fDmzZs1i9OjRrF69GmMMjz32GF/60pcayPp8vojR4owx3H///Xzve99rcm7NmjXMnj2bBx54gEmTJvGjH/0o7vtWUsfXpi8D4Bc3R+5VKko8eK7lfsMTC5n4O5/batCuXTtKSkoini8uLqZjx47k5eWxdetWli1blnBeO3fuZOzYsTz00EN069aN/fv3c8MNN/D888/XVQbbt2+nrKwsajqTJk3ihRdeoLS0FICDBw9y9OhRDh06RF5eHrfffjv33nsva9asSVhXRVHSA8+13I+c9sZimi5dujB+/HiGDx/OjTfeyE033dTg/OTJk3nyyScZOnQogwcP5vLLL084r3vvvZeCggKMMUyaNIkRI0Zw8cUXs337di655BKMMXTr1o1//vOfUdOZNGkSe/fuZdy4cYB/ovXll19mx44d3HvvvWRlZdGyZUueflrjuSlKpuM54+4lXn311QZ/5+fn1/3OycnhnXfeCTs8FBxX79q1Kxs31kdKvueee8LKv/POO02OiQgPPvggv/vd75roEKoHUNdSB5g6dSpTp05tcP6CCy7ghhtuaHAsWq9EUZT0x3PDMoqiKEryqHFXFEXJQNS4K4qiZCCeNu4a8Cs16HNWlMzDs8Y9NzeXEydOqOFxGGMMJ06cIDc3121VFEWxEc96y/Tp04cDBw5w7NixJufKy8vjNkaFp/yxXLaUtI5L3kraVmS9Jh8qm5ubS58+feLOR1EU7+NZ496yZcuwS+zBv0pz1KhRcaVz4zR/PJU9j94UQ9J62lZkvSZvNW1FUdILzw7LKIqiKImjxl1RFCUDUeOuKIqSgahxVxRFyUDUuCuKomQgatwbUVRey0ebjrithqIoSlLENO4i8oKIHBWRjSHHHhORrSKyQUTeFZGOIefuF5EdIrJNRG4Im6iHeWFTJd/7x2qqamrdVkVRFCVh4mm5vwhMbnRsLjDcGHMxsB24H0BELgS+BgwLXPMXEYlvs1OPsOl4jdsqKIqiJE1M426MWQicbHTsY2NMdeDPZUBweeMtwGvGmApjzG5gB3CZjfoqiqIocSDxxG4RkX7AB8aY4WHOvQ+8box5WUSeBJYZY14OnHse+NAY81aY66YAUwC6des2+o033gDgzjn+reReuCGPWgMtsqSJPqWlpbRt2zauGwym9+Lk8PuONuY/Piql1gh/vT4vbN6J6uE1edXFm3qEltd0fIahssYYqg20tPE78uJ9upn2xIkTVxtjxoQ9aYyJ+Q/oB2wMc/xnwLvUVxJPAreHnH8e+Gqs9AcNGmSC9L3vA9P3vg/M7X9dZvre94EJx4IFC8IeD0cwvXg5f5pfvqKqJqasFT28Jq+6eFOP0PKajs8wVPZvn+0yfe/7wBwpPmt72l6Q90LawCoTwa4m7C0jIncCXwS+EcgE4CBwbohYn8AxyywqOJ6oaoqieID3NxwGYP/JMy5r0jxJyLiLyGTgJ8DNxpjQNzcT+JqI5IhIf2AgsCJ5NRVFSVcqq9XzzA3icYWcASwFBovIARH5Dv7hl3bAXBFZJyLPABhjNgFvAJuBOcDdxpi0dD8xaBx5RUmG2kCH/oevr3NXkWZKzJC/xpjbwhx+Por8w8DDySjlJsGpn5+8tYFbR/Vm4uDuruqjKOlKbaB9dLSkIum07n9nA9cM6UHLpFNqPugK1UYE2+vvrTvEt/+20lVdFEXxM2PFfr7791Vuq5FWqHFXFEXJQDxv3Ec+9DFnKqtjCyqK4i1irKH5/EAxQ37+IUUVOuHqBJ437kVnqliztyhu+dV7T7L7eFnC+UVfbqEoil28sHg35VW1EUN+GGOYuf6QetskiOeNO8Adf4vfm/IrTy9l4u98zimjKEpKmLflKPfMWMsf5293W5W0JC2Me01tbLfEBVuP0i+wGbaipDtvrNrvtgpJk6wz8akzlQAUnk7e26Y5khbGPR7eXG3TxxDHuMz2whJmrj9kT36KEoYXPttt+ZraWsOzn+6kpLzKAY1Sz8x1/m8sjvBXShgyxrgnQ02tobwq/rVW1z++kHtmrHVQI0WxRmWNYfbGw/zmw608PGsLZyvTcu1gAz7b0TQESWWNoTaOnryixh2A7/1jNUN+Psf/h5YbJc0oPlPFlLln+K9X/Q2OOZuOMPR/57Bs1wmXNbOfKXPP8D9vrndbjbRAjTswb0uh2yooSsIcL2s4Jl10xj8ss2rPyXDiaUfjUCDvrE0oFmGzwzPG/WhJOaUV9vqzJ+RClaAvZG2tYe+JxF0wFSUc+0+eoVq3fFQSwDPG/bKH5zP5iYW2pnnf2xtsTS8azy7cxdWP+dh2pCRleSqZTVFFLVf93wJ+PWuL26okhG0ToTpUmhCeMe4AB06dtS2thduP8W4C3bdE10us2O0f3zxYpLGrFXso83sCsjjMxKKixMJTxj0Wq/eeitur5VsvaBh5JX2x0tDJdFfBsxY82ZR60sa4Hyo6y1eeXsK0FA61KIpb2DH/JJIZwTQ+3HjEbRXSkrQx7sHC/s91h5ixtaF3wP6TZ5j9eewCcKykggt+Ops1+045oqOiOEG6Nsx1wxt3SRvjHspHexq2aubEWbO/u/YANbWG5xNY/ReLBduOAfD2moNxhUtQlJgk2fA2Lo7XnK2sYePB067lr6SpcU+UR2ZvdSTdtSE9gVkbDvPikj2O5KMo6cIv39/ktgrNnpjb7KUDbg8tNh4fPVmmgY6UVGJ/Cz0YhO/Wkecwc/0hXrihjaXrDxeX266TYo14Nsh+QUSOisjGkGOdRWSuiBQE/u8UOC4i8icR2SEiG0TkkniUqHJpjcbp8iqe9u2MW37OxsOs31/U4NiafaeYu1lXuHqN4LvNhDgkO46WJnSdHROq/1x3iEQe4dKd8Yc+qKqFJz8p0MVaNhNPy/1F4Eng7yHHpgHzjTGPisi0wN/3ATcCAwP/xgJPB/6PysHSWnpZ09sWHnp/M2+tPhC3/PdfXtPk2Jf/ssROlRSb+MXMTbyz5iCDe7ZN27HHdHZxrLRgqGfurOLkpu10bpPD18eeB5ARlbLbxCz3xpiFQOMgFbcALwV+vwTcGnL878bPMqCjiLhht6MTKDd7Gu3YpGF8M4fScv9QWWV1+hqJ17ZWuq1CSqio8b+j0DUsD89Oz1W5XiLRRk0PY8zhwO8jQI/A795AaGD1A4FjjmK1+1lR7S9EhSUNxwUXbj9mm07GGH47ZysFhRqOQEmMjSfiXbzjfX/2l5bsYVHBMVbsPsn0heGHQoPV8BPztjvi0dbcSHpC1RhjRMRy80hEpgBTAFr1HBBTfsHihitOfT5f3e8de2JvThAqP2/LUd7+8BP2n2y4CvDIkaYulaHXNaa0tJRwH9bevfuY+fFhnvadYcbSXTwxMa9OPlp64dJ3Sj7TdTl+3F9xb9q0kcFtyuNK30vPpDHvf7wAAdq2alreDpWGHwLZtWsXPgk/7Oik7kWnm34XD85s6D0zqHY/Rwr978jvsins2LEDX/VenpgXOwCfF8p5KtIurTTUGmifY70CT9S4F4pIL2PM4cCwy9HA8YPAuSFyfQLHmmCMmQ5MB8jpNTBm5fCbFQ1b2fn5+XW/d322G7Zujnp9fn4+zKnfhu+/P226vLtnz55wsOHHEJpP6PUAbdu2BZoWxL59z+OKK/rDgnm0aNmyLg2fz9cwvRg4KZ/pury6bxUcLWTYsOHkHt8aV/qeeCZzwm8V+YNP/DGL9jx6U5NzO46WwGdNg+6df/755OeHbzjF1CVMWY/3Xr/+p4+A6Cts8/PzmVm4Dg4drOt5X3DBBeRfdX7EZ9D4+nhIt3LbWDbotRTuvcci0WGZmcAdgd93AO+FHP9WwGvmcqA4ZPgm43hspX2BzhQlnXlv3UGmvubfLGTjcWuhE8oyY1dAR0lkZ614XCFnAEuBwSJyQES+AzwKXCciBcC1gb8BZgO7gB3Ac8B/WtbIRax6J2w6EZ9HQEFhCYeLtSJwh/SdUHWL7QnME019bR3vrVOHBKdYm0DIlJjDMsaY2yKcmhRG1gB3W9YiSdxexNSYxpXEdY/7u8wvTra2EERJHK+ViXTi+seT3VdB0ErVfdLVBThlzN1cSHlVDYMe+DCh64+XNg93NsU9vOYPf7oycYWaa1C/Fz7bzWUPz7M1zYww7k420h6fu53DxeWJbdmnxM2CrUc5WKRDV24za0NqpsgiBdd7qZnGZXrog80cLYkStkRg48Fi1jVaIR+NjDDuSvrz7RdX8oU/LnJbjWbN4eKz3P1q01XYTvD3pXtSkk8m8cU/f8atTy2OWz4jjPvJMu8NfYQb871zThm/+iC6y2Zzpvisuk24SSp7p6fONH3Xv561RSdl46DftFms3NM4aEBTMsK47z5hz76lkTYXsBoXO9pknq68Sy1eG492ArtuccthXU3tVaTR4PO8LbGDFWaEcXcS9bpITxp/DM2R2lrD6fL4e0Pff3l1TJnyqpq6GDAV1TUJ+V8DzaPWdRk17oqS5kSqxv4wbzsX/+Jjis7YN2w55tfzGPLzOQBc+4dPGfq/c2xLW4lMIo3MjDDuXmujaXx3xQsEG8fhxrcTJXRjmmBspvvf0U3rU82x07E3BMoI4x4P8Yyb74ywKYLVDuT2wsQ2V1DsQzdndpbQjTVmrKgPBBvv/JS+neR4Z23YkF0NyAjjHk+X5dUV+2LKrD9QbIM2ipdoDnMmbhjK384Jvx/x35fujev65btje3s0RwpPh9+eMJFinBHGPR7+EWehUxQlNiv2hF9JuiHOBtKKZmjc399ZGdMVOpI7cCJbJjYb4771SGJuXom2/DYdOp3YhYqtZKJTxowV+9h6xN3y1Xgv4SBvr4l/28rmxtsFVSl1hU56sw4lPHe8sCK2kOIYmeoKub2whPvf+RxILMa3kp6ot0ya0FyDI3mZ11bs4zsflUWMeeIVimz0fAnyhT8u4pfvb4otqKSUsgprcfEbkxnGPc1mzV5dHntyV0ktD32wmRrTcJPmdCHZoafNh0/zt8V7bNHFCt6uRt1n/6n6lffNdkLVadOeieO2iqJkNhlh3Ctr0iscr1YWipJ+w6mppromOUOREcY9HbvSSmrItHrUrRHIvadr+NP8Ancyb6ZUhETpTOS9q7dMDDLV6yLTSbNpGM/z4JJyYLvbamQ8dvbqM6LlnoJRd4fTVxRFaUjDBkqKFzGJyI9EZJOIbBSRGSKSKyL9RWS5iOwQkddFpFUyecTDgVP2xHNXFEVxk1CDnmyTNWHjLiK9gXuAMcaY4UA28DXgt8DjxpgBwCngO0nqGJNEV5/Gj/bxFUVJLaEu3uGGGSuqo881Jjss0wJoLSItgDzgMHAN8Fbg/EvArUnm4QF0WCbTUQ8mxQtEKofhmpfT3v48aloJT6gaYw6KyO+AfcBZ4GNgNVBkjAkurToA9E40j1jc/coaxl3QxankHUPD0aYOq0bb6xOxXl9Bq6SOZbtORD2fsHEXkU7ALUB/oAh4E5hs4fopwBSAVj0HWM7f5/Mx6/MyZn1+2PK1VigpKWHFipW2prlx92F8vqKYcqWlpfh8vrjTtSLvZNqJ6BJsm/ztvfl0zBE65UbuVMaT9rFj/tCpmzZv4sK25XXyu4pq6Nxa6JjTMP2aWn8Xd9HCReS0iM/CO/0Mw7F45dq638G09pdEX+exfPly9rZpeL926JIsRwoT39QmVeW8rMpwoKSWwZ2zk047SLRrVq5cyeF2WZSWlrJrdf22h2vWrGkiW1ERfcOOZFwhrwV2G2OOAYjIO8B4oKOItAi03vsAYaPKG2OmA9MBcnoNtNwcyc/PhzmzElQ9ftq3b8dll42Azxbalub2U7V+/WPg8/nikktE3sm0E9EFygD45dJyWrfMZsuvIrcT4kn79QOrofAIw4cNI+/Etjr5O6fNolNeS9b+7/UN5LPnz4GaGq6acBV5reL7LBx5JjHK9PDhw2Gt/6MPprX1yGlYvCjiNWPHjqV/1zaRdUnBdxSOnj16wKHYm06EI1Xl/CtPL2H13lNs/dVkcltmR5WNSeA5h70mcG7MpWMY0rM9Pp+PPheMhGWLARg9enTd7yA5OTlRs0tmzH0fcLmI5Il/5H8SsBlYAHw1IHMH8F4SeXgCHY9NLWcdXpRm57ZzSmazORC6uzZFRiA0m1ufWhxZMA4SNu7GmOX4J07XAJ8H0poO3Af8WER2AF2A55PSUFEUpZlgZUI1FkmtUDXGPAg82OjwLuCyZNL1Eh6fX1MUJQWkY+89Q1aoKunM8sPJxa1uTizecbzJsXQ0POlCqr2n7MxPjXsM9LtxnmUOGvd4DZ+T7qnr9xfxxqr9tqQ1f8tRy9fsPl6a0u3dvEhVTS2PfbSV0iQ3wAhl3t4qCgrtXUAZcVimue7EpCiNSbQFFCtQXPGZKiqrrYWYvuWpxfzkrQ2JKWQD//HiKn71weaYKxozmbdWH+CpBTt5fK59wc9e3lLJF/4U2UvJbdS4x0DH3JVQRjz0Md/7xyrX8g9XaXl94ZUXqArs+ZBoBRepX1eVZMz1eEkkOm3aGvdUrtTToRkllAXbjrmtQgM0LHVsEn1CqX6ykYYHm9WwzMaDxW6roHiUs5U17Dha6rYajqCTp8mRrs8vkQ2J0ta4r913KjUZaZ837bjntbVsL8xM467FMUECD87rtj1S5fNfr64NfyIKaWvcDxaddVsFxaMs21kfUCnTgrSla8szLCmsqJLNyrj84I+cLrd8Tdoad0lVE8aYzPqgMoDKGoNvm3WXQC+z61gp2xLclyDeT8Fr5dgNfaxHCU3frlLa7qHqdk2quMc/NleyaO5KPpx6FUN7tbclTbeL0zW//zTha9PV/Ly7NrGgYYlQb6Mzx24cLo7emk/blnvKSOOaO12w+oQLz/jd2krK41uQsr+kln7TZvmjJ0YguNP8W6vtWWzkFOGGI5fGiOsdpDkX5WQ9itKxSkhb457K7tKpM5Upy0uxgUZFY+URfyXw0cbY8cOfmFfghEaO8o+le91WIW2wPCzjjBopIW2N+9nK1K22++Fr61KWl2I/wQ+0ptGXHW5oLx1bt6kKR5vOBN9r8FF5dVjXTrXS1rg3/lCdQoCjJdZnqhXvkFX3YdeXmXvfXE//+2ez85j7LpMl5cnFl0+mF7vLA/efCkKf0K5jpfS/fzazNji7i5vbpK1xT1XFu25/UWoyUuJm+ylrsV2Cti+0hfvm6gOAs4vh3li1n9V7T8aUK0zAzS2UeE17uG9m06HI8xCZSvCeZ2+M37h7tKEflbT1lqlweLeeUNLwvaYVdg+FNE4u2IKpiatOsE+ZeIOFlVdZq6yUxLG87iHO4lB4upwe7XMbHDtTWU11raF9bsu4s7NzXUbattzfSaEbVTrW2s2Zxq9LwgzLeIlkx8yTqRy9+UTsx8m5lA82HGLsI/NZ1shradxvPuHiX3xsKS0dc1cUCwQ/7HlbYnvLuDGhmugH3W/aLB56f7MGDrNAg2dtkyFdtccfCmVzoyGu4rPW51LsnBxX465kPEHjt/NYWRyyyXG6vMryJG0yn/MLi3fHXSGloyeQXQTLgCHB55CiLo6d0W7VuCsZR5Mx9ygfs90jNf/+7DImWVxt6uZwkVeHqmwn4c1bUkuH1vGPz8ciKeMuIh1F5C0R2SoiW0RknIh0FpG5IlIQ+L+TXcoqmcddL61idWFik+PxtMCMiV3I956ob9Ena+q2HLbufZIq89pc7Hg0rD4DJx7ZmF/PY//JM2HPtfeKcQf+CMwxxgwBRgBbgGnAfGPMQGB+4G9FCUs84+DJEqsSeHXFPsd1iIabred0DoxlheBdhnqjOBEx9MCpMzHdp4+XVqQkrk7Cxl1EOgATgOcBjDGVxpgi4BbgpYDYS8CtyamoKMkRzX41/sDT0dQlY6Cby7BM6DOyMgFt9cle+dsF3PrUYotXOUMyLff+wDHgbyKyVkT+KiJtgB7GmODqgCNAj2SVVJRk8KLB3l5YQr9ps9hwoIhk59C8eH9e5Z01B7n71TVuq8Ef5m6nOszCCzvr2mQWMbUALgF+YIxZLiJ/pNEQjDHGiEhYdUVkCjAFoFXPAUmokZ74fL6YMqWlpXHJJSLvZNqJyDcmnmvXrl1L2Z7sJsdrauqjRW7evJnKygoimcAtW7ZyoKT+I6usrIwrb5/PF/Uewx0PlZ+1yx+M7plZKxjRrek9WKGkND7vnIULF9IqWxrosuVQfJE1vYbVcr7tYFO3xKNHjzVJp/E7ra72P5/PFn9Gm5bhy9CBA/7Vzjt37AirXyRd5y74lNYtGqa5dOkSOuVmUVpaSrLVdjLG/QBwwBizPPD3W/iNe6GI9DLGHBaRXkDYXRWMMdOB6QA5vQY2j75hCPn5+TFlfD5fXHKJyDuZtiX5ObPCHo56beCaUaNGcWm/zk1OZ/s+gir/Rzlk6FDWbdwMhI/sOWTIELIKS2H3TgBatWoVV975+fnh7zHkfON7a9u2bZ38FnbC9q2ce965jBzcHVYsi5xnDNq1bQslsSdyJ0yYQG5Lf0US1L143UHYsC7hvN3Cajk/sfoAfL6+wbnu3buRnz86rHyQFr6PoLqa8ePH0zGvVcPEA++3T58+sG8PFwwYAFs31+sXWhZC5INceeWV5LVqQXaW1J0bN+4KenbIDVQIsV13o5HwsIwx5giwX0QGBw5NAjYDM4E7AsfuAN5LSkNFSYKpr62z5PJg1/zi4h3H45ZNtmWT6XOirVsm17NJBicnnO97ewMX/HS2Y+kn6y3zA+AVEdkAjAQeAR4FrhORAuDawN+K4hrRQrc8MnsrxWfrW/V2rfZcWHAsbtlkx1kz2bh//+oLWPPz65JOx4vPaPbnRxxNP6nAYcaYdcCYMKcmJZOukvnU1BqOl1Y4knbj1lZNFON5vLSCGSvc3X0pWZe8TA0/0LVtK6bdOMSWtMIZ90x3FErbqJBKevOHudt4asHOlOTVxsK6EFdaeEkaGSf8tb2BdyqtaBXBBxsOpU4RC2j4AcUVPt0e/7BFsnTM8Rfz/l3bxJRNeWvOuBuZMVX3O2XC+TFlFv1kIl3ahE5ahlfuvM55lvNPpHdTdKYyruBfx0v9w3rRGgYPz9ocV552bp6ixl1pNkSLMZNqQg1Bpg8PfH3sefzo2kEM6dkuqty5nfO4Zkj3mOm1zLb+IhPpkb28zL69aZ9btDsuuQfe22hbnmrclYyj6YfsbeuZucMqfn51y3Bat4rP4yWSER7bv97ltWW2PWbLSqWasjek8dzTnzdX7eeGxxe6rYZruDEJGI9bm5Nj7v/z6RmqAqsSQw1LsitUNx5MfKu8qvi2p0oZ2Vn1Jin0Gb1y19i63y0SaLl7mcaOBeVVNfzYFz6wmBXUuLvEvW9tYFthidtqKCnk+FnDqbJGi6nE3fguiWwoYRUrprh96/A+Hi2ys3jx25eSl6ALSLiK3SvukQsbzT8dLDrLyfLky4Qad6XZEI8RTUNnmaRwapFO746tbU8zf3B3BnZyb0FTLBKto52q29W4K67glVaTU1gadnLRujvVa/jiiF5Jp2GnZuHeRqxbD6340jF6pvq5KxmPle8yUkt23uZCenbIDXsuKUzmT6jGwz/vHu+2CknjtQaLGndFiYO7/r7K1vTccIVsnI8xhkqPTKj27xJ7DYJiDR2WUZoNXm0fu9Xjf3bhLv5vzjZH0rbDG8pLQyFOauJU2mrcFU9SXpXYvqrgpUXr8eGWCXt3jfNbvcWNBP+L/fYSsflhY8t4sLq3UyM17ooneWV57H1NrRrxY6edCVSWLLUpaqHWGkNldS07jpZQWuk9wxYP6VZxW8XO3oqOuSuuEOsjrU12ZU8IwZRKKjyw61DgxkO/4VSNPjzz6U4OFp3lnUCLfXCP6OEA7CLRiUZ7vWUyvVpoirbclbTnleV7eXzudrfVSIiXlu7hqQU7YgvawLJdJ5i3uTAleVnFSgWw6dBpFlmIl28H8VTAXqs+1Lgrac/P3t3IH+cX2JJWqt3Zyqtq+fxgcWozTQFOP8dvPr/Cknwi+li9JnRfAKf2KrCCGnfFHbzmFJxi3Lh9DzmfxEW66RsaTmT8o5+4qIkfNe6KO9jw5abZt+/HQ0of80DrMlUkW5darYwrquNfP7DRoZ6bGnclbamuMczZeDimXLRt9hqT6R2K0+X1k8onGwcxc5HgYw91T7TjXZRVmYjzDLHaF4u2129y7mQv4sUlexxJV427krZsPnya77+8JqbczJ3ORz5UmnLvDYOTut4Og/qXdeXc9fdVHC2x3ktZuutE8gq4SNLGXUSyRWStiHwQ+Lu/iCwXkR0i8rqItIqVhtIMsaFZVloe3rWxcXyYIgvhUx0f53WxZ7Bq76mU5nf3xAHsefQmxyJPxkPhGf8LrbQwTJIp2NFynwpsCfn7t8DjxpgBwCngOzbkoShxUVVT22S44VRF/Ba7ttbwtG8n5VU1GGOYvnAnJeXWW/5eWjqfTtjtj27Xa0jVatY9J87wP2+utyWtpBYxiUgf4CbgYeDH4q+irwG+HhB5CfgF8HQy+WQyxhhXWzbpTEV10xAFryS57+Wh4nJ+O2crJeVVXNq/M4/M3sq2I9Y3LZ67xZv+5F4l3DcQroJM9FMJH37Am6zdV2RLOsm23J8AfgIE+zxdgCJjTLC/fADonWQeSgZiR3X2F9/OJsfKKhOPSRNKaUU1FVX+Yp1Iyz14raK4RcItdxH5InDUGLNaRPITuH4KMAWgVc8BiaqR9vh8PhYeqKZzrnBRt4avo7S0FJ/PF3daVuSdTDse+dOnz0a9fsfOnfhqY8eXCcXn87F7lz0eIAcPHmRT+REAjh0/3uS8z+eLeo/l5eVhjy9ZsoSOOVnssklPr7Jv7z58viMNjpWVRX7nixYtonULYd+++udSXV3d5PlWV1cTbBrEUx5rTS0g7NzZtCFw/PjxujQ+3F3FwI5Z9Gx5Nmy6wfeWCFa+GztJZlhmPHCziHwByAXaA38EOopIi0DrvQ8QNvScMWY6MB0gp9dAr/aQHCc/P59v3z8bgD2PXtvgnM/nIz8/P+60rMg7mXY88k9sWgzFRRHP9z//fM4f3ovzuuQ1PTlnVthr8vPz2cwOKEg+jO055/Rm+MCusHY1Xbt2haMNh1ny8/PD32NAt9zcXChvasyuuOIKurfLZavshO1bk9bTq/Ttex75+UMaHGuzbiGUhN83eMJVV9EmpwXLzm6F3X5DnN2iRZPn+8c1cwB/7yye8pjlmw0YBgwYAFs3NzjXtWtX8vPHAHBn4L29OLltfboh5eyKcVfQvX2jzVoilMPGDBhxGcxZEJesnSQ8LGOMud8Y08cY0w/4GvCJMeYbwALgqwGxO4D3ktYyg9F5t/D8cV4BEx5bwN4TZa7kHzqBpu9ISYYrf5t6ww7O+Lnfh39ydQf+MfjnHchDyXDOBuK5F1oM02uXt8Ury/dFTelQ0VkeWX6WUx5aCKRExkqpmLe5kKmvrY14flHBMf7fy6uTV8phbAn5a4zxAb7A713AZXak2xyotjG0rWIfDVvrTd/Rs5/uZPupWv657iDfHt8/7nSbY+hZL2DFyybclorLd5/kX0acgzHGctAyt9B47i7zJ5uiGaYb8X5sbvqLR3NRDZ7TIRt7CPuobXi2wSTCJm8h/R/MWEvPDrlsPRJ+zsCLaPgBlyk4mj6FRaknaIys2h+DYf6WQh79MHMnU8F7MXrsWEty9HQFe4+7MweUCGrcXUZbftGx8nj2nzzjmB6NCQ6vWO1ZHCku5zsvNe32K36cqhS8VtmkAjXuLtNcbbsT39rVjy1I2Udc13KP8AIjGf2bn1zskEbpTbi5CC9+G+lUSahxdxltuUfna9OXAdBv2iwefG9jVFmn5qbDvaOsumEZfYHpS2a/OzXurpPZBcxOXloaO26MnQ2raGkFx3AjVSiZHC/o4x9N4KMfTrB8nZvPxK6c0+m9qnF3mcatworqmmYZntTLhLPfdZtLWByWyQQG9WjH4J7tGNu/Mw/dMsxtdeIjjYyyXahx9xiDH5jDFR7Yf1Gptwcrdp8Mcy4woRqh55W5pr2e1783jm+N62dLWk7b3vDJW880naoINe4uE84IeGHndKWe0oqmm4LEmlBNJyOQyQTfT/jKw3oVnE6Vthp3l8nk7ns0nBq7tDNZq6EPQknnt/r0Ny5xWwWg+X4bdqHGXfE8M9cfciXfn777ecRzdd4yGWiAbryoF4N7tHNbDVuwuw2RTj0yNe4uk3mmwX62HD7ttgpNCPpl/+7j7S5r4gyvTbk8qesTjaFjt/GsG5ZJK7NsD2rcXaa5xg2z8qlZaRyn6iMObRHuO5G6lbGpIqel+6bBzk8j7DZ7iWSQRnWE+29QqSPcxJ1ijVQtKgqdM5jwmDvxut3gq6P7uJr/2qPWtlGMFjgs01Hj7jKhY7bq3x4eKwb7kdmpCci18WBx1PMZOBTvKIkGYrOaftLppFE1ocbdQ2Ti5JwtePCxfLL1qNsqOIoXjJgbn0NFjQcLW4KocfcQmVOslOZOui4IfX1r5uyspZt1uMyiguN1v7XhHp5nF+5yWwXLaEAxbxFvT+RUReT3dvera+xSJyVoy91DNCeDkK4tu+aOU68tfMjf+L+HN1buZ3th8hvfZNCojBp3T5FBBUtJb6xUvvdMGuicInHyk7c3cP3jCyMLhLmfsspqqmoaOjFsOGbNG8fLJGzcReRcEVkgIptFZJOITA0c7ywic0WkIPB/J/vUVZT0IF2H2O4Y19fyNT++bpADmthLuLpq2a6T/MeLK1OuS6pIpuVeDfy3MeZC4HLgbhG5EJgGzDfGDATmB/5W4iBN7UFCeMEbw04KCkt4ZPaWur9PlKXnxFysmD/JlNGTZZFj9QSzDc3dzgoy0n2FznllGglPqBpjDgOHA79LRGQL0Bu4BcgPiL0E+ID7ktKymZCurT0Frms0JFDTXJceRyGZQGzhKK2opvhsFb07tq47dqykgqIzlQxsFBunrBkuELTFW0ZE+gGjgOVAj4DhBzgC9IhwzRRgCkCrngPsUCPtWbJ0Sd1vn89HaWkpPp8v7uutyDuZdjzyRcVn404rFCs6KNY5cOAAPt8xKiPMLBYeOYLPdypmOnv27sXnOxxTLsinn35Kiyxh3776Hk9tbW3U9339/33MoTLDi5Pb1B279OF5ANx3aS5Du2RTa2oB4cGZmyKmk6llKmnjLiJtgbeBHxpjTod2f4wxRkTClhJjzHRgOkBOr4HazAEuv3wc+PwbdeTn5+Pz+cjPz4/7eivyTqYdj/xTW5fAqdhGojH5+fkwZ5bl65T46NOnD/n5wyivqoG5c5qc79mzJ/n5I5pe2Oid9Ovbl/z8wVFlQrn66qtpmZ3FivKtsGsnAO1at2pahkLSOFTmNxvhykSHPgPJH3sesmA2sQaTNtT0BjIvAFxS3jIi0hK/YX/FGPNO4HChiPQKnO8FZPZSPhsJLYKfZfBYIGTemLuSHI1LQ+c2rXjr++MSTq/WwhjnH+ZmnmGH5LxlBHge2GKM+UPIqZnAHYHfdwDvJa5e8yI0/MDtzy9nd3HmuGUpzYtkq+7vXNmf87u1Tfj64LfUnOexkhmWGQ98E/hcRNYFjv0UeBR4Q0S+A+wF/i0pDZsxZVXOlsy7XlpFqxbCX74x2tF8FMVJ+k1rOtzz8/c20a1djgvaeIdkvGU+I3IFPSnRdN3k3f+8grcXrOLlLe64sTVuZQhC8Zkq/rZkNzW1hhuG9WR47w6A3xvjqQU76N+1Df8y4pwI6Rl+MXMT1w/ryfgBXZucn7elMKZOldW1PD5vOzmnq+tcoOxgxZ6mm07Hw/f+scpGLZTGxFq85NTKYie2XXx8boHtaaYTGbtCdXjv9pavGXVeJyae651wOyLw039+zhPzCvjzJzv44p8/A6CqppZXV+zjD3O384MZazlbGX74Zs2+Il5aupdv/HV5wjo8t2gXT/t28sQa+9zY9p4oS/jajzbFrpCU5Ilka1M1zGFHhNSa5jwmQ4YFDvvVrcP5+T83AvDBD64K213zMk1b7lB8pqrBsXD39I9le5gy4YImx19etjdsPrM2HObuOfEZ2NdW7gub9/oHr6dD65ZN5F9cvJtfvL+Z3Gy49cQGXlu5nz2P3lR33rftKHf+LXNXBaY75VXuzvPY2YDfcbTUvsTSkIwy7o05t3Nr9p+Mz5/62W+6P+7ceEcf3/4qctvHLu2PzN7Kyj2nODeriquN4clPdvD1sefx7tqDdTJ/XbSLu646H4BnF+5scP0T87bzg2sGkp0lTF+4E9+2Y+S1yua6C3tEfH7//cY6pk4axJYjp+nZPpeqmlr2nTzDL9/fDEB5Dby2cj8Ai3ccZ2z/zvz5kx0UHE0+uJPiHLat2NTIcK6Tkca9XY7/tuI17K/cNbZuTNpLZXL5kRq6lcW3OfTczf7hikk7T/D7uduZ9XnDBSS/nrWFb47rS06LbDYcaLiL0BPzCji/W1tuHnFOg52M5m2J7MU6b8vRqOdD+cZfl/PvY87l9VX745JX3OPAqcQWlyWLhz67jCGjxtz7d/GvVLvvxiEAdMprOmwQju4enlU/VmJtrDs4vr71SNMW8saDkSuKe2astaaYRdSwpxeR1iF4qfGjRMczxv2blzeNRvfW98ex8N6Jcadx5cCufDj1Kr4x9jwAhvaKPqk6pm8nPvrhhCZxKDKVrzy9JOo8RKSJWUWxTDOfzPQCnhmWaZPTgunfHM3BorMI0Ktja8b062w5nVCDHquV8e+Xnsvgng0NuwDfu/p8nv00/Xb/SZah/9t0ubmiWGX8OS24a8L5bqvR7PGMcT+nYy7XD+tpa5ots6N3THJaZjc5JiLcf+PQuIz74E5ZbDtVG1NOUTKda4f2qFs38d2Lc2ifG9+QaBAd7rEfzxj30LCdjQm2pKdMOJ/pFvbTbGexgMXi/f+6knM7t6Z1q2yOnq5gx/rl9Bo6mj6d8miZLSzfdZLu7XOY/MQiAN78/jgE+OozS23VQ1HC8db3xzle1nLDNIgAnr79Egb+7ENH81as4Qnj3jFHmDi4e8TzeS39aua0sDZF8NDNw3h//aGkdAvloj4d6n6f2zmPnSIM6Vk/DDRhUDcAXvqPy6iqruXSwLDS/33lYn7y9gbb9FCUcHSM04EgHsK1pK8d2p17bxjc9ASxe8lK6vHEG+mYI2RlRe6XTRjkd1O8elA3br/8vLjT7dSmFaO6N21ptMz253VR7w5NzgX5wkWJDxFdPagb115YH8a+e3vveuMomUPXts6Wsx9dNyhqb/i2y85NOO1g+IFgI+/Kgd0STkvx44mWeyxGndepbpXjmH6deXnZvhhX1DP1klzuDFmNGbpaMhrBYFpvrtrPvW8l1+pul5sWj1lJET3a59i+KxFA2xx3y9lvvnwxv/nyxUltfjGmX+e4v1ElOp5ouVvlvktzAXh9yuV8aVRvAP727Usjyj9z+yWM7tuJ16dcbjmvr1zSh4t6d2BawHc+EUb37cy1Q3vwmytbs+gnExk/oEvUXkM8DLbgvjmwe+KhU53mukAP56qB9YHN/jP/Ar54cS+G9Gx6jz/9whCu7N2CS/uF33e9VcjwwH+M78+wc/zDZiMCQ2p3XtGvzlW2MV1ypYEe0Qj27L57Vf+45EP55L/zLV+j2MeSade4rUJKSMsm5dAu2XW1+9jzu/D4v4+MKj95eC8mD++VUF5ZWcL7P7gyoWtD+esdY/D5fJzbOY9X7oqvksnknZiayo6NeP6Jedt5Yl4B90wayJQJFzCodj/5+VdY1KXhO3z4SxdZ1iO8/IX87KYLLcjnx52+m2Sy88o5UZw3Mom0bLkripJ6dF1SeqHGXUkf1LpExc6Y6OGedDr5ol87tEdsoRD+fNsozu1c36J/8F/8vbHWEVw/5/14gmWdOuUk9gATCV8OatwVRQmD1+vRUed1jHr+5pHhN7CJxL+MOIfakPWId4zrx/gBXfjL7ZeElR/QvR1/viav7u/1D14fVu73/1q/mfj5HSOb2zvGNQ2/EuTGRIeUE7pKUVJIcPJ4cM/EWjCKdaJ4JnuCsf27NDkW6i2UyGYf+YP97pej+3YiK0t45a7Lo66/adcq5CEZ+NkXhjaRCd0w5IIOkc3tv46J7EaaqEOEGnfF89x4US8++uEEbro4sRZMOnPryHO494bBDTZGuay/9ZhLVmmRnRUz8J6b3HvDYOb9eAIP3TIM8K9wD3V8CGfbV/xsEmt+fh0Aqx+4llfvGsuKn05ibeDYQ7cMZ+olOcz4bkOHh3HnN61IGlNrDHeF8Zyqqa1XZHL/+BeZ9WxTX3EkGpZFjbuSFjQO8NZcEBHunjiAob3q7/+yCAH17NiaLpSgG2l9+rYmnxTZWcKA7u247bLz+PrY83jnP6+gX5f6YZLaMMp2b5dL5zatAOjSNocrBnSle/tcOgWOZWcJo7q3oFWjlfC9OubG1McQfs6juqZ+rCcryqRFY3XH9EjekdEx4y4ik0Vkm4jsEJFpTuWjKOlIcDVprN5I0O/++gvrW2+RWu7JTKiGC7nd2Oc/2ZXWQcOaDN1aN7zHltlZPPKli+jRPrfB/Q/u2a5u055kmRBYLRtckxFusjbSxOuF5zRcz3JJmLmCIT3b0aNDw2dbG6MiDYY6iYYjfu4ikg08BVwHHABWishMY8xmJ/JTlHRj6f3XcKykgnM6tub+G89QU2s4p2Nr9p44w3md89heWMLm9av58iV9APj2+H5MGtqd7CyhT6c81j94Pev2F1FdU0vHvJbs27Iu0Jpty46jpUz/5mj6dW1DdpZQUl5Niywhp0UWxWerOF5awfJ1Gxk2dChlFdWMu6ALg3q04+tjz2swvnvLyN6M7tuJojNVbFq3mu7tYrdgo9GhdUtOllXW/b3t15MpLK5g/er4N3B/5KrWXHllZE+Vrb+aTPHZKnq0z2XN/17H+3N9TLhyPHmtwhvfeLh1VG8mDu5Ou9wWHDldTo/29c9h0y9voLyqhtaB9Nc/eD2nz1Zx1f/5t8wc3bfhYrvXpoyjqqaW3328jb8t3hNYu3E+bXNasOqBaxnz63lAU+M+7vwuLN11ou7vl759KftOnqHfbyPr7dQipsuAHcaYXQAi8hpwC6DGXVHwtziDi2n6dKofThgQMK7De3fgeEF9x1pE6BvYaQz8hvLqkNZbyW6/bHCF7jkdWzMoyirm3OPbyB/dp8GxcGPsfTrl0acTDXRJlMb9ipwW2ZzXJY9dreLvcbTMkjpDGo7cltl1kStbZmfROTfLlpg7HQJB2RovgGqT04I2IT2EDq1bht04PkirFln+f4H31Lpldt1EcKieppEzak2jcZvG5SEcYvc4XSDjrwKTjTF3Bf7+JjDWGPNfITJTgCkA3bp1G/3GG2/EnX5paSlt28Y3g2xF1ktpOy2vunhXj0Tkg7K+/VW8uKmSJ6/Jo20Uo+nG+5y3t4qXt1Qypkc2qwpreHFyG9vSdkM+muwvl5yluNLwh/w8pi44Q9dc4UcX1dTJF5yq4eHl5fxiXC79OtRXVnfOKePqPi0Y1amKJz4XuuQKv8/PY/HBKp773N/r6ZgjPDHR3yCYOHHiamPMmLBKGGNs/wd8FfhryN/fBJ6MJD9o0CBjhQULFjgi66W0nZZXXbyrRyLyzUUXvc+GAKtMBLvq1ITqQSDUcbNP4JiiKIqSApwy7iuBgSLSX0RaAV8DZjqUl6IoitIIRyZUjTHVIvJfwEdANvCCMWaTE3kpiqIoTXEs5K8xZjYw26n0FUVRlMjoClVFUZQMRI27oihKBqLGXVEUJQNR464oipKBOLJC1bISIiXANguXdACKHZAF6AocdyhtJ3Wxmr7q4l09EpFvLrp46R15wbYMNsaEjzMRaXVTKv8RZZVVBPnpTsha1SWBtB3TxUvPJV118YoeCT7DZqGLl96RF2xLtDTTdVjmfYdkrWI1bSd1sZq+6pK4XKJ4qbykqy5eekdeeSZh8cqwzCoTKfhNilFdwqO6eFcPUF0ikem6REvTKy336W4rEILqEh7VpSle0QNUl0hkui4R0/REy11RFEWxF6+03BVFURQbUeOuKIqSgaTUuItIaSrzi4SI3CoiRkSGuK1LkFjPRkR8IuLoxJCI9BGR90SkQER2isgfAyGbI8n/UETyIp23QR8tLxFwu7xoWQmPl8pKc2253wZ8Fvg/bgIbf2ck4t86/h3gn8aYgcAgoC3wcJTLfgg49sF6CC0vIWhZiYp3yooVJ/xk/wGl+AvBfGAN8DlwS+BcP2AL8BywCfgYaO2ADm3x7wo1CNgWOJYPLARm4V8p+wyQFaLz74H1wJUOP5t84IOQY08CdwZ++4AxDuY/CVjY6Fh74ATQBvgdsBHYAPwAuAeoDLzDBVpemk950bKSHmXFjZZ7OfAlY8wlwETg94GWAMBA4CljzDCgCPiKA/nfAswxxmwHTojI6MDxy/AXxAuBC4AvB463AZYbY0YYYz5zQB+vMAxYHXrAGHMa2Afchf8DGWmMuRh4xRjzJ+AQMNEYM9FBvbS8eA8tK+HxVFlxw7gL8IiIbADmAb2BHoFzu40x6wK/V+MvJHZzG/Ba4Pdr1HefVhhjdhljaoAZwJWB4zXA2w7okU7kA88aY6oBjDEnU5i3lpf0Ih8tK+CBsuLYTkxR+AbQDRhtjKkSkT1AbuBcRYhcDdDazoxFpDNwDXCRiBj8WwAa/F2mxg7/wb/LAy8lFVTTsMLNjSToAJuBr4YeEJH2wHnAnhTq0RgtL5Fxq7xoWWmEF8uKGy33DsDRwMOfCPRNYd5fBf5hjOlrjOlnjDkX2A1cBVwW2NA7C/h3/JMiqWYvcKGI5IhIR/xjm6liPpAnIt+Cugme3wMv4t8L93si0iJwrnPgmhIgfEQ6+9DyEhm3youWlaZ4rqykzLgHXnYF8AowRkQ+B74FbE2VDvi7Se82OvZ24PhK/BNSW/C/lMZyjhF8NsaY/cAb+Cej3gDWpkoH45/h+RLwryJSAGzHP4b5U+Cv+MdTN4jIeuDrgcumA3NEZIHd+mh5iYzb5UXLSlg8V1ZSFn5AREYAzxljLktJhhYQkXzgf4wxX3Qpf88+G7fw8jPR8uItvPw83CwrKWm5i8j38U8kPJCK/NIJfTZN0WcSGX02DdHnERkNHKYoipKBONJyF5FzRWSBiGwWkU0iMjVwvLOIzA0sWZ4rIp0Cx4eIyFIRqRCR/4mVjpJZ2FheckVkhYisD6TzS7fuSXEGu8pKSHrZIrJWRD5I9b04jSMtdxHpBfQyxqwRkXb4/UpvBe4EThpjHhWRaUAnY8x9ItId/8z2rcApY8zvoqVjjNlsu9KKa9hYXgRoY4wpFZGW+L0SphpjlqX8phRHsKushKT3Y2AM0N6tORSncKTlbow5bIxZE/hdgn+WuDf+FVwvBcRewv/AMcYcNcasBKriTEfJIGwsL8YYEwwg1TLwT8cdMwi7ygr4g58BN+H38Mk4HJ9QFZF+wChgOdDDGHM4cOoI9avHrKajZCjJlpdAN3sdcBSYa4zR8pKh2GBbngB+AtQ6oZ/bOGrcRaQtfl/PHwZiT9QR8JWNq1UVLR0lc7CjvBhjaowxI4E++BePDHdCV8Vdki0rIvJF/AueVkeTS2ccM+6BMc+38QcOeidwuDAwZhYcOzuaYDpKhmFXeQlijCkCFgCTbVZVcRmbysp44Gbxhyh4DbhGRF52SGVXcMpbRoDngS3GmD+EnJoJ3BH4fQfwXoLpKBmEjeWlm/iX4SMirYHrSO0qRcVh7Corxpj7jTF9jDH9gK8BnxhjbndAZddwylvmSmAR/pjKwfGsn+IfG3sDf4ChvcC/GWNOikhPYBX+mNC1+OMcXwhcHC4dY8xs25VWXMPG8tIP/2RaNv6GyxvGmIdSdyeK09hVVkKHctxecewUuohJURQlA2mu2+wpiqJkNGrcFUVRMhA17oqiKBmIGndFUZQMRI27oihKBqLGXVEUJQNR464oipKBqHFXFEXJQP4/S6ksQhlOBBIAAAAASUVORK5CYII=\n", + "application/vnd.jupyter.widget-view+json": { + "model_id": "6aee6464577d40d595c11ea80b66b69e", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "Training: 0it [00:00, ?it/s]" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0, global step 99: train_loss reached 6.64344 (best 6.64344), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=0-step=99.ckpt\" as top 1\n", + "Epoch 1, global step 199: train_loss reached 5.94193 (best 5.94193), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=1-step=199.ckpt\" as top 1\n", + "Epoch 2, global step 299: train_loss reached 5.73109 (best 5.73109), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=2-step=299.ckpt\" as top 1\n", + "Epoch 3, global step 399: train_loss reached 5.61180 (best 5.61180), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=3-step=399.ckpt\" as top 1\n", + "Epoch 4, global step 499: train_loss reached 5.52999 (best 5.52999), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=4-step=499.ckpt\" as top 1\n", + "Epoch 5, global step 599: train_loss reached 5.49227 (best 5.49227), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=5-step=599.ckpt\" as top 1\n", + "Epoch 6, global step 699: train_loss reached 5.44622 (best 5.44622), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=6-step=699.ckpt\" as top 1\n", + "Epoch 7, global step 799: train_loss reached 5.39689 (best 5.39689), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=7-step=799.ckpt\" as top 1\n", + "Epoch 8, global step 899: train_loss reached 5.36580 (best 5.36580), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=8-step=899.ckpt\" as top 1\n", + "Epoch 9, global step 999: train_loss reached 5.34275 (best 5.34275), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=9-step=999.ckpt\" as top 1\n", + "Epoch 10, global step 1099: train_loss reached 5.30170 (best 5.30170), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=10-step=1099.ckpt\" as top 1\n", + "Epoch 11, global step 1199: train_loss was not in top 1\n", + "Epoch 12, global step 1299: train_loss reached 5.28796 (best 5.28796), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=12-step=1299.ckpt\" as top 1\n", + "Epoch 13, global step 1399: train_loss was not in top 1\n", + "Epoch 14, global step 1499: train_loss reached 5.24089 (best 5.24089), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=14-step=1499.ckpt\" as top 1\n", + "Epoch 15, global step 1599: train_loss reached 5.23170 (best 5.23170), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=15-step=1599.ckpt\" as top 1\n", + "Epoch 16, global step 1699: train_loss was not in top 1\n", + "Epoch 17, global step 1799: train_loss was not in top 1\n", + "Epoch 18, global step 1899: train_loss reached 5.22364 (best 5.22364), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=18-step=1899.ckpt\" as top 1\n", + "Epoch 19, global step 1999: train_loss reached 5.19707 (best 5.19707), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=19-step=1999.ckpt\" as top 1\n", + "Epoch 20, global step 2099: train_loss was not in top 1\n", + "Epoch 21, global step 2199: train_loss was not in top 1\n", + "Epoch 22, global step 2299: train_loss reached 5.19473 (best 5.19473), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=22-step=2299.ckpt\" as top 1\n", + "Epoch 23, global step 2399: train_loss reached 5.16252 (best 5.16252), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=23-step=2399.ckpt\" as top 1\n", + "Epoch 24, global step 2499: train_loss was not in top 1\n", + "Epoch 25, global step 2599: train_loss reached 5.14338 (best 5.14338), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=25-step=2599.ckpt\" as top 1\n", + "Epoch 26, global step 2699: train_loss was not in top 1\n", + "Epoch 27, global step 2799: train_loss was not in top 1\n", + "Epoch 28, global step 2899: train_loss was not in top 1\n", + "Epoch 29, global step 2999: train_loss reached 5.11718 (best 5.11718), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=29-step=2999.ckpt\" as top 1\n", + "Epoch 30, global step 3099: train_loss was not in top 1\n", + "Epoch 31, global step 3199: train_loss was not in top 1\n", + "Epoch 32, global step 3299: train_loss was not in top 1\n", + "Epoch 33, global step 3399: train_loss was not in top 1\n", + "Epoch 34, global step 3499: train_loss was not in top 1\n", + "Epoch 35, global step 3599: train_loss was not in top 1\n", + "Epoch 36, global step 3699: train_loss reached 5.08207 (best 5.08207), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=36-step=3699.ckpt\" as top 1\n", + "Epoch 37, global step 3799: train_loss was not in top 1\n", + "Epoch 38, global step 3899: train_loss was not in top 1\n", + "Epoch 39, global step 3999: train_loss was not in top 1\n", + "Epoch 40, global step 4099: train_loss was not in top 1\n", + "Epoch 41, global step 4199: train_loss reached 5.06769 (best 5.06769), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=41-step=4199.ckpt\" as top 1\n", + "Epoch 42, global step 4299: train_loss was not in top 1\n", + "Epoch 43, global step 4399: train_loss was not in top 1\n", + "Epoch 44, global step 4499: train_loss reached 5.04426 (best 5.04426), saving model to \"/mnt/scratch/kashif/pytorch-transformer-ts/hopfield/lightning_logs/version_0/checkpoints/epoch=44-step=4499.ckpt\" as top 1\n", + "Epoch 45, global step 4599: train_loss was not in top 1\n", + "Epoch 46, global step 4699: train_loss was not in top 1\n", + "Epoch 47, global step 4799: train_loss was not in top 1\n", + "Epoch 48, global step 4899: train_loss was not in top 1\n", + "Epoch 49, global step 4999: train_loss was not in top 1\n" + ] } ], "source": [ - "entry = next(iter(dataset.train))\n", - "train_series = to_pandas(entry)\n", - "train_series.plot()\n", - "plt.grid(which=\"both\")\n", - "plt.legend([\"train series\"], loc=\"upper left\")\n", - "plt.title(entry['item_id'])\n", - "plt.show()" + "predictor = estimator.train(\n", + " training_data=dataset.train,\n", + " num_workers=8,\n", + " shuffle_buffer_length=1024\n", + ")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/dataset/util.py:128: FutureWarning: Timestamp.freqstr is deprecated and will be removed in a future version.\n", - " freq = start.freqstr\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "entry = next(iter(dataset.test))\n", - "test_series = to_pandas(entry)\n", - "test_series.plot()\n", - "plt.axvline(train_series.index[-1], color='r') # end of train dataset\n", - "plt.grid(which=\"both\")\n", - "plt.legend([\"test series\", \"end of train series\"], loc=\"upper left\")\n", - "plt.title(entry['item_id'])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Recommended prediction horizon: 24\n", - "Frequency of the time series: 1H\n" - ] - } - ], - "source": [ - "print(f\"Recommended prediction horizon: {dataset.metadata.prediction_length}\")\n", - "print(f\"Frequency of the time series: {dataset.metadata.freq}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "estimator = HopfieldEstimator(\n", - " #distr_output=ZeroInflatedNegativeBinomialOutput(),\n", - " num_heads=3,\n", - " act_type='relu',\n", - " input_size=30,\n", - " dropout_rate=0.1,\n", - " #use_feat_dynamic_real=True,\n", - " #use_feat_static_cat=True,\n", - " #cardinality=[int(cat_feat_info.cardinality) for cat_feat_info in dataset.metadata.feat_static_cat],\n", - " #embedding_dimension = [4, 4, 4, 4, 16],\n", - " prediction_length=dataset.metadata.prediction_length,\n", - " context_length=dataset.metadata.prediction_length*14,\n", - " freq=dataset.metadata.freq,\n", - " scaling=True,\n", - " trainer=Trainer(device=device,\n", - " epochs=50,\n", - " learning_rate=1e-3,\n", - " num_batches_per_epoch=100,\n", - " batch_size=128,)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7f416706e71a40d595e5e55caeb32671", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4e4c94fe9cf544f2972c9a27d17c3663", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "969d69a3e8c14f9fa1f0dbf3a46ff78a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "45de96c010d74c6da67abb4546ff625d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "615a4d7787154de0b76cb27bb3f05924", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c38c16ba11c742309ca0963bfd34451b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b75709a3e8cd4a02a1784aa58f906956", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6d948d753873433084690553d52428a9", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b774d93f9f4d4093a7cd4106a71b082c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "03263f6b78784dfb83837c735a2c6de7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "assert self._parent_pid == os.getpid(), 'can only test a child process' \n", - "assert self._parent_pid == os.getpid(), 'can only test a child process'AssertionError: \n", - "can only test a child processAssertionError\n", - ": can only test a child process\n", - "Exception ignored in: Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "\n", - " Traceback (most recent call last):\n", - "self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " self._shutdown_workers()if w.is_alive():\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: : can only test a child processcan only test a child process\n", - "\n", - "Exception ignored in: Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " \n", - "self._shutdown_workers()Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "self._shutdown_workers() \n", - "if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - ": can only test a child processassert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.8/multiprocessing/queues.py\", line 245, in _feed\n", - " send_bytes(obj)\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 200, in send_bytes\n", - " self._send_bytes(m[offset:offset + size])\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 411, in _send_bytes\n", - " self._send(header + buf)\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 368, in _send\n", - " n = write(self._handle, buf)\n", - "self._shutdown_workers()BrokenPipeError: [Errno 32] Broken pipe\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Traceback (most recent call last):\n", - "Exception ignored in: File \"/usr/lib/python3.8/multiprocessing/queues.py\", line 245, in _feed\n", - " send_bytes(obj)\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 200, in send_bytes\n", - " self._send_bytes(m[offset:offset + size])\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 411, in _send_bytes\n", - " self._send(header + buf)\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 368, in _send\n", - " n = write(self._handle, buf)\n", - " BrokenPipeError: [Errno 32] Broken pipe\n", - "self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4c6716b1c7584f268558ca69917787ee", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "32ad511e31f545e3a6f5c899d9a1debd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "15d60049f5714ed4bdde98239f19805e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - "if w.is_alive():\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'if w.is_alive():\n", - "\n", - "AssertionError: File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " can only test a child processassert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4d5b70dfbd1d420d94fa52c9327d6b57", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "be1af13111aa4c0789ee968446c6bb30", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cee7898ba2fd470a876e1dab8df68b65", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: Exception ignored in: can only test a child process\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Exception ignored in: self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "Traceback (most recent call last):\n", - "AssertionError File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " : can only test a child process\n", - "self._shutdown_workers()\n", - "Exception ignored in: File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "assert self._parent_pid == os.getpid(), 'can only test a child process' \n", - "self._shutdown_workers()AssertionError\n", - ": File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "can only test a child process \n", - "if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "600c26382f32443ba05a02043a669bbb", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "104d8ec670bd4a0fb402792986e4e59a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f1af072ef5214e5987ec19b33fa54d14", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionErrorException ignored in: : can only test a child process\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Exception ignored in: self._shutdown_workers()\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " if w.is_alive(): \n", - "self._shutdown_workers() File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "AssertionError : assert self._parent_pid == os.getpid(), 'can only test a child process'can only test a child process\n", - "AssertionError\n", - ": can only test a child process\n", - "Exception ignored in: Exception ignored in: \n", - "\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " if w.is_alive():self._shutdown_workers()\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process' if w.is_alive():\n", - "\n", - "AssertionError File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - ": can only test a child processassert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "85ec88b3c696492bb398b2b51086aa40", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c1dfcfd6b24c4c30ace46aff3e7a4b4a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fadc804651ab4375bee1ba048f643018", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child processException ignored in: \n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " \n", - "self._shutdown_workers()Traceback (most recent call last):\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " if w.is_alive():self._shutdown_workers()\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process' File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " AssertionError: can only test a child process\n", - "if w.is_alive():Exception ignored in: \n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " Traceback (most recent call last):\n", - "assert self._parent_pid == os.getpid(), 'can only test a child process' File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "\n", - "AssertionError: can only test a child process\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b5297f9a61ff4ef48e7988c9f6d22c4e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b36d0fb12f384dd097fe4464a540741f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8b799c2c4a0642d0a71779291c976d21", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - "Exception ignored in: File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()if w.is_alive():\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process' \n", - "if w.is_alive():AssertionError\n", - ": File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "can only test a child process \n", - "assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionErrorException ignored in: : \n", - "can only test a child process\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Exception ignored in: self._shutdown_workers()\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " if w.is_alive(): self._shutdown_workers()\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process' \n", - "if w.is_alive():AssertionError\n", - ": can only test a child process\n", - "Exception ignored in: File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " \n", - "Traceback (most recent call last):\n", - "assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "self._shutdown_workers()Traceback (most recent call last):\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers() File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "AssertionError : assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child processcan only test a child process\n", - "\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "491caad585114c1bb2fa9a7f2a799b26", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8f014ca42c3c4a8b800adfc5be476eab", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a2a2908ff97c40539d0c507760e2abe8", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child processException ignored in: \n", - "Exception ignored in: \n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()self._shutdown_workers()\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " AssertionErrorassert self._parent_pid == os.getpid(), 'can only test a child process': \n", - "AssertionError: can only test a child processcan only test a child process\n", - "\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ebf98dae1b1c4ee0ab052e4e61bc13e5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9451beb1b499474d8cac5434ef4ad92d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7f7072c6007248d3bb10382cdfa720a7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Exception ignored in: \n", - "self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()if w.is_alive():\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " if w.is_alive(): assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "AssertionError : assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "can only test a child processAssertionError\n", - ": can only test a child process\n", - "Exception ignored in: Exception ignored in: \n", - "Traceback (most recent call last):\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "self._shutdown_workers() \n", - "if w.is_alive(): File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'if w.is_alive():\n", - "AssertionError: can only test a child process\n", - "\n", - "Exception ignored in: File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionErrorTraceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - ": self._shutdown_workers()\n", - "can only test a child process File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "if w.is_alive():\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError: can only test a child process File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e411dedfb52c4c419ff73f3d1f82a1e1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "Exception ignored in: self._shutdown_workers()\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " if w.is_alive(): \n", - "self._shutdown_workers() File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "AssertionError assert self._parent_pid == os.getpid(), 'can only test a child process': \n", - "AssertionError: can only test a child processcan only test a child process\n", - "\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "37fba90dbe154b6c8e0ad03d58c317e3", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7005474141674248a0c9306480266c3a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()Exception ignored in: \n", - "\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "self._shutdown_workers() assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "AssertionError File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - ": can only test a child process\n", - "Exception ignored in: if w.is_alive():\n", - "\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'self._shutdown_workers()\n", - "\n", - "AssertionError File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " : if w.is_alive():can only test a child process\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: Exception ignored in: can only test a child process\n", - "\n", - "Traceback (most recent call last):\n", - "Exception ignored in: File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - "\n", - " Traceback (most recent call last):\n", - "self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive(): \n", - "self._shutdown_workers()\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process' \n", - "AssertionError: can only test a child processif w.is_alive():\n", - "\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - "Exception ignored in: assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "\n", - "Traceback (most recent call last):\n", - "AssertionError File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers(): can only test a child process\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - "\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d53bf26b160b4cfd97621bd71684f00c", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "1ca2083f1361486ba44150d5c0285181", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "263ed55fbc6242448434e9d31b5758de", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "Exception ignored in: \n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1320, in _shutdown_workers\n", - " if w.is_alive():\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 160, in is_alive\n", - " assert self._parent_pid == os.getpid(), 'can only test a child process'\n", - "AssertionError: can only test a child process\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/feature.py:352: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " self._min_time_point, self._max_time_point, freq=start.freq\n", - "/mnt/scratch/kashif/gluon-ts/src/gluonts/transform/split.py:36: FutureWarning: Timestamp.freq is deprecated and will be removed in a future version\n", - " return _shift_timestamp_helper(ts, ts.freq, offset)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c3bd2604901a4bc9bea065e90c1320ed", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/99 [00:00\n", - "Traceback (most recent call last):\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1328, in __del__\n", - " self._shutdown_workers()\n", - " File \"/home/kashif/.env/pytorch/lib/python3.8/site-packages/torch/utils/data/dataloader.py\", line 1301, in _shutdown_workers\n", - " w.join(timeout=_utils.MP_STATUS_CHECK_INTERVAL)\n", - " File \"/usr/lib/python3.8/multiprocessing/process.py\", line 149, in join\n", - " res = self._popen.wait(timeout)\n", - " File \"/usr/lib/python3.8/multiprocessing/popen_fork.py\", line 44, in wait\n", - " if not wait([self.sentinel], timeout):\n", - " File \"/usr/lib/python3.8/multiprocessing/connection.py\", line 931, in wait\n", - " ready = selector.select(timeout)\n", - " File \"/usr/lib/python3.8/selectors.py\", line 415, in select\n", - " fd_event_list = self._selector.poll(timeout)\n", - "KeyboardInterrupt: \n" - ] - } - ], - "source": [ - "tss = list(tqdm(ts_it, total=len(dataset.test)))" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9b5e81b6d5644ce8a4cd0c40c5fcbe85", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/2247 [00:00" ] @@ -4117,19 +484,19 @@ } ], "source": [ - "item_metrics.plot(x='MSIS', y='MASE', kind='scatter')\n", + "ts_metrics.plot(x='MSIS', y='MASE', kind='scatter')\n", "plt.grid(which=\"both\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -4145,13 +512,11 @@ "date_formater = mdates.DateFormatter('%b, %d')\n", "plt.rcParams.update({'font.size': 15})\n", "\n", - "prediction_length = dataset.metadata.prediction_length\n", - "\n", "for idx, (forecast, ts) in islice(enumerate(zip(forecasts, tss)), 9):\n", " ax = plt.subplot(3, 3, idx+1)\n", "\n", - " plt.plot(ts[-5 * prediction_length:], label=\"target\")\n", - " forecast.plot()\n", + " plt.plot(ts[-4 * dataset.metadata.prediction_length:], label=\"target\", )\n", + " forecast.plot( color='g')\n", " plt.xticks(rotation=60)\n", " ax.xaxis.set_major_formatter(date_formater)\n", "\n",