FEAT: Training window filtering

nbs/common.base_model.ipynb

@@ -154,6 +154,7 @@
     "        windows_batch_size: int,\n",
     "        inference_windows_batch_size: Union[int, None],\n",
     "        start_padding_enabled: bool,\n",
+    "        training_data_availability_threshold: Union[float, List[float]] = 0.0,\n",
     "        n_series: Union[int, None] = None,\n",
     "        n_samples: Union[int, None] = 100,\n",
     "        h_train: int = 1,\n",
@@ -358,6 +359,28 @@
     "        else:\n",
     "            self.inference_windows_batch_size = inference_windows_batch_size\n",
     "\n",
+    "        # Filtering training windows by available sample fractions\n",
+    "        if isinstance(training_data_availability_threshold, int):\n",
+    "            raise ValueError(\"training_data_availability_threshold cannot be an integer - must be a float\")\n",
+    "        elif isinstance(training_data_availability_threshold, float):\n",
+    "            if training_data_availability_threshold < 0.0 or training_data_availability_threshold > 1.0:\n",
+    "                raise ValueError(f\"training_data_availability_threshold must be between 0.0 and 1.0, got {training_data_availability_threshold}\")\n",
+    "            self.min_insample_fraction = training_data_availability_threshold\n",
+    "            self.min_outsample_fraction = training_data_availability_threshold\n",
+    "        elif isinstance(training_data_availability_threshold, (list, tuple)) and len(training_data_availability_threshold) == 2:\n",
+    "            for i, value in enumerate(training_data_availability_threshold):\n",
+    "                if isinstance(value, int):\n",
+    "                    raise ValueError(f\"training_data_availability_threshold[{i}] cannot be an integer - must be a float\")\n",
+    "                if not isinstance(value, float):\n",
+    "                    raise ValueError(f\"training_data_availability_threshold[{i}] must be a float\")\n",
+    "                if value < 0.0 or value > 1.0:\n",
+    "                    raise ValueError(f\"training_data_availability_threshold[{i}] must be between 0.0 and 1.0, got {value}\")\n",
+    "            \n",
+    "            self.min_insample_fraction = training_data_availability_threshold[0]\n",
+    "            self.min_outsample_fraction = training_data_availability_threshold[1]\n",
+    "        else:\n",
+    "            raise ValueError(\"training_data_availability_threshold must be a float or a list/tuple of two floats\")\n",
+    "\n",
     "        # Optimization \n",
     "        self.learning_rate = learning_rate\n",
     "        self.max_steps = max_steps\n",
@@ -674,16 +697,20 @@
     "                windows = windows.flatten(0, 1)\n",
     "                windows = windows.unsqueeze(-1)\n",
     "\n",
-    "            # Sample and Available conditions\n",
-    "            available_idx = temporal_cols.get_loc('available_mask')           \n",
-    "            available_condition = windows[:, :self.input_size, available_idx]\n",
-    "            available_condition = torch.sum(available_condition, axis=(1, -1)) # Sum over time & series dimension\n",
-    "            final_condition = (available_condition > 0)\n",
-    "            \n",
+    "            # Calculate minimum required available points based on fractions\n",
+    "            min_insample_points = max(1, int(self.input_size * self.min_insample_fraction * self.n_series))\n",
+    "            min_outsample_points = max(1, int(self.h * self.min_outsample_fraction * self.n_series))\n",
+    "\n",
+    "            # Sample based on available conditions\n",
+    "            available_idx = temporal_cols.get_loc(\"available_mask\")\n",
+    "            insample_condition = windows[:, : self.input_size, available_idx]\n",
+    "            insample_condition = torch.sum(insample_condition, axis=(1, -1))  # Sum over time & series dimension\n",
+    "            final_condition = insample_condition >= min_insample_points\n",
+    "\n",
     "            if self.h > 0:\n",
-    "                sample_condition = windows[:, self.input_size:, available_idx]\n",
-    "                sample_condition = torch.sum(sample_condition, axis=(1, -1)) # Sum over time & series dimension\n",
-    "                final_condition = (sample_condition > 0) & (available_condition > 0)\n",
+    "                outsample_condition = windows[:, self.input_size :, available_idx]\n",
+    "                outsample_condition = torch.sum(outsample_condition, axis=(1, -1))  # Sum over time & series dimension\n",
+    "                final_condition = (outsample_condition >= min_outsample_points) & (insample_condition >= min_insample_points)\n",
     "            \n",
     "            windows = windows[final_condition]\n",
     "\n",