From b805018576a5204e65730fb6694fcfaee14ddc8e Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Wed, 27 Dec 2023 16:46:48 +0100 Subject: [PATCH 01/18] Wandb saves model checkpoints --- cmd/conf/trainer/default.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/cmd/conf/trainer/default.yaml b/cmd/conf/trainer/default.yaml index 8d4dd38..974c127 100644 --- a/cmd/conf/trainer/default.yaml +++ b/cmd/conf/trainer/default.yaml @@ -5,5 +5,6 @@ gradient_clip_val: 1.0 enable_progress_bar: true logger: _target_: pytorch_lightning.loggers.WandbLogger + log_model: true defaults: - callbacks: default From 639a2879eb3a8eec0c449185e28628ce533ec22c Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Wed, 27 Dec 2023 18:07:17 +0100 Subject: [PATCH 02/18] Add sampling callback --- cmd/conf/trainer/callbacks/default.yaml | 13 ++++ cmd/train.py | 6 ++ src/fdiff/utils/callbacks.py | 86 +++++++++++++++++++++++++ 3 files changed, 105 insertions(+) create mode 100644 src/fdiff/utils/callbacks.py diff --git a/cmd/conf/trainer/callbacks/default.yaml b/cmd/conf/trainer/callbacks/default.yaml index fc9879e..3b9e496 100644 --- a/cmd/conf/trainer/callbacks/default.yaml +++ b/cmd/conf/trainer/callbacks/default.yaml @@ -6,3 +6,16 @@ - _target_: pytorch_lightning.callbacks.EarlyStopping monitor: val/loss patience: 20 +- _target_: fdiff.utils.callbacks.SamplingCallback + every_n_epochs: 1 + sample_batch_size: ${datamodule.batch_size} + num_samples: 200 + num_diffusion_steps: 1000 + metrics: + - _target_: fdiff.sampling.metrics.SlicedWasserstein + _partial_: true + random_seed: ${random_seed} + num_directions: 200 + - _target_: fdiff.sampling.metrics.MarginalWasserstein + _partial_: true + random_seed: ${random_seed} diff --git a/cmd/train.py b/cmd/train.py index cc05267..252a1dc 100644 --- a/cmd/train.py +++ b/cmd/train.py @@ -11,6 +11,7 @@ from fdiff.dataloaders.datamodules import Datamodule from fdiff.models.score_models import ScoreModule +from fdiff.utils.callbacks import SamplingCallback from fdiff.utils.extraction import dict_to_str, get_training_params from fdiff.utils.wandb import maybe_initialize_wandb @@ -50,6 +51,11 @@ def __init__(self, cfg: DictConfig) -> None: training_params = get_training_params(self.datamodule, self.trainer) self.score_model = self.score_model(**training_params) + # Possibly setup the datamodule in the sampling callback + for callback in self.trainer.callbacks: # type: ignore + if isinstance(callback, SamplingCallback): + callback.setup_datamodule(datamodule=self.datamodule) + def train(self) -> None: assert not ( self.score_model.scale_noise and not self.datamodule.fourier_transform diff --git a/src/fdiff/utils/callbacks.py b/src/fdiff/utils/callbacks.py new file mode 100644 index 0000000..6ffadd9 --- /dev/null +++ b/src/fdiff/utils/callbacks.py @@ -0,0 +1,86 @@ +import pytorch_lightning as pl +import torch + +from fdiff.dataloaders.datamodules import Datamodule +from fdiff.models.score_models import ScoreModule +from fdiff.sampling.metrics import Metric, MetricCollection +from fdiff.sampling.sampler import DiffusionSampler + +from .fourier import idft + + +class SamplingCallback(pl.Callback): + def __init__( + self, + every_n_epochs: int, + sample_batch_size: int, + num_samples: int, + num_diffusion_steps: int, + metrics: list[Metric], + ) -> None: + super().__init__() + self.every_n_epochs = every_n_epochs + self.sample_batch_size = sample_batch_size + self.num_samples = num_samples + self.num_diffusion_steps = num_diffusion_steps + self.metrics = metrics + self.datamodule_initialized = False + + def setup_datamodule(self, datamodule: Datamodule) -> None: + # Exract the necessary information from the datamodule + self.standardize = datamodule.standardize + self.fourier_transform = datamodule.fourier_transform + self.feature_mean, self.feature_std = datamodule.feature_mean_and_std + self.metric_collection = MetricCollection( + metrics=self.metrics, + original_samples=datamodule.X_train, + include_baselines=False, + ) + self.datamodule_initialized = True + + def on_train_start(self, trainer: pl.Trainer, pl_module: ScoreModule) -> None: + # Initialize the sampler with the score model + self.sampler = DiffusionSampler( + score_model=pl_module, + sample_batch_size=self.sample_batch_size, + ) + + def on_train_epoch_end( + self, trainer: pl.Trainer, pl_module: pl.LightningModule + ) -> None: + if trainer.current_epoch % self.every_n_epochs == 0: + # Sample from score model + X = self.sample() + + # Compute metrics + results = self.metric_collection(X) + + # Add a metrics/ suffix to the keys in results + results = {f"metrics/{key}": value for key, value in results.items()} + + # Log metrics + pl_module.log_dict(results, on_step=False, on_epoch=True) + + def sample(self) -> torch.Tensor: + # Check that the dqtqmodule is initialized + assert self.datamodule_initialized, ( + "The datamodule has not been initialized. " + "Please call `setup_datamodule` before sampling." + ) + + # Sample from score model + + X = self.sampler.sample( + num_samples=self.num_samples, + num_diffusion_steps=self.num_diffusion_steps, + ) + + # Map to the original scale if the input was standardized + if self.standardize: + X = X * self.feature_std + self.feature_mean + + # If sampling in frequency domain, bring back the sample to time domain + if self.fourier_transform: + X = idft(X) + assert isinstance(X, torch.Tensor) + return X From 00d848bb0ae5b1a4b14d042bde2a972db0a68eea Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Wed, 27 Dec 2023 18:12:07 +0100 Subject: [PATCH 03/18] Change frequency of sampling callback --- cmd/conf/trainer/callbacks/default.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/conf/trainer/callbacks/default.yaml b/cmd/conf/trainer/callbacks/default.yaml index 3b9e496..6629722 100644 --- a/cmd/conf/trainer/callbacks/default.yaml +++ b/cmd/conf/trainer/callbacks/default.yaml @@ -7,7 +7,7 @@ monitor: val/loss patience: 20 - _target_: fdiff.utils.callbacks.SamplingCallback - every_n_epochs: 1 + every_n_epochs: 10 sample_batch_size: ${datamodule.batch_size} num_samples: 200 num_diffusion_steps: 1000 From e8d59cd4999a4d71db6d74fa6c60d858c31d0874 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Thu, 28 Dec 2023 12:15:15 +0100 Subject: [PATCH 04/18] Bugfix SDE val loss, remove early stopping --- cmd/conf/trainer/callbacks/default.yaml | 3 --- src/fdiff/dataloaders/datamodules.py | 2 ++ 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/cmd/conf/trainer/callbacks/default.yaml b/cmd/conf/trainer/callbacks/default.yaml index 6629722..f49da60 100644 --- a/cmd/conf/trainer/callbacks/default.yaml +++ b/cmd/conf/trainer/callbacks/default.yaml @@ -3,9 +3,6 @@ monitor: val/loss filename: "epoch={epoch}-val_loss={val/loss:.2f}" auto_insert_metric_name: false -- _target_: pytorch_lightning.callbacks.EarlyStopping - monitor: val/loss - patience: 20 - _target_: fdiff.utils.callbacks.SamplingCallback every_n_epochs: 10 sample_batch_size: ${datamodule.batch_size} diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index 05af4f4..1725c17 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -40,6 +40,8 @@ def __init__( self.standardize = standardize if X_ref is None: X_ref = X + elif fourier_transform: + X_ref = dft(X_ref).detach() self.feature_mean = X_ref.mean(dim=0) self.feature_std = X_ref.std(dim=0) From 804c4a1413ee3aa53041acdec21fc61f4200b5d2 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Thu, 28 Dec 2023 12:21:18 +0100 Subject: [PATCH 05/18] Small type hinting fix --- src/fdiff/dataloaders/datamodules.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index 1725c17..5609199 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -42,6 +42,7 @@ def __init__( X_ref = X elif fourier_transform: X_ref = dft(X_ref).detach() + assert isinstance(X_ref, torch.Tensor) self.feature_mean = X_ref.mean(dim=0) self.feature_std = X_ref.std(dim=0) From 3a0b001589ea5ca7879311d227852f92b8c8fa3c Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Fri, 29 Dec 2023 11:13:26 +0100 Subject: [PATCH 06/18] Save all the individual Wasserstein distances --- cmd/conf/metrics/default.yaml | 2 ++ src/fdiff/sampling/metrics.py | 36 +++++++++++++++++------------------ src/fdiff/utils/extraction.py | 3 +++ tests/test_metrics.py | 20 ++++++++++++++++++- 4 files changed, 42 insertions(+), 19 deletions(-) diff --git a/cmd/conf/metrics/default.yaml b/cmd/conf/metrics/default.yaml index cbce263..edcfc28 100644 --- a/cmd/conf/metrics/default.yaml +++ b/cmd/conf/metrics/default.yaml @@ -6,6 +6,8 @@ metrics: _partial_: true random_seed: ${random_seed} num_directions: 10000 + save_all_distances: true - _target_: fdiff.sampling.metrics.MarginalWasserstein _partial_: true random_seed: ${random_seed} + save_all_distances: true diff --git a/src/fdiff/sampling/metrics.py b/src/fdiff/sampling/metrics.py index f202eba..c5c40fd 100644 --- a/src/fdiff/sampling/metrics.py +++ b/src/fdiff/sampling/metrics.py @@ -1,10 +1,10 @@ from abc import ABC, abstractmethod, abstractproperty from functools import partial -from pathlib import Path -from typing import Optional +from typing import Any, Optional import numpy as np import torch + from fdiff.utils.fourier import dft from fdiff.utils.tensors import check_flat_array from fdiff.utils.wasserstein import WassersteinDistances @@ -15,7 +15,7 @@ def __init__(self, original_samples: np.ndarray | torch.Tensor) -> None: self.original_samples = check_flat_array(original_samples) @abstractmethod - def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, float]: + def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, Any]: ... @abstractproperty @@ -53,7 +53,7 @@ def __init__( self.metrics_freq = metrics_freq self.include_baselines = include_baselines - def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, float]: + def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, Any]: metric_dict = {} other_samples_freq = dft(other_samples) for metric_time, metric_freq in zip(self.metrics_time, self.metrics_freq): @@ -86,22 +86,27 @@ def __init__( original_samples: np.ndarray | torch.Tensor, random_seed: int, num_directions: int, + save_all_distances: bool = False, ) -> None: super().__init__(original_samples=original_samples) self.random_seed = random_seed self.num_directions = num_directions + self.save_all_distances = save_all_distances - def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, float]: + def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, Any]: wd = WassersteinDistances( original_data=self.original_samples, other_data=check_flat_array(other_samples), seed=self.random_seed, ) distances = wd.sliced_distances(self.num_directions) - return { + metrics = { "sliced_wasserstein_mean": float(np.mean(distances)), "sliced_wasserstein_max": float(np.max(distances)), } + if self.save_all_distances: + metrics["sliced_wasserstein_all"] = distances.tolist() + return metrics @property def baseline_metrics(self) -> dict[str, float]: @@ -141,31 +146,26 @@ def __init__( self, original_samples: np.ndarray | torch.Tensor, random_seed: int, + save_all_distances: bool = False, ) -> None: super().__init__(original_samples=original_samples) self.random_seed = random_seed + self.save_all_distances = save_all_distances - def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, float]: + def __call__(self, other_samples: np.ndarray | torch.Tensor) -> dict[str, Any]: wd = WassersteinDistances( original_data=self.original_samples, other_data=check_flat_array(other_samples), seed=self.random_seed, ) distances = wd.marginal_distances() - return { + metrics = { "marginal_wasserstein_mean": float(np.mean(distances)), "marginal_wasserstein_max": float(np.max(distances)), } - - def save(self, other_samples: np.ndarray | torch.Tensor, path: str | Path) -> None: - # Save the distances array for post-processing - wd = WassersteinDistances( - original_data=self.original_samples, - other_data=check_flat_array(other_samples), - seed=self.random_seed, - ) - distances = wd.marginal_distances() - np.save(path, distances) + if self.save_all_distances: + metrics["marginal_wasserstein_all"] = distances.tolist() + return metrics @property def baseline_metrics(self) -> dict[str, float]: diff --git a/src/fdiff/utils/extraction.py b/src/fdiff/utils/extraction.py index 41005bf..380a42e 100644 --- a/src/fdiff/utils/extraction.py +++ b/src/fdiff/utils/extraction.py @@ -91,5 +91,8 @@ def dict_to_str(dict: DictConfig | dict[str, Any]) -> str: dict_str = "" max_len = max([len(k) for k in dict]) for k, v in dict.items(): + # In case of long lists, just print the first 3 elements + if isinstance(v, list): + v = v[:3] + ["..."] if len(v) > 3 else v dict_str += f"\t {k: <{max_len + 5}} : \t {v} \t \n" return dict_str diff --git a/tests/test_metrics.py b/tests/test_metrics.py index e55c116..4e7771f 100644 --- a/tests/test_metrics.py +++ b/tests/test_metrics.py @@ -10,6 +10,7 @@ max_len = 2 n_samples = 1000 num_directions = 1000 +EPS = 1e-5 test_data_wasserstein = [0.0, 0.1, 1.0] @@ -36,9 +37,17 @@ def test_sliced_waserstein(shift: float) -> None: original_samples=dataset1, random_seed=random_seed, num_directions=num_directions, + save_all_distances=True, ) metrics = sw(dataset2) + assert ( + np.abs( + metrics["sliced_wasserstein_mean"] + - np.mean(metrics["sliced_wasserstein_all"]) + ) + <= EPS + ) assert metrics["sliced_wasserstein_mean"] <= metrics["sliced_wasserstein_max"] assert np.abs(metrics["sliced_wasserstein_mean"] - pot_estimate) <= 0.1 @@ -56,9 +65,18 @@ def test_marginal_waserstein(shift: float) -> None: ground_truth = shift # Compute sliced wasserstein distance - mw = MarginalWasserstein(original_samples=dataset1, random_seed=random_seed) + mw = MarginalWasserstein( + original_samples=dataset1, random_seed=random_seed, save_all_distances=True + ) metrics = mw(dataset2) + assert ( + np.abs( + metrics["marginal_wasserstein_mean"] + - np.mean(metrics["marginal_wasserstein_all"]) + ) + <= EPS + ) assert metrics["marginal_wasserstein_mean"] <= metrics["marginal_wasserstein_max"] assert np.abs(metrics["marginal_wasserstein_mean"] - ground_truth) <= 0.1 assert np.abs(metrics["marginal_wasserstein_max"] - ground_truth) <= 0.1 From 0e5eef1cee44ea4490b3052a885fa7f79d9a7006 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Fri, 29 Dec 2023 11:19:37 +0100 Subject: [PATCH 07/18] Change metrics settings for sampling --- cmd/conf/metrics/default.yaml | 2 +- cmd/conf/sample.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/conf/metrics/default.yaml b/cmd/conf/metrics/default.yaml index edcfc28..d3574b7 100644 --- a/cmd/conf/metrics/default.yaml +++ b/cmd/conf/metrics/default.yaml @@ -5,7 +5,7 @@ metrics: - _target_: fdiff.sampling.metrics.SlicedWasserstein _partial_: true random_seed: ${random_seed} - num_directions: 10000 + num_directions: 1000 save_all_distances: true - _target_: fdiff.sampling.metrics.MarginalWasserstein _partial_: true diff --git a/cmd/conf/sample.yaml b/cmd/conf/sample.yaml index b19f120..69b0d4b 100644 --- a/cmd/conf/sample.yaml +++ b/cmd/conf/sample.yaml @@ -1,6 +1,6 @@ model_path: ${hydra:runtime.cwd}/lightning_logs model_id: ub0lv98f -num_samples: 1000 +num_samples: 10000 num_diffusion_steps: 1000 random_seed: 42 From d09496c8c14f0622e9bcea89056c3e27ffb00d20 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Sun, 31 Dec 2023 17:20:59 +0100 Subject: [PATCH 08/18] Add MIMIC-III datamodule and preprocessing --- cmd/conf/datamodule/mimiciii.yaml | 6 + pyproject.toml | 1 + src/fdiff/dataloaders/datamodules.py | 53 +++++++- src/fdiff/utils/preprocessing.py | 179 +++++++++++++++++++++++++++ 4 files changed, 237 insertions(+), 2 deletions(-) create mode 100644 cmd/conf/datamodule/mimiciii.yaml create mode 100644 src/fdiff/utils/preprocessing.py diff --git a/cmd/conf/datamodule/mimiciii.yaml b/cmd/conf/datamodule/mimiciii.yaml new file mode 100644 index 0000000..405b8ac --- /dev/null +++ b/cmd/conf/datamodule/mimiciii.yaml @@ -0,0 +1,6 @@ +_target_: fdiff.dataloaders.datamodules.MIMICIIIDatamodule +data_dir: ${hydra:runtime.cwd}/data +random_seed: ${random_seed} +fourier_transform: ${fourier_transform} +standardize: ${standardize} +batch_size: 64 diff --git a/pyproject.toml b/pyproject.toml index 79e85b7..e56d289 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -48,6 +48,7 @@ dependencies = [ "hydra-core", "wandb", "POT", + "tables", ] diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index 5609199..10900ec 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -12,6 +12,7 @@ from fdiff.utils.dataclasses import collate_batch from fdiff.utils.fourier import dft +from fdiff.utils.preprocessing import mimic_preprocess class DiffusionDataset(Dataset): @@ -84,10 +85,9 @@ def __init__( def prepare_data(self) -> None: if not self.data_dir.exists(): - logging.info(f"Downloading {self.dataset_name} dataset in {self.data_dir}") + logging.info(f"Downloading {self.dataset_name} dataset in {self.data_dir}.") os.makedirs(self.data_dir) self.download_data() - logging.info(f"Dataset {self.dataset_name} downloaded in {self.data_dir}") @abstractmethod def download_data(self) -> None: @@ -267,3 +267,52 @@ def download_data(self) -> None: @property def dataset_name(self) -> str: return "synthetic" + + +class MIMICIIIDatamodule(Datamodule): + def __init__( + self, + data_dir: Path | str = Path.cwd() / "data", + random_seed: int = 42, + batch_size: int = 32, + fourier_transform: bool = False, + standardize: bool = False, + ) -> None: + super().__init__( + data_dir=data_dir, + random_seed=random_seed, + batch_size=batch_size, + fourier_transform=fourier_transform, + standardize=standardize, + ) + + def setup(self, stage: str = "fit") -> None: + if ( + not (self.data_dir / "X_train.pt").exists() + or not (self.data_dir / "X_test.pt").exists() + ): + logging.info( + f"Preprocessed tensors for {self.dataset_name} not found. " + f"Now running the preprocessing pipeline." + ) + mimic_preprocess(data_dir=self.data_dir, random_seed=self.random_seed) + logging.info( + f"Preprocessing pipeline finished, tensors saved in {self.data_dir}." + ) + + # Load preprocessed tensors + self.X_train = torch.load(self.data_dir / "X_train.pt") + self.X_test = torch.load(self.data_dir / "X_test.pt") + + def download_data(self) -> None: + dataset_path = self.data_dir / "all_hourly_data.h5" + assert dataset_path.exists(), ( + f"Dataset {dataset_path} does not exist. " + "Because MIMIC-III is a restricted dataset, you need to download it yourself. " + "Our implementation relies on the default MIMIC-Extract preprocessed version of the dataset. " + "Please follow the instruction on https://github.com/MLforHealth/MIMIC_Extract/tree/master." + ) + + @property + def dataset_name(self) -> str: + return "mimiciii" diff --git a/src/fdiff/utils/preprocessing.py b/src/fdiff/utils/preprocessing.py new file mode 100644 index 0000000..b218204 --- /dev/null +++ b/src/fdiff/utils/preprocessing.py @@ -0,0 +1,179 @@ +from pathlib import Path + +import numpy as np +import pandas as pd +import torch +from einops import rearrange + + +def mimic_imputer(df: pd.DataFrame) -> pd.DataFrame: + """ + Impute missing values in a MIMIC-III dataframe. Adapted from MIMIC-Extract https://shorturl.at/amtyQ. + Parameters + ---------- + df : pd.DataFrame + Dataframe to impute. + + Returns + ------- + pd.DataFrame + Imputed dataframe. + """ + ID_COLS = ["subject_id", "hadm_id", "icustay_id"] + + idx = pd.IndexSlice + df = df.copy() + if len(df.columns.names) > 2: + df.columns = df.columns.droplevel(("label", "LEVEL1", "LEVEL2")) + + # Only the mean features (avg measurement over 1 hour) shall be imputed. + df_out = df.loc[:, idx[:, ["mean", "count"]]] # type: ignore + + # Compute mean value over the whole stay for each patient. + icustay_means = df_out.loc[:, idx[:, "mean"]].groupby(ID_COLS).mean() # type: ignore + + # For each patient, propagate last observation forward if possible. + # If not, fill with the mean value for that patient. + # If no mean value is available, fill with 0. + df_out.loc[:, idx[:, "mean"]] = ( # type: ignore + df_out.loc[:, idx[:, "mean"]] # type: ignore + .groupby(ID_COLS) + .ffill() + .groupby(ID_COLS) + .fillna(icustay_means) + .fillna(0) + ) # type: ignore + + # Create mask that highlights time steps at which no feature has been observed. + df_out.loc[:, idx[:, "count"]] = (df.loc[:, idx[:, "count"]] > 0).astype(float) # type: ignore + df_out.rename(columns={"count": "mask"}, level="Aggregation Function", inplace=True) + + # When the feature is missing, compute the time since it was last measured. + is_absent = 1 - df_out.loc[:, idx[:, "mask"]] # type: ignore + hours_of_absence = is_absent.cumsum() + time_since_measured = hours_of_absence - hours_of_absence[is_absent == 0].ffill() + time_since_measured.rename( + columns={"mask": "time_since_measured"}, + level="Aggregation Function", + inplace=True, + ) + + # Add the time since the last measurement to the dataframe. + df_out = pd.concat((df_out, time_since_measured), axis=1) + df_out.loc[:, idx[:, "time_since_measured"]] = df_out.loc[ # type: ignore + :, idx[:, "time_since_measured"] # type: ignore + ].fillna(100) + + # Return a dataframe with sorted columns. + df_out.sort_index(axis=1, inplace=True) + return df_out + + +def mimic_to_3D_tensor(df: pd.DataFrame) -> np.ndarray: + idx = pd.IndexSlice + return np.dstack( + [ + df.loc[idx[:, :, :, i], :].values + for i in sorted(set(df.index.get_level_values("hours_in"))) + ] + ) + + +def mimic_preprocess(data_dir: Path, random_seed: int, train_frac: float = 0.8) -> None: + """Preprocess the MIMIC-III dataset from the raw h5 file in data_dir. + Saves the preprocessed data as .pt files in the same directory. + + Args: + data_dir (Path): Path in which the raw "all_hourly_data.h5 file is stored. + """ + dataset_path = data_dir / "all_hourly_data.h5" + GAP_TIME = 6 # In hours + WINDOW_SIZE = 24 # In hours + + # Load the static and dynamic dataframes + statics = pd.read_hdf(dataset_path, "patients") + df = pd.read_hdf(dataset_path, "vitals_labs") + + # Extract the target + Ys = statics[statics.max_hours > WINDOW_SIZE + GAP_TIME][ + ["mort_hosp", "mort_icu", "los_icu"] + ] + Ys["los_3"] = Ys["los_icu"] > 3 + Ys["los_7"] = Ys["los_icu"] > 7 + Ys.drop(columns=["los_icu"], inplace=True) + Ys.astype(float) + + # Extract the rows of the dynamic dataframe that have a corresponding target + # and that correspond to the first 24 hours of stay. + lvl2 = df[ + ( + df.index.get_level_values("icustay_id").isin( + set(Ys.index.get_level_values("icustay_id")) + ) + ) + & (df.index.get_level_values("hours_in") < WINDOW_SIZE) + ] + + # Extract the identifiers of all patients in the datasets. + lvl2_subj_idx, Ys_subj_idx = [ + df.index.get_level_values("subject_id") for df in (lvl2, Ys) + ] + lvl2_subjects = set(lvl2_subj_idx) + assert lvl2_subjects == set(Ys_subj_idx), "Subject ID pools differ!" + + # Split the dataset into train and test patients + assert 0 < train_frac < 1, f"train_frac must be in (0, 1), but got {train_frac=}." + np.random.seed(random_seed) + subjects, N = np.random.permutation(list(lvl2_subjects)), len(lvl2_subjects) + N_train = int(train_frac * N) + train_subj = subjects[:N_train] + test_subj = subjects[N_train:] + (lvl2_train, lvl2_test) = [ + lvl2[lvl2.index.get_level_values("subject_id").isin(s)] + for s in (train_subj, test_subj) + ] + + # Standardize each feature over all times and patients. + idx = pd.IndexSlice + lvl2_means, lvl2_stds = lvl2_train.loc[:, idx[:, "mean"]].mean( # type: ignore + axis=0 + ), lvl2_train.loc[ + :, idx[:, "mean"] # type: ignore + ].std( # type: ignore + axis=0 + ) # type: ignore + lvl2_train.loc[:, idx[:, "mean"]] = ( # type: ignore + lvl2_train.loc[:, idx[:, "mean"]] - lvl2_means # type: ignore + ) / lvl2_stds + lvl2_test.loc[:, idx[:, "mean"]] = ( # type: ignore + lvl2_test.loc[:, idx[:, "mean"]] - lvl2_means # type: ignore + ) / lvl2_stds + assert isinstance(lvl2_train, pd.DataFrame) and isinstance(lvl2_test, pd.DataFrame) + + # Impute the missing values. + lvl2_train, lvl2_test = [mimic_imputer(df) for df in (lvl2_train, lvl2_test)] + + # Check that there is no missing value after imputation. + for df in lvl2_train, lvl2_test: + assert not df.isnull().any().any() + + # Convert the train and test dataframes to 3D tensors. + X_train, X_test = [ + rearrange( + torch.from_numpy( + mimic_to_3D_tensor(df.loc[:, pd.IndexSlice[:, "mean"]]).astype( # type: ignore + np.float32 + ) + ), + "example_idx channel time -> example_idx time channel", + ) + for df in (lvl2_train, lvl2_test) + ] + + # Check that each time series has 24 time steps and 104 features + for X in X_train, X_test: + assert X.size() == (len(X), 24, 104) + + # Save the preprocessed tensors. + for X, name in zip([X_train, X_test], ["train", "test"]): + torch.save(X, data_dir / f"X_{name}.pt") From 3e6546cc0105b337010e2c1a374d2c8233e900b6 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Sun, 31 Dec 2023 17:27:48 +0100 Subject: [PATCH 09/18] Add einops to dependencies --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index e56d289..2094a73 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,7 @@ dependencies = [ "wandb", "POT", "tables", + "einops", ] From c8105321f97059746f193829eb8802ccecda4328 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 1 Jan 2024 16:15:07 +0000 Subject: [PATCH 10/18] Add top feature selection for MIMIC-III --- cmd/conf/datamodule/mimiciii.yaml | 1 + src/fdiff/dataloaders/datamodules.py | 13 +++++++++++++ 2 files changed, 14 insertions(+) diff --git a/cmd/conf/datamodule/mimiciii.yaml b/cmd/conf/datamodule/mimiciii.yaml index 405b8ac..6c5608b 100644 --- a/cmd/conf/datamodule/mimiciii.yaml +++ b/cmd/conf/datamodule/mimiciii.yaml @@ -4,3 +4,4 @@ random_seed: ${random_seed} fourier_transform: ${fourier_transform} standardize: ${standardize} batch_size: 64 +n_feats: 20 diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index 10900ec..e6b5194 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -277,6 +277,7 @@ def __init__( batch_size: int = 32, fourier_transform: bool = False, standardize: bool = False, + n_feats: int = 104, ) -> None: super().__init__( data_dir=data_dir, @@ -285,6 +286,7 @@ def __init__( fourier_transform=fourier_transform, standardize=standardize, ) + self.n_feats = n_feats def setup(self, stage: str = "fit") -> None: if ( @@ -304,6 +306,17 @@ def setup(self, stage: str = "fit") -> None: self.X_train = torch.load(self.data_dir / "X_train.pt") self.X_test = torch.load(self.data_dir / "X_test.pt") + assert isinstance(self.X_train, torch.Tensor) + assert isinstance(self.X_test, torch.Tensor) + + # Filter the tensors to keep the features with highest variance accross the population + # The variance for each feature is averaged accrossed all time steps + top_feats = torch.argsort(self.X_train.std(1).mean(0), descending=True)[ + : self.n_feats + ] + self.X_train = self.X_train[:, :, top_feats] + self.X_test = self.X_test[:, :, top_feats] + def download_data(self) -> None: dataset_path = self.data_dir / "all_hourly_data.h5" assert dataset_path.exists(), ( From acd8d6afa3c79db2852a4499141e68539457deaf Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 1 Jan 2024 16:18:41 +0000 Subject: [PATCH 11/18] Automatically activate Fourier scaling when necessary --- cmd/conf/score_model/default.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/conf/score_model/default.yaml b/cmd/conf/score_model/default.yaml index 53c41c2..8cc5a5c 100644 --- a/cmd/conf/score_model/default.yaml +++ b/cmd/conf/score_model/default.yaml @@ -4,7 +4,7 @@ d_model: 72 num_layers: 10 n_head: 12 lr_max: 1.0e-3 -fourier_noise_scaling: False +fourier_noise_scaling: ${fourier_transform} likelihood_weighting: False defaults: From 2e42d7810d798920cd52eea7a3ba9201148040c0 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 1 Jan 2024 16:34:04 +0000 Subject: [PATCH 12/18] Also apply sampling callback at last epoch --- src/fdiff/utils/callbacks.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/fdiff/utils/callbacks.py b/src/fdiff/utils/callbacks.py index 6ffadd9..e8e3ee2 100644 --- a/src/fdiff/utils/callbacks.py +++ b/src/fdiff/utils/callbacks.py @@ -48,7 +48,10 @@ def on_train_start(self, trainer: pl.Trainer, pl_module: ScoreModule) -> None: def on_train_epoch_end( self, trainer: pl.Trainer, pl_module: pl.LightningModule ) -> None: - if trainer.current_epoch % self.every_n_epochs == 0: + if ( + trainer.current_epoch % self.every_n_epochs == 0 + or trainer.current_epoch + 1 == trainer.max_epochs + ): # Sample from score model X = self.sample() From 9cac4d4edcb524c2f0eac53af03d319f3d5376a0 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 1 Jan 2024 19:03:35 +0100 Subject: [PATCH 13/18] Bugfix for top feature computation in MIMIC-III --- src/fdiff/dataloaders/datamodules.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index e6b5194..4e8992d 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -311,7 +311,7 @@ def setup(self, stage: str = "fit") -> None: # Filter the tensors to keep the features with highest variance accross the population # The variance for each feature is averaged accrossed all time steps - top_feats = torch.argsort(self.X_train.std(1).mean(0), descending=True)[ + top_feats = torch.argsort(self.X_train.std(0).mean(0), descending=True)[ : self.n_feats ] self.X_train = self.X_train[:, :, top_feats] From de9e29eb70c80e0a13088bc9f47955fa1a565fb3 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 1 Jan 2024 21:09:11 +0100 Subject: [PATCH 14/18] Set number of MIMIC-III features to 50 --- cmd/conf/datamodule/mimiciii.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/conf/datamodule/mimiciii.yaml b/cmd/conf/datamodule/mimiciii.yaml index 6c5608b..0358e67 100644 --- a/cmd/conf/datamodule/mimiciii.yaml +++ b/cmd/conf/datamodule/mimiciii.yaml @@ -4,4 +4,4 @@ random_seed: ${random_seed} fourier_transform: ${fourier_transform} standardize: ${standardize} batch_size: 64 -n_feats: 20 +n_feats: 50 From c1bf674fccbd7b38bd7fcb52d5779152a61ae3b0 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Tue, 2 Jan 2024 12:12:14 +0100 Subject: [PATCH 15/18] Add MIMIC exploration notebook --- notebooks/mimic_exploration.ipynb | 1448 +++++++++++++++++++++++++++++ 1 file changed, 1448 insertions(+) create mode 100644 notebooks/mimic_exploration.ipynb diff --git a/notebooks/mimic_exploration.ipynb b/notebooks/mimic_exploration.ipynb new file mode 100644 index 0000000..ed297f0 --- /dev/null +++ b/notebooks/mimic_exploration.ipynb @@ -0,0 +1,1448 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "import torch\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "DATA_FILEPATH = Path.cwd() / \"../data/mimiciii/all_hourly_data.h5\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "GAP_TIME = 6 # In hours\n", + "WINDOW_SIZE = 24 # In hours\n", + "SEED = 1\n", + "ID_COLS = ['subject_id', 'hadm_id', 'icustay_id']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def simple_imputer(df):\n", + " idx = pd.IndexSlice\n", + " df = df.copy()\n", + " if len(df.columns.names) > 2: df.columns = df.columns.droplevel(('label', 'LEVEL1', 'LEVEL2'))\n", + " \n", + " df_out = df.loc[:, idx[:, ['mean', 'count']]]\n", + " icustay_means = df_out.loc[:, idx[:, 'mean']].groupby(ID_COLS).mean()\n", + " \n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).ffill().groupby(ID_COLS).fillna(icustay_means).fillna(0)\n", + " \n", + " df_out.loc[:, idx[:, 'count']] = (df.loc[:, idx[:, 'count']] > 0).astype(float)\n", + " df_out.rename(columns={'count': 'mask'}, level='Aggregation Function', inplace=True)\n", + " \n", + " is_absent = (1 - df_out.loc[:, idx[:, 'mask']])\n", + " hours_of_absence = is_absent.cumsum()\n", + " time_since_measured = hours_of_absence - hours_of_absence[is_absent==0].ffill()\n", + " time_since_measured.rename(columns={'mask': 'time_since_measured'}, level='Aggregation Function', inplace=True)\n", + "\n", + " df_out = pd.concat((df_out, time_since_measured), axis=1)\n", + " df_out.loc[:, idx[:, 'time_since_measured']] = df_out.loc[:, idx[:, 'time_since_measured']].fillna(100)\n", + " \n", + " df_out.sort_index(axis=1, inplace=True)\n", + " return df_out" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def to_3D_tensor(df):\n", + " idx = pd.IndexSlice\n", + " return np.dstack([df.loc[idx[:,:,:,i], :].values for i in sorted(set(df.index.get_level_values('hours_in')))])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
genderethnicityageinsuranceadmittimediagnosis_at_admissiondischtimedischarge_locationfullcode_firstdnr_first...outtimelos_icuadmission_typefirst_careunitmort_icumort_hosphospital_expire_flaghospstay_seqreadmission_30max_hours
subject_idhadm_idicustay_id
3145834211552MWHITE76.526792Medicare2101-10-20 19:08:00HYPOTENSION2101-10-31 13:58:00SNF1.00.0...2101-10-26 20:43:096.064560EMERGENCYMICU00010145
4185777294638FWHITE47.845047Private2191-03-16 00:28:00FEVER,DEHYDRATION,FAILURE TO THRIVE2191-03-23 18:41:00HOME WITH HOME IV PROVIDR1.00.0...2191-03-17 16:46:311.678472EMERGENCYMICU0001040
6107064228232FWHITE65.942297Medicare2175-05-30 07:15:00CHRONIC RENAL FAILURE/SDA2175-06-15 16:00:00HOME HEALTH CARE1.00.0...2175-06-03 13:39:543.672917ELECTIVESICU0001088
9150750220597MUNKNOWN/NOT SPECIFIED41.790228Medicaid2149-11-09 13:06:00HEMORRHAGIC CVA2149-11-14 10:15:00DEAD/EXPIRED1.00.0...2149-11-14 20:52:145.323056EMERGENCYMICU11110127
11194540229441FWHITE50.148295Private2178-04-16 06:18:00BRAIN MASS2178-05-11 19:00:00HOME HEALTH CARE1.00.0...2178-04-17 20:21:051.584410EMERGENCYSICU0001038
\n", + "

5 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " gender ethnicity age \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 M WHITE 76.526792 \n", + "4 185777 294638 F WHITE 47.845047 \n", + "6 107064 228232 F WHITE 65.942297 \n", + "9 150750 220597 M UNKNOWN/NOT SPECIFIED 41.790228 \n", + "11 194540 229441 F WHITE 50.148295 \n", + "\n", + " insurance admittime \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 Medicare 2101-10-20 19:08:00 \n", + "4 185777 294638 Private 2191-03-16 00:28:00 \n", + "6 107064 228232 Medicare 2175-05-30 07:15:00 \n", + "9 150750 220597 Medicaid 2149-11-09 13:06:00 \n", + "11 194540 229441 Private 2178-04-16 06:18:00 \n", + "\n", + " diagnosis_at_admission \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 HYPOTENSION \n", + "4 185777 294638 FEVER,DEHYDRATION,FAILURE TO THRIVE \n", + "6 107064 228232 CHRONIC RENAL FAILURE/SDA \n", + "9 150750 220597 HEMORRHAGIC CVA \n", + "11 194540 229441 BRAIN MASS \n", + "\n", + " dischtime discharge_location \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 2101-10-31 13:58:00 SNF \n", + "4 185777 294638 2191-03-23 18:41:00 HOME WITH HOME IV PROVIDR \n", + "6 107064 228232 2175-06-15 16:00:00 HOME HEALTH CARE \n", + "9 150750 220597 2149-11-14 10:15:00 DEAD/EXPIRED \n", + "11 194540 229441 2178-05-11 19:00:00 HOME HEALTH CARE \n", + "\n", + " fullcode_first dnr_first ... \\\n", + "subject_id hadm_id icustay_id ... \n", + "3 145834 211552 1.0 0.0 ... \n", + "4 185777 294638 1.0 0.0 ... \n", + "6 107064 228232 1.0 0.0 ... \n", + "9 150750 220597 1.0 0.0 ... \n", + "11 194540 229441 1.0 0.0 ... \n", + "\n", + " outtime los_icu admission_type \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 2101-10-26 20:43:09 6.064560 EMERGENCY \n", + "4 185777 294638 2191-03-17 16:46:31 1.678472 EMERGENCY \n", + "6 107064 228232 2175-06-03 13:39:54 3.672917 ELECTIVE \n", + "9 150750 220597 2149-11-14 20:52:14 5.323056 EMERGENCY \n", + "11 194540 229441 2178-04-17 20:21:05 1.584410 EMERGENCY \n", + "\n", + " first_careunit mort_icu mort_hosp \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 MICU 0 0 \n", + "4 185777 294638 MICU 0 0 \n", + "6 107064 228232 SICU 0 0 \n", + "9 150750 220597 MICU 1 1 \n", + "11 194540 229441 SICU 0 0 \n", + "\n", + " hospital_expire_flag hospstay_seq \\\n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 0 1 \n", + "4 185777 294638 0 1 \n", + "6 107064 228232 0 1 \n", + "9 150750 220597 1 1 \n", + "11 194540 229441 0 1 \n", + "\n", + " readmission_30 max_hours \n", + "subject_id hadm_id icustay_id \n", + "3 145834 211552 0 145 \n", + "4 185777 294638 0 40 \n", + "6 107064 228232 0 88 \n", + "9 150750 220597 0 127 \n", + "11 194540 229441 0 38 \n", + "\n", + "[5 rows x 28 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "statics = pd.read_hdf(DATA_FILEPATH, 'patients')\n", + "statics.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
LEVEL2alanine aminotransferasealbuminalbumin ascitesalbumin pleural...white blood cell countwhite blood cell count urinephph urine
Aggregation Functioncountmeanstdcountmeanstdcountmeanstdcount...stdcountmeanstdcountmeanstdcountmeanstd
subject_idhadm_idicustay_idhours_in
314583421155202.025.00.02.01.80.00.0NaNNaN0.0...4.0128370.0NaNNaN9.07.400.1477331.05.0NaN
10.0NaNNaN0.0NaNNaN0.0NaNNaN0.0...NaN0.0NaNNaN0.0NaNNaN0.0NaNNaN
20.0NaNNaN0.0NaNNaN0.0NaNNaN0.0...NaN0.0NaNNaN3.07.260.0000000.0NaNNaN
30.0NaNNaN0.0NaNNaN0.0NaNNaN0.0...NaN0.0NaNNaN0.0NaNNaN0.0NaNNaN
40.0NaNNaN0.0NaNNaN0.0NaNNaN0.0...NaN0.0NaNNaN0.0NaNNaN0.0NaNNaN
\n", + "

5 rows × 312 columns

\n", + "
" + ], + "text/plain": [ + "LEVEL2 alanine aminotransferase \\\n", + "Aggregation Function count mean std \n", + "subject_id hadm_id icustay_id hours_in \n", + "3 145834 211552 0 2.0 25.0 0.0 \n", + " 1 0.0 NaN NaN \n", + " 2 0.0 NaN NaN \n", + " 3 0.0 NaN NaN \n", + " 4 0.0 NaN NaN \n", + "\n", + "LEVEL2 albumin albumin ascites \\\n", + "Aggregation Function count mean std count mean \n", + "subject_id hadm_id icustay_id hours_in \n", + "3 145834 211552 0 2.0 1.8 0.0 0.0 NaN \n", + " 1 0.0 NaN NaN 0.0 NaN \n", + " 2 0.0 NaN NaN 0.0 NaN \n", + " 3 0.0 NaN NaN 0.0 NaN \n", + " 4 0.0 NaN NaN 0.0 NaN \n", + "\n", + "LEVEL2 albumin pleural ... \\\n", + "Aggregation Function std count ... \n", + "subject_id hadm_id icustay_id hours_in ... \n", + "3 145834 211552 0 NaN 0.0 ... \n", + " 1 NaN 0.0 ... \n", + " 2 NaN 0.0 ... \n", + " 3 NaN 0.0 ... \n", + " 4 NaN 0.0 ... \n", + "\n", + "LEVEL2 white blood cell count \\\n", + "Aggregation Function std \n", + "subject_id hadm_id icustay_id hours_in \n", + "3 145834 211552 0 4.012837 \n", + " 1 NaN \n", + " 2 NaN \n", + " 3 NaN \n", + " 4 NaN \n", + "\n", + "LEVEL2 white blood cell count urine \\\n", + "Aggregation Function count mean std \n", + "subject_id hadm_id icustay_id hours_in \n", + "3 145834 211552 0 0.0 NaN NaN \n", + " 1 0.0 NaN NaN \n", + " 2 0.0 NaN NaN \n", + " 3 0.0 NaN NaN \n", + " 4 0.0 NaN NaN \n", + "\n", + "LEVEL2 ph ph urine \n", + "Aggregation Function count mean std count mean std \n", + "subject_id hadm_id icustay_id hours_in \n", + "3 145834 211552 0 9.0 7.40 0.147733 1.0 5.0 NaN \n", + " 1 0.0 NaN NaN 0.0 NaN NaN \n", + " 2 3.0 7.26 0.000000 0.0 NaN NaN \n", + " 3 0.0 NaN NaN 0.0 NaN NaN \n", + " 4 0.0 NaN NaN 0.0 NaN NaN \n", + "\n", + "[5 rows x 312 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_hdf(DATA_FILEPATH, 'vitals_labs')\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "Ys = statics[statics.max_hours > WINDOW_SIZE + GAP_TIME][['mort_hosp', 'mort_icu', 'los_icu']]\n", + "Ys['los_3'] = Ys['los_icu'] > 3\n", + "Ys['los_7'] = Ys['los_icu'] > 7\n", + "Ys.drop(columns=['los_icu'], inplace=True)\n", + "Ys.astype(float)\n", + "\n", + "lvl2 = df[\n", + " (df.index.get_level_values('icustay_id').isin(set(Ys.index.get_level_values('icustay_id')))) &\n", + " (df.index.get_level_values('hours_in') < WINDOW_SIZE)\n", + "]\n", + "\n", + "train_frac, dev_frac, test_frac = 0.7, 0.1, 0.2\n", + "lvl2_subj_idx, Ys_subj_idx = [df.index.get_level_values('subject_id') for df in (lvl2, Ys)]\n", + "lvl2_subjects = set(lvl2_subj_idx)\n", + "assert lvl2_subjects == set(Ys_subj_idx), \"Subject ID pools differ!\"\n", + "\n", + "np.random.seed(SEED)\n", + "subjects, N = np.random.permutation(list(lvl2_subjects)), len(lvl2_subjects)\n", + "N_train, N_dev, N_test = int(train_frac * N), int(dev_frac * N), int(test_frac * N)\n", + "train_subj = subjects[:N_train]\n", + "dev_subj = subjects[N_train:N_train + N_dev]\n", + "test_subj = subjects[N_train+N_dev:]\n", + "\n", + "[(lvl2_train, lvl2_dev, lvl2_test), (Ys_train, Ys_dev, Ys_test)] = [\n", + " [df[df.index.get_level_values('subject_id').isin(s)] for s in (train_subj, dev_subj, test_subj)] \\\n", + " for df in (lvl2, Ys)\n", + "]\n", + "\n", + "idx = pd.IndexSlice\n", + "lvl2_means, lvl2_stds = lvl2_train.loc[:, idx[:,'mean']].mean(axis=0), lvl2_train.loc[:, idx[:,'mean']].std(axis=0)\n", + "\n", + "lvl2_train.loc[:, idx[:,'mean']] = (lvl2_train.loc[:, idx[:,'mean']] - lvl2_means)/lvl2_stds\n", + "lvl2_dev.loc[:, idx[:,'mean']] = (lvl2_dev.loc[:, idx[:,'mean']] - lvl2_means)/lvl2_stds\n", + "lvl2_test.loc[:, idx[:,'mean']] = (lvl2_test.loc[:, idx[:,'mean']] - lvl2_means)/lvl2_stds" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrameGroupBy.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:14: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " df_out.rename(columns={'count': 'mask'}, level='Aggregation Function', inplace=True)\n", + "/tmp/ipykernel_179799/2355116716.py:18: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " time_since_measured = hours_of_absence - hours_of_absence[is_absent==0].fillna(method='ffill')\n", + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrameGroupBy.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:14: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " df_out.rename(columns={'count': 'mask'}, level='Aggregation Function', inplace=True)\n", + "/tmp/ipykernel_179799/2355116716.py:18: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " time_since_measured = hours_of_absence - hours_of_absence[is_absent==0].fillna(method='ffill')\n", + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrameGroupBy.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:9: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " df_out.loc[:,idx[:,'mean']] = df_out.loc[:,idx[:,'mean']].groupby(ID_COLS).fillna(\n", + "/tmp/ipykernel_179799/2355116716.py:14: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " df_out.rename(columns={'count': 'mask'}, level='Aggregation Function', inplace=True)\n", + "/tmp/ipykernel_179799/2355116716.py:18: FutureWarning: DataFrame.fillna with 'method' is deprecated and will raise in a future version. Use obj.ffill() or obj.bfill() instead.\n", + " time_since_measured = hours_of_absence - hours_of_absence[is_absent==0].fillna(method='ffill')\n" + ] + } + ], + "source": [ + "lvl2_train, lvl2_dev, lvl2_test = [\n", + " simple_imputer(df) for df in (lvl2_train, lvl2_dev, lvl2_test)\n", + "]\n", + "\n", + "for df in lvl2_train, lvl2_dev, lvl2_test: assert not df.isnull().any().any()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "Ys = statics[statics.max_hours > WINDOW_SIZE + GAP_TIME][['mort_hosp', 'mort_icu', 'los_icu']]\n", + "Ys['los_3'] = Ys['los_icu'] > 3\n", + "Ys['los_7'] = Ys['los_icu'] > 7\n", + "Ys.drop(columns=['los_icu'], inplace=True)\n", + "Ys.astype(float)\n", + "[(Ys_train, Ys_dev, Ys_test)] = [\n", + " [df[df.index.get_level_values('subject_id').isin(s)] for s in (train_subj, dev_subj, test_subj)] \\\n", + " for df in (Ys,)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16760, 104, 24])\n", + "torch.Size([16760, 4])\n" + ] + } + ], + "source": [ + "X_train = torch.from_numpy(to_3D_tensor(lvl2_train.loc[:, pd.IndexSlice[:, 'mean']]).astype(np.float32))\n", + "Y_train = torch.from_numpy(Ys_train.values.astype(np.int64))\n", + "print(X_train.shape)\n", + "print(Y_train.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " ...,\n", + " [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n", + " [ 0.1821, 0.1821, 0.1821, ..., -0.3215, -0.3215, -0.3215],\n", + " [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000]])\n", + "tensor([0, 0, 0, 0])\n" + ] + } + ], + "source": [ + "print(X_train[1000])\n", + "print(Y_train[1000])" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-6.5309e-02, -6.5219e-02, -6.4588e-02, ..., -6.3912e-02,\n", + " -6.3586e-02, -6.3790e-02],\n", + " [ 3.5038e-02, 3.4359e-02, 3.3021e-02, ..., 1.5625e-02,\n", + " 1.4301e-02, 1.3290e-02],\n", + " [ 1.7782e-11, 1.7782e-11, 1.7782e-11, ..., 1.7782e-11,\n", + " 1.7782e-11, 1.7782e-11],\n", + " ...,\n", + " [-1.2061e-02, -1.4655e-02, -1.5165e-02, ..., 4.3676e-03,\n", + " 5.0095e-03, 5.3206e-03],\n", + " [-9.9786e-04, 1.1045e-03, 3.4469e-03, ..., -3.9437e-02,\n", + " -4.1601e-02, -4.3474e-02],\n", + " [-1.9659e-04, -1.5752e-04, -1.2957e-04, ..., -2.8179e-04,\n", + " -2.9970e-04, -4.4784e-04]])\n", + "tensor([[0.4258, 0.4231, 0.4289, ..., 0.4123, 0.4105, 0.4081],\n", + " [0.6207, 0.6198, 0.6185, ..., 0.6104, 0.6092, 0.6096],\n", + " [0.0546, 0.0546, 0.0546, ..., 0.0546, 0.0546, 0.0546],\n", + " ...,\n", + " [0.8095, 0.8120, 0.8111, ..., 0.8178, 0.8176, 0.8178],\n", + " [0.9639, 0.9629, 0.9453, ..., 0.8095, 0.8049, 0.7927],\n", + " [0.3380, 0.3381, 0.3383, ..., 0.3387, 0.3387, 0.3383]])\n" + ] + } + ], + "source": [ + "print(torch.mean(X_train, dim=0))\n", + "print(torch.std(X_train, dim=0))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lvl2_train.loc[:, idx[:,'mean']].mean(axis=0).plot(kind=\"hist\")" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "lvl2_train.loc[:, idx[:,'mean']].std(axis=0).plot(kind=\"hist\")" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_179799/157780906.py:4: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(X_train.mean(dim=0).flatten())\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "X_train = torch.load(Path.cwd() / \"../data/mimiciii/X_train.pt\")\n", + "sns.distplot(X_train.mean(dim=0).flatten())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(X_train.mean(dim=0), vmin=-1, vmax=1, cmap=\"RdBu_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_179799/3314006042.py:1: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(X_train.std(dim=0).flatten())\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.distplot(X_train.std(dim=0).flatten())" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(X_train.std(dim=0), vmin=-2, vmax=2, cmap=\"RdBu_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(X_train.std(dim=0).sum(dim=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_179799/1785037963.py:2: UserWarning: \n", + "\n", + "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n", + "\n", + "Please adapt your code to use either `displot` (a figure-level function with\n", + "similar flexibility) or `histplot` (an axes-level function for histograms).\n", + "\n", + "For a guide to updating your code to use the new functions, please see\n", + "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n", + "\n", + " sns.distplot(dft(X_train).mean(dim=0))\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from fdiff.utils.fourier import dft\n", + "sns.distplot(dft(X_train).mean(dim=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 116, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X_norm = (X_train - X_train.mean(dim=0))/X_train.std(dim=0)\n", + "sns.heatmap(X_train.max(0)[0], vmin=-200, vmax=200, cmap=\"RdBu_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [], + "source": [ + "X_train_dft = dft(X_train)\n", + "X_demean_dft = X_train_dft - X_train_dft.mean(dim=0)\n", + "X_demean = X_train - X_train.mean(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Singular value')" + ] + }, + "execution_count": 118, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "sns.lineplot(torch.svd(X_norm.flatten(start_dim=1))[1], label=\"Time domain\")\n", + "sns.lineplot(torch.svd(X_demean.flatten(start_dim=1))[1], label=\"Frequency domain\")\n", + "plt.legend()\n", + "plt.xlabel(\"Singular value index\")\n", + "plt.ylabel(\"Singular value\")" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for idx in [666, 777, 42, 12]:\n", + " max_val = torch.abs(X_train[idx]).max(dim=0)[0].max(dim=0)[0]\n", + " sns.heatmap(X_norm[idx].transpose(1, 0), cmap=\"RdBu_r\", vmin=-max_val, vmax=max_val)\n", + " plt.xlabel(\"Time\")\n", + " plt.ylabel(\"Feature\")\n", + " plt.show()\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 138, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "max_val = X_train.std(0).max()\n", + "sns.heatmap(X_train.std(0), vmin=-max_val, vmax=max_val, cmap=\"RdBu_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 61, 55, 57, 31, 38, 87, 54, 91, 56, 40, 82, 71, 41, 9,\n", + " 13, 26, 11, 92, 19, 88, 75, 6, 53, 25, 89, 102, 37, 101,\n", + " 62, 68, 77, 64, 69, 66, 78, 36, 94, 12, 93, 46, 24, 60,\n", + " 67, 65, 58, 18, 8, 73, 1, 70, 95, 42, 10, 76, 5, 99,\n", + " 33, 35, 45, 63, 34, 80, 0, 72, 7, 39, 43, 30, 90, 15])\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "top_feats = torch.argsort(X_train.std(0).mean(0), descending=True)[:70]\n", + "print(top_feats)\n", + "sns.heatmap(X_train[:, :, top_feats].std(0), vmin=0, vmax=max_val, cmap=\"RdBu_r\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 13b2f68b6af4a33a15ff81af176fc35a452bed00 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Tue, 2 Jan 2024 17:13:28 +0100 Subject: [PATCH 16/18] Add NASDAQ datamodule --- cmd/conf/datamodule/nasdaq.yaml | 6 + notebooks/nasdaq_exploration.ipynb | 1308 ++++++++++++++++++++++++++ src/fdiff/dataloaders/datamodules.py | 57 +- src/fdiff/utils/preprocessing.py | 81 +- 4 files changed, 1450 insertions(+), 2 deletions(-) create mode 100644 cmd/conf/datamodule/nasdaq.yaml create mode 100644 notebooks/nasdaq_exploration.ipynb diff --git a/cmd/conf/datamodule/nasdaq.yaml b/cmd/conf/datamodule/nasdaq.yaml new file mode 100644 index 0000000..4a1f470 --- /dev/null +++ b/cmd/conf/datamodule/nasdaq.yaml @@ -0,0 +1,6 @@ +_target_: fdiff.dataloaders.datamodules.NASDAQDatamodule +data_dir: ${hydra:runtime.cwd}/data +random_seed: ${random_seed} +fourier_transform: ${fourier_transform} +standardize: ${standardize} +batch_size: 64 diff --git a/notebooks/nasdaq_exploration.ipynb b/notebooks/nasdaq_exploration.ipynb new file mode 100644 index 0000000..78e8f57 --- /dev/null +++ b/notebooks/nasdaq_exploration.ipynb @@ -0,0 +1,1308 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from tqdm import tqdm\n", + "from einops import rearrange\n", + "from fdiff.utils.fourier import dft\n", + "\n", + "import pandas as pd\n", + "import torch\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "DATA_FILEPATH = Path.cwd() / \"../data/nasdaq/stocks\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading stock data: 0%| | 0/5884 [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateOpenHighLowCloseAdj CloseVolumeName
02015-10-120.0500.0500.0500.0500.0500.0LN
12015-10-130.0450.0450.0450.0450.0455000.0LN
22015-10-140.0500.0500.0500.0500.050410000.0LN
32015-10-150.0500.0500.0500.0500.05091100.0LN
42015-10-160.0500.0500.0500.0500.05035000.0LN
\n", + "" + ], + "text/plain": [ + " Date Open High Low Close Adj Close Volume Name\n", + "0 2015-10-12 0.050 0.050 0.050 0.050 0.050 0.0 LN\n", + "1 2015-10-13 0.045 0.045 0.045 0.045 0.045 5000.0 LN\n", + "2 2015-10-14 0.050 0.050 0.050 0.050 0.050 410000.0 LN\n", + "3 2015-10-15 0.050 0.050 0.050 0.050 0.050 91100.0 LN\n", + "4 2015-10-16 0.050 0.050 0.050 0.050 0.050 35000.0 LN" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collate all stock data into a single dataframe\n", + "df_list = []\n", + "stock_paths = list(DATA_FILEPATH.glob(\"*.csv\"))\n", + "for path in tqdm(stock_paths, unit=\"stock\", leave=False, desc=\"Loading stock data\"):\n", + " df_stock = pd.read_csv(path)\n", + " df_stock[\"Name\"] = path.stem.strip(\".csv\")\n", + " df_list.append(df_stock)\n", + "df = pd.concat(df_list, axis=0, ignore_index=True)\n", + "assert len(df[\"Name\"].unique()) == len(stock_paths)\n", + "df.head() \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateOpenHighLowCloseAdj CloseVolumeName
02015-10-120.0500.0500.0500.0500.0500.0LN
12015-10-130.0450.0450.0450.0450.0455000.0LN
22015-10-140.0500.0500.0500.0500.050410000.0LN
32015-10-150.0500.0500.0500.0500.05091100.0LN
42015-10-160.0500.0500.0500.0500.05035000.0LN
\n", + "
" + ], + "text/plain": [ + " Date Open High Low Close Adj Close Volume Name\n", + "0 2015-10-12 0.050 0.050 0.050 0.050 0.050 0.0 LN\n", + "1 2015-10-13 0.045 0.045 0.045 0.045 0.045 5000.0 LN\n", + "2 2015-10-14 0.050 0.050 0.050 0.050 0.050 410000.0 LN\n", + "3 2015-10-15 0.050 0.050 0.050 0.050 0.050 91100.0 LN\n", + "4 2015-10-16 0.050 0.050 0.050 0.050 0.050 35000.0 LN" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Convert date column to datetime\n", + "df[\"Date\"] = pd.to_datetime(df[\"Date\"])\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "start_time = pd.to_datetime(\"2019-01-01\")\n", + "end_time = pd.to_datetime(\"2020-01-01\")\n", + "\n", + "# Remove stocks that are not active in the whole time interval\n", + "stocks_older_than_start = set()\n", + "stocks_active_in_end = set()\n", + "for stock, valid in (df.groupby(\"Name\")[\"Date\"].min() <= start_time).items():\n", + " if valid:\n", + " stocks_older_than_start.add(stock)\n", + "for stock, valid in (df.groupby(\"Name\")[\"Date\"].max() >= end_time).items():\n", + " if valid:\n", + " stocks_active_in_end.add(stock)\n", + "valid_stocks = stocks_older_than_start.intersection(stocks_active_in_end)\n", + "df = df[df[\"Name\"].isin(valid_stocks) & (df[\"Date\"] >= start_time) & (df[\"Date\"] < end_time)] " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Remove stocks with missing days\n", + "stocks_no_missing_day = set()\n", + "for stock, valid in (df.groupby(\"Name\")[\"Date\"].nunique() == 252).items():\n", + " if valid:\n", + " stocks_no_missing_day.add(stock)\n", + "df = df[df[\"Name\"].isin(stocks_no_missing_day)] " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Date\n", + "252 5364\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby(\"Name\")[\"Date\"].nunique().value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateOpenHighLowCloseAdj CloseVolumeName
8092019-01-0233.59000034.32000033.59000034.16000034.16000025900.0LN
8102019-01-0334.20999934.43999933.49000233.52999933.52999972200.0LN
8112019-01-0435.06000136.34000035.00999836.34000036.34000081800.0LN
8122019-01-0736.16000036.45999935.88000136.15000236.15000247600.0LN
8132019-01-0836.33000236.63999936.07000036.58000236.58000248700.0LN
\n", + "
" + ], + "text/plain": [ + " Date Open High Low Close Adj Close \\\n", + "809 2019-01-02 33.590000 34.320000 33.590000 34.160000 34.160000 \n", + "810 2019-01-03 34.209999 34.439999 33.490002 33.529999 33.529999 \n", + "811 2019-01-04 35.060001 36.340000 35.009998 36.340000 36.340000 \n", + "812 2019-01-07 36.160000 36.459999 35.880001 36.150002 36.150002 \n", + "813 2019-01-08 36.330002 36.639999 36.070000 36.580002 36.580002 \n", + "\n", + " Volume Name \n", + "809 25900.0 LN \n", + "810 72200.0 LN \n", + "811 81800.0 LN \n", + "812 47600.0 LN \n", + "813 48700.0 LN " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Adj Close...Volume
Date2019-01-022019-01-032019-01-042019-01-072019-01-082019-01-092019-01-102019-01-112019-01-142019-01-15...2019-12-172019-12-182019-12-192019-12-202019-12-232019-12-242019-12-262019-12-272019-12-302019-12-31
Name
A64.96868162.57524964.74120366.11592967.08517568.48957869.13244669.60717068.98410069.824745...1653200.02025500.01696000.02287800.0816000.0271900.0649100.0767700.0742800.01176200.0
AA26.24000026.24000028.34000028.42000028.25000029.10000028.98000028.54999928.79000128.900000...3504000.05129800.04766900.05139800.02262200.01092200.04729200.02455000.02299200.02288500.0
AAL31.96316029.58166531.53016132.42567831.90411032.88819931.53016131.29398031.20541031.589205...5920300.04633800.06295100.012277100.09291100.02373600.04746500.08416500.04940300.04396800.0
AAMC30.01000030.30999929.76000029.73000029.08000029.38999929.60000030.49000030.57000029.920000...3700.06800.012000.00.0600.06900.0300.00.020100.021500.0
AAME2.4702382.6289682.9265872.7480162.6289682.7678572.4305562.5793652.4702382.648810...4000.010900.03600.05100.01000.01700.05900.03500.0700.03400.0
\n", + "

5 rows × 1512 columns

\n", + "
" + ], + "text/plain": [ + " Adj Close \\\n", + "Date 2019-01-02 2019-01-03 2019-01-04 2019-01-07 2019-01-08 2019-01-09 \n", + "Name \n", + "A 64.968681 62.575249 64.741203 66.115929 67.085175 68.489578 \n", + "AA 26.240000 26.240000 28.340000 28.420000 28.250000 29.100000 \n", + "AAL 31.963160 29.581665 31.530161 32.425678 31.904110 32.888199 \n", + "AAMC 30.010000 30.309999 29.760000 29.730000 29.080000 29.389999 \n", + "AAME 2.470238 2.628968 2.926587 2.748016 2.628968 2.767857 \n", + "\n", + " ... Volume \\\n", + "Date 2019-01-10 2019-01-11 2019-01-14 2019-01-15 ... 2019-12-17 2019-12-18 \n", + "Name ... \n", + "A 69.132446 69.607170 68.984100 69.824745 ... 1653200.0 2025500.0 \n", + "AA 28.980000 28.549999 28.790001 28.900000 ... 3504000.0 5129800.0 \n", + "AAL 31.530161 31.293980 31.205410 31.589205 ... 5920300.0 4633800.0 \n", + "AAMC 29.600000 30.490000 30.570000 29.920000 ... 3700.0 6800.0 \n", + "AAME 2.430556 2.579365 2.470238 2.648810 ... 4000.0 10900.0 \n", + "\n", + " \\\n", + "Date 2019-12-19 2019-12-20 2019-12-23 2019-12-24 2019-12-26 2019-12-27 \n", + "Name \n", + "A 1696000.0 2287800.0 816000.0 271900.0 649100.0 767700.0 \n", + "AA 4766900.0 5139800.0 2262200.0 1092200.0 4729200.0 2455000.0 \n", + "AAL 6295100.0 12277100.0 9291100.0 2373600.0 4746500.0 8416500.0 \n", + "AAMC 12000.0 0.0 600.0 6900.0 300.0 0.0 \n", + "AAME 3600.0 5100.0 1000.0 1700.0 5900.0 3500.0 \n", + "\n", + " \n", + "Date 2019-12-30 2019-12-31 \n", + "Name \n", + "A 742800.0 1176200.0 \n", + "AA 2299200.0 2288500.0 \n", + "AAL 4940300.0 4396800.0 \n", + "AAMC 20100.0 21500.0 \n", + "AAME 700.0 3400.0 \n", + "\n", + "[5 rows x 1512 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_pivot = df.pivot_table(index=\"Name\", columns=\"Date\", values=[\"Open\", \"High\", \"Low\", \"Close\", \"Adj Close\", \"Volume\"])\n", + "df_pivot.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([5364, 252, 6])" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a tensor of shape (num_stocks, num_days, num_features) from df\n", + "X = torch.tensor(df_pivot.values, dtype=torch.float32)\n", + "X = rearrange(X, \"stock (feature day) -> stock day feature\", day=252)\n", + "X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[64.9687, 65.6900, 66.5700, 65.3000, 66.5000],\n", + " [62.5752, 63.2700, 65.7800, 62.0000, 65.5300],\n", + " [64.7412, 65.4600, 65.9500, 64.0900, 64.0900],\n", + " ...,\n", + " [85.0236, 85.4200, 85.6800, 85.1100, 85.6800],\n", + " [84.6845, 84.9000, 85.4000, 84.6400, 85.3400],\n", + " [85.0934, 85.3100, 85.3400, 84.6700, 84.8400]])\n", + "tensor([[26.2400, 26.2400, 26.8470, 25.4800, 25.9550],\n", + " [26.2400, 26.2400, 26.8500, 25.5300, 26.1200],\n", + " [28.3400, 28.3400, 28.6100, 26.6500, 26.8400],\n", + " ...,\n", + " [21.5800, 21.5800, 21.7800, 21.3300, 21.4100],\n", + " [21.3400, 21.3400, 21.7000, 21.3000, 21.7000],\n", + " [21.5100, 21.5100, 21.6700, 21.2600, 21.3700]])\n", + "tensor([[31.9632, 32.4800, 32.6500, 31.0500, 31.4600],\n", + " [29.5817, 30.0600, 31.8500, 28.8100, 31.6900],\n", + " [31.5302, 32.0400, 32.0900, 30.4000, 30.4400],\n", + " ...,\n", + " [28.3353, 28.4400, 29.8100, 28.3600, 29.7600],\n", + " [28.1958, 28.3000, 28.5300, 28.0700, 28.5000],\n", + " [28.5744, 28.6800, 28.7900, 28.1900, 28.2000]])\n", + "tensor([[30.0100, 30.0100, 30.9900, 29.4100, 30.0300],\n", + " [30.3100, 30.3100, 31.3000, 30.3100, 31.3000],\n", + " [29.7600, 29.7600, 31.2000, 29.7600, 31.0000],\n", + " ...,\n", + " [13.1900, 13.1900, 13.1900, 13.1900, 13.1900],\n", + " [11.2000, 11.2000, 13.5000, 11.0500, 13.5000],\n", + " [12.3500, 12.3500, 12.3500, 10.2000, 11.2200]])\n", + "tensor([[2.4702, 2.4900, 2.4900, 2.4300, 2.4300],\n", + " [2.6290, 2.6500, 2.7200, 2.5000, 2.5100],\n", + " [2.9266, 2.9500, 3.0600, 2.6500, 2.6500],\n", + " ...,\n", + " [1.8500, 1.8500, 1.9000, 1.8200, 1.9000],\n", + " [1.9200, 1.9200, 1.9200, 1.8500, 1.8500],\n", + " [1.9700, 1.9700, 1.9700, 1.8500, 1.9300]])\n" + ] + } + ], + "source": [ + "for stock in range(5):\n", + " print(X[stock, :, 0:5])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train set shape: torch.Size([4827, 252, 6])\n", + "Test set shape: torch.Size([537, 252, 6])\n" + ] + } + ], + "source": [ + "train_ratio = 0.9\n", + "num_train = int(train_ratio * len(X))\n", + "perm_idx = torch.randperm(len(X))\n", + "train_stocks, test_stocks = perm_idx[:num_train], perm_idx[num_train:]\n", + "X_train, X_test = X[train_stocks], X[test_stocks]\n", + "print(f\"Train set shape: {X_train.shape}\")\n", + "print(f\"Test set shape: {X_test.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Singular value')" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "X_train_reduced = X_train[:, :, :1]\n", + "X_norm = (X_train_reduced - X_train_reduced.mean(dim=0, keepdim=True)) / X_train_reduced.std(dim=0, keepdim=True)\n", + "X_dft = dft(X_train_reduced)\n", + "X_norm_dft = (X_dft - X_dft.mean(dim=0, keepdim=True)) / X_dft.std(dim=0, keepdim=True)\n", + "\n", + "sns.lineplot(torch.svd(X_norm.flatten(start_dim=1))[1], label=\"Time domain\")\n", + "sns.lineplot(torch.svd(X_norm_dft.flatten(start_dim=1))[1], label=\"Frequency domain\")\n", + "plt.legend()\n", + "plt.xlabel(\"Singular value index\")\n", + "plt.ylabel(\"Singular value\")" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAHqCAYAAADLbQ06AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAu0klEQVR4nO3df3SU5Z3//9cgyRDTcJsYkiEHxKjIQoN0G1wIH1csSIAlIOuerhU6X/zWxWoNmBXOnqLbBf10CR9dad1i/dFa7bbV9Hu+gHW3mCUKxuaQAEayEEAPPUUCNCEUJpMfkpmQuT5/sNzrJAFDGJxrzPNxzn1k7uude677En3lun96jDFGAADASkPi3QEAAHBhBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygjiFjjFpbW8UzZAAAsUJQx1BbW5scx1FbW1u8uwIA+IIgqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDF4hrUzz//vG655RYNHz5cw4cPV0FBgd566y233RijNWvWKCcnRykpKbrjjju0f//+qG2EQiEtW7ZMmZmZSk1N1YIFC3Ts2LGomkAgIL/fL8dx5DiO/H6/WlpaomoaGho0f/58paamKjMzU8uXL1c4HL5i+w4AQH/ENahHjRqldevW6f3339f777+vGTNm6K677nLD+KmnntL69eu1YcMG7d69Wz6fT7NmzVJbW5u7jZKSEm3evFllZWWqqqpSe3u7ioqK1N3d7dYsWrRIdXV1Ki8vV3l5uerq6uT3+9327u5uzZs3Tx0dHaqqqlJZWZk2btyoFStWfH6DAQBAX4xl0tPTzU9/+lMTiUSMz+cz69atc9s6OzuN4zjmhRdeMMYY09LSYpKSkkxZWZlbc/z4cTNkyBBTXl5ujDHmwIEDRpKpqalxa6qrq40k8+GHHxpjjNmyZYsZMmSIOX78uFvz+uuvG6/Xa4LBYL/7HgwGjaRL+pm+RCIRE4lELmsbAIAvBmvOUXd3d6usrEwdHR0qKCjQ4cOH1dTUpMLCQrfG6/Vq+vTp2rFjhySptrZWXV1dUTU5OTnKy8tza6qrq+U4jqZMmeLWTJ06VY7jRNXk5eUpJyfHrZk9e7ZCoZBqa2sv2OdQKKTW1taoBQCAWIp7UO/bt09f+tKX5PV69eCDD2rz5s2aMGGCmpqaJEnZ2dlR9dnZ2W5bU1OTkpOTlZ6eftGarKysXt+blZUVVdPze9LT05WcnOzW9KW0tNQ97+04jkaPHn2Jew8AwMXFPajHjRunuro61dTU6KGHHtKSJUt04MABt93j8UTVG2N6reupZ01f9QOp6WnVqlUKBoPucvTo0Yv2CwCASxX3oE5OTtZNN92kyZMnq7S0VJMmTdKzzz4rn88nSb1mtM3Nze7s1+fzKRwOKxAIXLTmxIkTvb735MmTUTU9vycQCKirq6vXTPvTvF6ve8X6+QUAgFiKe1D3ZIxRKBRSbm6ufD6fKioq3LZwOKzKykpNmzZNkpSfn6+kpKSomsbGRtXX17s1BQUFCgaD2rVrl1uzc+dOBYPBqJr6+no1Nja6NVu3bpXX61V+fv4V3V8AAC4qnleyrVq1yrz33nvm8OHDZu/eveaxxx4zQ4YMMVu3bjXGGLNu3TrjOI7ZtGmT2bdvn7n33nvNyJEjTWtrq7uNBx980IwaNcq8/fbb5oMPPjAzZswwkyZNMmfPnnVr5syZY2655RZTXV1tqqurzcSJE01RUZHbfvbsWZOXl2dmzpxpPvjgA/P222+bUaNGmeLi4kvaH676BgDEWlyD+lvf+pYZM2aMSU5ONiNGjDAzZ850Q9qYc4G1evVq4/P5jNfrNbfffrvZt29f1DbOnDljiouLTUZGhklJSTFFRUWmoaEhqubUqVNm8eLFJi0tzaSlpZnFixebQCAQVXPkyBEzb948k5KSYjIyMkxxcbHp7Oy8pP0hqAEAseYxxph4z+q/KFpbW+U4joLB4GWdrz7/r+SzLpoDAHzxWXeOGgAA/A+CGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagsZY8RrwgEAEkENAIDVCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxYbGuwPojaeSAQDOY0YNAIDFCGoAACxGUAMAYDGCGgAAi3ExmYW4mAwAcB4zagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFgsrkFdWlqqW2+9VWlpacrKytLChQv10UcfRdXcd9998ng8UcvUqVOjakKhkJYtW6bMzEylpqZqwYIFOnbsWFRNIBCQ3++X4zhyHEd+v18tLS1RNQ0NDZo/f75SU1OVmZmp5cuXKxwOX5F9BwCgP+Ia1JWVlXr44YdVU1OjiooKnT17VoWFhero6IiqmzNnjhobG91ly5YtUe0lJSXavHmzysrKVFVVpfb2dhUVFam7u9utWbRokerq6lReXq7y8nLV1dXJ7/e77d3d3Zo3b546OjpUVVWlsrIybdy4UStWrLiygwAAwMUYizQ3NxtJprKy0l23ZMkSc9ddd13wZ1paWkxSUpIpKytz1x0/ftwMGTLElJeXG2OMOXDggJFkampq3Jrq6mojyXz44YfGGGO2bNlihgwZYo4fP+7WvP7668br9ZpgMNiv/geDQSOp3/UX0tXVZbq6ui5rGwCALwarzlEHg0FJUkZGRtT6d999V1lZWbr55pu1dOlSNTc3u221tbXq6upSYWGhuy4nJ0d5eXnasWOHJKm6ulqO42jKlCluzdSpU+U4TlRNXl6ecnJy3JrZs2crFAqptrY29jsLAEA/DI13B84zxujRRx/Vbbfdpry8PHf93Llz9fWvf11jxozR4cOH9b3vfU8zZsxQbW2tvF6vmpqalJycrPT09KjtZWdnq6mpSZLU1NSkrKysXt+ZlZUVVZOdnR3Vnp6eruTkZLemp1AopFAo5H5ubW0d2M4DAHAB1gR1cXGx9u7dq6qqqqj199xzj/vnvLw8TZ48WWPGjNFvf/tb3X333RfcnjFGHo/H/fzpP19OzaeVlpbqiSeeuPBOAQBwmaw49L1s2TK9+eab2r59u0aNGnXR2pEjR2rMmDE6dOiQJMnn8ykcDisQCETVNTc3uzNkn8+nEydO9NrWyZMno2p6zpwDgYC6urp6zbTPW7VqlYLBoLscPXq0fzsMAEA/xTWojTEqLi7Wpk2btG3bNuXm5n7mz5w6dUpHjx7VyJEjJUn5+flKSkpSRUWFW9PY2Kj6+npNmzZNklRQUKBgMKhdu3a5NTt37lQwGIyqqa+vV2Njo1uzdetWeb1e5efn99kXr9er4cOHRy0AAMSSxxhj4vXl3/nOd/Taa6/pN7/5jcaNG+eudxxHKSkpam9v15o1a/Q3f/M3GjlypD7++GM99thjamho0MGDB5WWliZJeuihh/Qf//EfevXVV5WRkaGVK1fq1KlTqq2t1VVXXSXp3LnuP/7xj3rxxRclSQ888IDGjBmjf//3f5d07vasr3zlK8rOztbTTz+t06dP67777tPChQv1ox/9qF/709raKsdxFAwGLyu0z549K0kaOtSaMxMAgHiJ4xXnRlKfyyuvvGKMMeaTTz4xhYWFZsSIESYpKclcd911ZsmSJaahoSFqO2fOnDHFxcUmIyPDpKSkmKKiol41p06dMosXLzZpaWkmLS3NLF682AQCgaiaI0eOmHnz5pmUlBSTkZFhiouLTWdnZ7/3h9uzAACxFtcZ9RcNM2oAQKxZcTEZAADoG1M2C3GQAwBwHjNqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGO+jthDvowYAnMeMGgAAixHUAABYjKAGAMBiBDUAABbjYjILcTEZAOA8ZtQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDHuo7YQ91EDAM5jRg0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFuM+agtxHzUA4Dxm1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoLaUMYYnlAEACGoAAGxGUAMAYDGCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIvFNahLS0t16623Ki0tTVlZWVq4cKE++uijqBpjjNasWaOcnBylpKTojjvu0P79+6NqQqGQli1bpszMTKWmpmrBggU6duxYVE0gEJDf75fjOHIcR36/Xy0tLVE1DQ0Nmj9/vlJTU5WZmanly5crHA5fkX0HAKA/4hrUlZWVevjhh1VTU6OKigqdPXtWhYWF6ujocGueeuoprV+/Xhs2bNDu3bvl8/k0a9YstbW1uTUlJSXavHmzysrKVFVVpfb2dhUVFam7u9utWbRokerq6lReXq7y8nLV1dXJ7/e77d3d3Zo3b546OjpUVVWlsrIybdy4UStWrPh8BgMAgL4YizQ3NxtJprKy0hhjTCQSMT6fz6xbt86t6ezsNI7jmBdeeMEYY0xLS4tJSkoyZWVlbs3x48fNkCFDTHl5uTHGmAMHDhhJpqamxq2prq42ksyHH35ojDFmy5YtZsiQIeb48eNuzeuvv268Xq8JBoP96n8wGDSS+l1/IR0dHaa9vd1EIpHL2g4AIPFZdY46GAxKkjIyMiRJhw8fVlNTkwoLC90ar9er6dOna8eOHZKk2tpadXV1RdXk5OQoLy/PramurpbjOJoyZYpbM3XqVDmOE1WTl5ennJwct2b27NkKhUKqra3ts7+hUEitra1RS6wYXnMJAJBFF5MZY/Too4/qtttuU15eniSpqalJkpSdnR1Vm52d7bY1NTUpOTlZ6enpF63Jysrq9Z1ZWVlRNT2/Jz09XcnJyW5NT6Wlpe45b8dxNHr06Evd7QsiqAEAkkVBXVxcrL179+r111/v1ebxeKI+G2N6reupZ01f9QOp+bRVq1YpGAy6y9GjRy/aJwAALpUVQb1s2TK9+eab2r59u0aNGuWu9/l8ktRrRtvc3OzOfn0+n8LhsAKBwEVrTpw40et7T548GVXT83sCgYC6urp6zbTP83q9Gj58eNQSC8YYRSIRRSKRmGwPAJC44hrUxhgVFxdr06ZN2rZtm3Jzc6Pac3Nz5fP5VFFR4a4Lh8OqrKzUtGnTJEn5+flKSkqKqmlsbFR9fb1bU1BQoGAwqF27drk1O3fuVDAYjKqpr69XY2OjW7N161Z5vV7l5+fHfuc/w32v9n1eHAAwuAyN55c//PDDeu211/Sb3/xGaWlp7ozWcRylpKTI4/GopKREa9eu1dixYzV27FitXbtWV199tRYtWuTW3n///VqxYoWuvfZaZWRkaOXKlZo4caLuvPNOSdL48eM1Z84cLV26VC+++KIk6YEHHlBRUZHGjRsnSSosLNSECRPk9/v19NNP6/Tp01q5cqWWLl0as5nypbn4oX0AwCARp6vNjTl3pVSfyyuvvOLWRCIRs3r1auPz+YzX6zW333672bdvX9R2zpw5Y4qLi01GRoZJSUkxRUVFpqGhIarm1KlTZvHixSYtLc2kpaWZxYsXm0AgEFVz5MgRM2/ePJOSkmIyMjJMcXGx6ezs7Pf+xOr2rPb2drPwh9tMOBy+rO0AABKfxxguLY6V1tZWOY6jYDB4WbPwjo4OffOnu/T/fec2JSUlxbCHAIBEY8XFZAAAoG8ENQAAFiOoAQCwGEFtKe6jBgBIBDUAAFYjqAEAsBhBDQCAxQhqAAAsRlBbyvCaSwCACGprEdQAAImgthZBDQCQCGoAAKxGUAMAYDGCGgAAixHUAABYjKAGAMBiBLWluOobACAR1AAAWI2gBgDAYgQ1AAAWI6gBALAYQQ0AgMUIaktx1TcAQCKorUVQAwAkghoAAKsR1AAAWIygBgDAYgQ1AAAWI6gtxcVkAACJoAYAwGoENQAAFiOoAQCwGEENAIDFCGoAACw2oKC+4YYbdOrUqV7rW1padMMNN1x2pwAAwDkDCuqPP/5Y3d3dvdaHQiEdP378sjsFAADOGXopxW+++ab75//8z/+U4zju5+7ubr3zzju6/vrrY9Y5AAAGu0sK6oULF0qSPB6PlixZEtWWlJSk66+/Xs8880zMOgcAwGB3SUEdiUQkSbm5udq9e7cyMzOvSKcAAMA5lxTU5x0+fDjW/QAAAH0YUFBL0jvvvKN33nlHzc3N7kz7vJ/97GeX3TEAADDAoH7iiSf05JNPavLkyRo5cqQ8Hk+s+wUAADTAoH7hhRf06quvyu/3x7o/AADgUwZ0H3U4HNa0adNi3RcAANDDgIL67/7u7/Taa6/Fui8AAKCHAR367uzs1EsvvaS3335bt9xyi5KSkqLa169fH5POAQAw2A0oqPfu3auvfOUrkqT6+vqoNi4sAwAgdgYU1Nu3b491PwAAQB94zSUAABYb0Iz6a1/72kUPcW/btm3AHQIAAP9jQEF9/vz0eV1dXaqrq1N9fX2vl3UAAICBG1BQ/+AHP+hz/Zo1a9Te3n5ZHQIAAP8jpueov/nNb/KcbwAAYiimQV1dXa1hw4bFcpMAAAxqAzr0fffdd0d9NsaosbFR77//vr73ve/FpGMAAGCAQe04TtTnIUOGaNy4cXryySdVWFgYk44BAIABBvUrr7wS634AAIA+DCioz6utrdXBgwfl8Xg0YcIE/fmf/3ms+gUAADTAoG5ubtY3vvENvfvuu7rmmmtkjFEwGNTXvvY1lZWVacSIEbHu56BjjJExJt7dAADE2YCu+l62bJlaW1u1f/9+nT59WoFAQPX19WptbdXy5cv7vZ333ntP8+fPV05Ojjwej954442o9vvuu08ejydqmTp1alRNKBTSsmXLlJmZqdTUVC1YsEDHjh2LqgkEAvL7/XIcR47jyO/3q6WlJaqmoaFB8+fPV2pqqjIzM7V8+XKFw+FLGhcAAGJtQEFdXl6u559/XuPHj3fXTZgwQc8995zeeuutfm+no6NDkyZN0oYNGy5YM2fOHDU2NrrLli1botpLSkq0efNmlZWVqaqqSu3t7SoqKlJ3d7dbs2jRItXV1am8vFzl5eWqq6uT3+9327u7uzVv3jx1dHSoqqpKZWVl2rhxo1asWNHvfQEA4EoY0KHvSCTS6x3UkpSUlKRIJNLv7cydO1dz5869aI3X65XP5+uzLRgM6uWXX9YvfvEL3XnnnZKkX/7ylxo9erTefvttzZ49WwcPHlR5eblqamo0ZcoUSdJPfvITFRQU6KOPPtK4ceO0detWHThwQEePHlVOTo4k6ZlnntF9992nf/7nf9bw4cP7vU8AAMTSgGbUM2bM0COPPKI//vGP7rrjx4/r7//+7zVz5syYdU6S3n33XWVlZenmm2/W0qVL1dzc7LbV1taqq6sr6pawnJwc5eXlaceOHZLOPYTFcRw3pCVp6tSpchwnqiYvL88NaUmaPXu2QqGQamtrY7o/l4Lz1ACAAQX1hg0b1NbWpuuvv1433nijbrrpJuXm5qqtrU0/+tGPYta5uXPn6le/+pW2bdumZ555Rrt379aMGTMUCoUkSU1NTUpOTlZ6enrUz2VnZ6upqcmtycrK6rXtrKysqJrs7Oyo9vT0dCUnJ7s1fQmFQmptbY1aAACIpQEd+h49erQ++OADVVRU6MMPP5QxRhMmTHAPP8fKPffc4/45Ly9PkydP1pgxY/Tb3/6219PRPs0YE/Uazr5eyTmQmp5KS0v1xBNPfOZ+AAAwUJc0o962bZsmTJjgzhxnzZqlZcuWafny5br11lv15S9/Wb/73e+uSEclaeTIkRozZowOHTokSfL5fAqHwwoEAlF1zc3N7gzZ5/PpxIkTvbZ18uTJqJqeM+dAIKCurq5eM+1PW7VqlYLBoLscPXr0svbv0zjsDQCQLjGof/jDH2rp0qV9XlzlOI6+/e1va/369THrXE+nTp3S0aNHNXLkSElSfn6+kpKSVFFR4dY0Njaqvr5e06ZNkyQVFBQoGAxq165dbs3OnTsVDAajaurr69XY2OjWbN26VV6vV/n5+Rfsj9fr1fDhw6MWAABi6ZKC+r/+6780Z86cC7YXFhZe0sVX7e3tqqurU11dnSTp8OHDqqurU0NDg9rb27Vy5UpVV1fr448/1rvvvqv58+crMzNTf/3Xfy3p3C8H999/v1asWKF33nlHe/bs0Te/+U1NnDjRPQw/fvx4zZkzR0uXLlVNTY1qamq0dOlSFRUVady4cW6/J0yYIL/frz179uidd97RypUrL/hLCQAAnxtzCbxerzl06NAF2w8dOmSGDRvW7+1t377dSOq1LFmyxHzyySemsLDQjBgxwiQlJZnrrrvOLFmyxDQ0NERt48yZM6a4uNhkZGSYlJQUU1RU1Kvm1KlTZvHixSYtLc2kpaWZxYsXm0AgEFVz5MgRM2/ePJOSkmIyMjJMcXGx6ezs7Pe+GGNMMBg0kkwwGLykn+upvb3dzPrnfzenT582kUjksrYFAEhsHmP6fyL0xhtv1L/8y7+4M9qeNm3apJUrV+oPf/hDDH6FSDytra1yHEfBYPCyZuIdHR3662e369cP/S9dc801F72gDQDwxXZJh77/6q/+Sv/0T/+kzs7OXm1nzpzR6tWrVVRUFLPOAQAw2F3S7Vn/+I//qE2bNunmm29WcXGxxo0bJ4/Ho4MHD+q5555Td3e3Hn/88SvVVwAABp1LCurs7Gzt2LFDDz30kFatWuXePuTxeDR79mz9+Mc/vujtTLg05r9v0eLQNwAMXpf8wJMxY8Zoy5YtCgQC+v3vfy9jjMaOHdvr6WAAAODyDejJZNK5R2zeeuutsewLAADoYUDP+gYAAJ8PgtpCxhjx8FAAgERQAwBgNYIaAACLEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKC21Pl3UQMABjeCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqi3GLFgCAoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUFuKK74BABJBDQCA1QhqAAAsRlBbjMPfAACCGgAAixHUlopEIopEIsyoAWCQI6gt9sDr9fHuAgAgzghqixkjZtQAMMgR1AAAWIygtlQkEpHEbBoABjuCGgAAixHUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqi/FSDgAAQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoLcZ91AAAgtpiBDUAgKAGAMBiBDUAABYjqAEAsFhcg/q9997T/PnzlZOTI4/HozfeeCOq3RijNWvWKCcnRykpKbrjjju0f//+qJpQKKRly5YpMzNTqampWrBggY4dOxZVEwgE5Pf75TiOHMeR3+9XS0tLVE1DQ4Pmz5+v1NRUZWZmavny5QqHw1dit/uNc9QAgLgGdUdHhyZNmqQNGzb02f7UU09p/fr12rBhg3bv3i2fz6dZs2apra3NrSkpKdHmzZtVVlamqqoqtbe3q6ioSN3d3W7NokWLVFdXp/LycpWXl6uurk5+v99t7+7u1rx589TR0aGqqiqVlZVp48aNWrFixZXbeQAA+sNYQpLZvHmz+zkSiRifz2fWrVvnruvs7DSO45gXXnjBGGNMS0uLSUpKMmVlZW7N8ePHzZAhQ0x5ebkxxpgDBw4YSaampsatqa6uNpLMhx9+aIwxZsuWLWbIkCHm+PHjbs3rr79uvF6vCQaD/d6HYDBoJF3Sz/Slra3N3L56o5nzf7aYjo6Oy9oWACCxWXuO+vDhw2pqalJhYaG7zuv1avr06dqxY4ckqba2Vl1dXVE1OTk5ysvLc2uqq6vlOI6mTJni1kydOlWO40TV5OXlKScnx62ZPXu2QqGQamtrL9jHUCik1tbWqAUAgFiyNqibmpokSdnZ2VHrs7Oz3bampiYlJycrPT39ojVZWVm9tp+VlRVV0/N70tPTlZyc7Nb0pbS01D3v7TiORo8efYl7eXGGc9QAMOhZG9TneTyeqM/GmF7reupZ01f9QGp6WrVqlYLBoLscPXr0ov0CAOBSWRvUPp9PknrNaJubm93Zr8/nUzgcViAQuGjNiRMnem3/5MmTUTU9vycQCKirq6vXTPvTvF6vhg8fHrUAABBL1gZ1bm6ufD6fKioq3HXhcFiVlZWaNm2aJCk/P19JSUlRNY2Njaqvr3drCgoKFAwGtWvXLrdm586dCgaDUTX19fVqbGx0a7Zu3Sqv16v8/Pwrup8AAFzM0Hh+eXt7u37/+9+7nw8fPqy6ujplZGTouuuuU0lJidauXauxY8dq7NixWrt2ra6++motWrRIkuQ4ju6//36tWLFC1157rTIyMrRy5UpNnDhRd955pyRp/PjxmjNnjpYuXaoXX3xRkvTAAw+oqKhI48aNkyQVFhZqwoQJ8vv9evrpp3X69GmtXLlSS5cuZZYMAIiveF5yvn37diOp17JkyRJjzLlbtFavXm18Pp/xer3m9ttvN/v27YvaxpkzZ0xxcbHJyMgwKSkppqioyDQ0NETVnDp1yixevNikpaWZtLQ0s3jxYhMIBKJqjhw5YubNm2dSUlJMRkaGKS4uNp2dnZe0P7G+PWv2ut+a9vb2y9oWACCxeYzhsuJYaW1tleM4CgaDlzUTb29v17x/2aqUlGHaWDxdqampMewlACCRWHuOGgAAENQAAFiNoLaY4YEnADDoEdQAAFiMoAYAwGIENQAAFiOoAQCwGEENAIDFCGoAACxGUAMAYDGCGgAAixHUAABYjKC2GE8mAwAQ1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYLaYtxHDQAgqC10LpwJaAAAQQ0AgNUIagAALEZQAwBgMYIaAACLEdQAAFiMoAYAwGIENQAAFiOoLcYDTwAABDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALAYQQ0AgMUIagAALEZQAwBgMYIaAACLEdQAAFiMoLYY76MGABDUAABYjKAGAMBiBDUAABYjqC0WiUQUiUTi3Q0AQBwR1BbjYjIAAEFtMWOMIpEIYQ0AgxhBbTFm1AAAghoAAIsR1JZjVg0AgxtBbaHzwWyMUXd3t7q7u+PcIwBAvBDUlvt2WT0zagAYxAhq63ni3QEAQBwR1JbjHDUADG5WB/WaNWvk8XiiFp/P57YbY7RmzRrl5OQoJSVFd9xxh/bv3x+1jVAopGXLlikzM1OpqalasGCBjh07FlUTCATk9/vlOI4cx5Hf71dLS8vnsYsAAFyU1UEtSV/+8pfV2NjoLvv27XPbnnrqKa1fv14bNmzQ7t275fP5NGvWLLW1tbk1JSUl2rx5s8rKylRVVaX29nYVFRVFXaC1aNEi1dXVqby8XOXl5aqrq5Pf7/9c9xMAgL4MjXcHPsvQoUOjZtHnGWP0wx/+UI8//rjuvvtuSdLPf/5zZWdn67XXXtO3v/1tBYNBvfzyy/rFL36hO++8U5L0y1/+UqNHj9bbb7+t2bNn6+DBgyovL1dNTY2mTJkiSfrJT36igoICffTRRxo3btznt7N94HnfADC4WT+jPnTokHJycpSbm6tvfOMb+sMf/iBJOnz4sJqamlRYWOjWer1eTZ8+XTt27JAk1dbWqqurK6omJydHeXl5bk11dbUcx3FDWpKmTp0qx3HcGgAA4sXqGfWUKVP0b//2b7r55pt14sQJff/739e0adO0f/9+NTU1SZKys7OjfiY7O1tHjhyRJDU1NSk5OVnp6em9as7/fFNTk7Kysnp9d1ZWlltzIaFQSKFQyP3c2tp66TsJAMBFWB3Uc+fOdf88ceJEFRQU6MYbb9TPf/5zTZ06VZLk8UTfvmSM6bWup541fdX3ZzulpaV64oknPnM/LgdXfQPA4Gb9oe9PS01N1cSJE3Xo0CH3vHXPWW9zc7M7y/b5fAqHwwoEAhetOXHiRK/vOnnyZK/Zek+rVq1SMBh0l6NHjw543wAA6EtCBXUoFNLBgwc1cuRI5ebmyufzqaKiwm0Ph8OqrKzUtGnTJEn5+flKSkqKqmlsbFR9fb1bU1BQoGAwqF27drk1O3fuVDAYdGsuxOv1avjw4VFLrDGjBoDBzepD3ytXrtT8+fN13XXXqbm5Wd///vfV2tqqJUuWyOPxqKSkRGvXrtXYsWM1duxYrV27VldffbUWLVokSXIcR/fff79WrFiha6+9VhkZGVq5cqUmTpzoXgU+fvx4zZkzR0uXLtWLL74oSXrggQdUVFQU9yu+JYIaAAY7q4P62LFjuvfee/WnP/1JI0aM0NSpU1VTU6MxY8ZIkv7hH/5BZ86c0Xe+8x0FAgFNmTJFW7duVVpamruNH/zgBxo6dKj+9m//VmfOnNHMmTP16quv6qqrrnJrfvWrX2n58uXu1eELFizQhg0bPt+dvQBuzwKAwc1jmK7FTGtrqxzHUTAYvKzD4MFgUAvWv62IiWjYsGHaWDz9ihxWBwDYL6HOUQMAMNgQ1AAAWIygBgDAYgS15bjqGwAGN4Laclz1DQCDG0ENAIDFCGrLMaMGgMGNoAYAwGIEteWYUQPA4EZQAwBgMYLacudvz+IWLQAYnAjqBPDgr/fHuwsAgDghqBOCJ94dAADECUGdADj0DQCDF0ENAIDFCOoEwIwaAAYvgjoBcC81AAxeBHUCYEYNAIMXQW0hY4xMz88ENQAMSgQ1AAAWI6gTwNmzZ3X27Nl4dwMAEAcEdQLgYjIAGLwI6gTAOWoAGLwIagAALEZQJwBm1AAweBHUAABYjKBOAMyoAWDwIqgTAEENAIMXQZ0AuD0LAAYvgjoBnA9qZtUAMPgQ1AnAGKNvl9XHuxsAgDggqBOGJ94dAADEAUGdIDhPDQCDE0GdIAhqABicCGoAACxGUCcIZtQAMDgR1AmCh54AwOBEUCcIZtQAMDgR1Amiq6tLXV1dzKoBYJAhqBNEOByW/2e7dPbs2Xh3BQDwOSKoE8S5c9RiRg0AgwxBnUA6OzvV2dkZ724AAD5HBHUCCYfDCofDzKoBYBAhqBNIJBLR/b+sU3d3d7y7AgD4nBDUFjo3Y+571hyJGG7TAoBBhKBOMDz4BAAGF4I6wfDgEwAYXAjqBENQA8DgQlADAGAxgjrBcI4aAAYXgjrBhEIhhUIhwhoABgmCOsF0d3dryavvKxwOx7srAIDPAUGdgM6e7eblHAAwSBDUCej8Ky8BAF98BHUC6u7uVigUIqwBYBAgqBNQd3e37vt5rfuCDi4sA4AvLoI6QX3yyRmdPHlSX//xe/HuCgDgCiKoE1QkEtH/88punTnTqVAoFO/uAACuEII6gRkjtbW1KRAIcL4aAL6gCOoEZ4yR/2e79Mknn3CuGgC+gAjqHn784x8rNzdXw4YNU35+vn73u9/Fu0ufKRzu0td//J7a2toUiUQIbAD4AiGoP+XXv/61SkpK9Pjjj2vPnj36y7/8S82dO1cNDQ2faz8GErRnznRqwQ8qNP+Zrers7CSsAeALwmP4P7prypQp+upXv6rnn3/eXTd+/HgtXLhQpaWln/nzra2tchxHwWBQw4cPH3A/Tp8+rYXPbut32Ho8nqhaj0d6/YFpuvbaa5WUlBRV19c/AQD2GhrvDtgiHA6rtrZW3/3ud6PWFxYWaseOHX3+zPkXZJwXDAYlnQvsy9Ha2qqzoY4BB7Uk/c2zW3vVpQxL0c/+3yl65P8/oFfvL9BVV111Wf0EgMEolpOctLS0z9weQf3f/vSnP6m7u1vZ2dlR67Ozs9XU1NTnz5SWluqJJ57otX706NFXpI+xcMP/PvfPa/8hvv0AAKhfR2AJ6h56/mZjjLngbzurVq3So48+6n6ORCI6ffq0rr322pj9xtXa2qrRo0fr6NGjl3U4HecwnrHFeMYeYxpbto9nWlraZ9YQ1P8tMzNTV111Va/Zc3Nzc69Z9nler1derzdq3TXXXHNF+jd8+HAr/5IlKsYzthjP2GNMYyuRx5Orvv9bcnKy8vPzVVFREbW+oqJC06ZNi1OvAACDHTPqT3n00Ufl9/s1efJkFRQU6KWXXlJDQ4MefPDBeHcNADBIEdSfcs899+jUqVN68skn1djYqLy8PG3ZskVjxoyJW5+8Xq9Wr17d6xA7BobxjC3GM/YY09j6Iown91EDAGAxzlEDAGAxghoAAIsR1AAAWIygBgDAYgS1xRLxlZu2eO+99zR//nzl5OTI4/HojTfeiGo3xmjNmjXKyclRSkqK7rjjDu3fvz8+nU0ApaWluvXWW5WWlqasrCwtXLhQH330UVQNY9p/zz//vG655Rb3IRwFBQV666233HbG8vKUlpbK4/GopKTEXZfIY0pQW8qWV24mqo6ODk2aNEkbNmzos/2pp57S+vXrtWHDBu3evVs+n0+zZs1SW1vb59zTxFBZWamHH35YNTU1qqio0NmzZ1VYWKiOjg63hjHtv1GjRmndunV6//339f7772vGjBm666673OBgLAdu9+7deumll3TLLbdErU/oMTWw0l/8xV+YBx98MGrdn/3Zn5nvfve7cepR4pJkNm/e7H6ORCLG5/OZdevWues6OzuN4zjmhRdeiEMPE09zc7ORZCorK40xjGkspKenm5/+9KeM5WVoa2szY8eONRUVFWb69OnmkUceMcYk/t9PZtQWOv/KzcLCwqj1F3vlJvrv8OHDampqihpfr9er6dOnM779dP6VrhkZGZIY08vR3d2tsrIydXR0qKCggLG8DA8//LDmzZunO++8M2p9oo8pTyaz0EBeuYn+Oz+GfY3vkSNH4tGlhGKM0aOPPqrbbrtNeXl5khjTgdi3b58KCgrU2dmpL33pS9q8ebMmTJjgBgdjeWnKysr0wQcfaPfu3b3aEv3vJ0FtsUt55SYuHeM7MMXFxdq7d6+qqqp6tTGm/Tdu3DjV1dWppaVFGzdu1JIlS1RZWem2M5b9d/ToUT3yyCPaunWrhg0bdsG6RB1TDn1baCCv3ET/+Xw+SWJ8B2DZsmV68803tX37do0aNcpdz5heuuTkZN10002aPHmySktLNWnSJD377LOM5QDU1taqublZ+fn5Gjp0qIYOHarKykr967/+q4YOHeqOW6KOKUFtIV65eWXl5ubK5/NFjW84HFZlZSXjewHGGBUXF2vTpk3atm2bcnNzo9oZ08tnjFEoFGIsB2DmzJnat2+f6urq3GXy5MlavHix6urqdMMNNyT2mMbvOjZcTFlZmUlKSjIvv/yyOXDggCkpKTGpqanm448/jnfXEkJbW5vZs2eP2bNnj5Fk1q9fb/bs2WOOHDlijDFm3bp1xnEcs2nTJrNv3z5z7733mpEjR5rW1tY499xODz30kHEcx7z77rumsbHRXT755BO3hjHtv1WrVpn33nvPHD582Ozdu9c89thjZsiQIWbr1q3GGMYyFj591bcxiT2mBLXFnnvuOTNmzBiTnJxsvvrVr7q3wuCzbd++3UjqtSxZssQYc+52jdWrVxufz2e8Xq+5/fbbzb59++LbaYv1NZaSzCuvvOLWMKb9961vfcv9b3vEiBFm5syZbkgbw1jGQs+gTuQx5TWXAABYjHPUAABYjKAGAMBiBDUAABYjqAEAsBhBDQCAxQhqAAAsRlADAGAxghoAAIsR1AAAWIygBgDAYgQ1AAAWI6gBALDY/wU1PJRvIVKknAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/home/jonathan/anaconda3/envs/fdiff/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", + " with pd.option_context('mode.use_inf_as_na', True):\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(6):\n", + " sns.displot(X_norm[:, :, i].flatten())\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000],\n", + " [1.0000]])" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_norm.std(dim=0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index 4e8992d..d234538 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -12,7 +12,7 @@ from fdiff.utils.dataclasses import collate_batch from fdiff.utils.fourier import dft -from fdiff.utils.preprocessing import mimic_preprocess +from fdiff.utils.preprocessing import mimic_preprocess, nasdaq_preprocess class DiffusionDataset(Dataset): @@ -329,3 +329,58 @@ def download_data(self) -> None: @property def dataset_name(self) -> str: return "mimiciii" + + +class NASDAQDatamodule(Datamodule): + def __init__( + self, + data_dir: Path | str = Path.cwd() / "data", + random_seed: int = 42, + batch_size: int = 32, + fourier_transform: bool = False, + standardize: bool = False, + ) -> None: + super().__init__( + data_dir=data_dir, + random_seed=random_seed, + batch_size=batch_size, + fourier_transform=fourier_transform, + standardize=standardize, + ) + + def setup(self, stage: str = "fit") -> None: + if ( + not (self.data_dir / "X_train.pt").exists() + or not (self.data_dir / "X_test.pt").exists() + ): + logging.info( + f"Preprocessed tensors for {self.dataset_name} not found. " + f"Now running the preprocessing pipeline." + ) + nasdaq_preprocess(data_dir=self.data_dir, random_seed=self.random_seed) + logging.info( + f"Preprocessing pipeline finished, tensors saved in {self.data_dir}." + ) + + # Load preprocessed tensors + self.X_train = torch.load(self.data_dir / "X_train.pt") + self.X_test = torch.load(self.data_dir / "X_test.pt") + + assert isinstance(self.X_train, torch.Tensor) + assert isinstance(self.X_test, torch.Tensor) + assert self.X_train.shape[1:] == self.X_test.shape[1:] == (252, 6) + + self.X_train = self.X_train[:, :, :-1] + self.X_test = self.X_test[:, :, :-1] + + def download_data(self) -> None: + import kaggle + + kaggle.api.authenticate() + kaggle.api.dataset_download_files( + "jacksoncrow/stock-market-dataset", path=self.data_dir, unzip=True + ) + + @property + def dataset_name(self) -> str: + return "nasdaq" diff --git a/src/fdiff/utils/preprocessing.py b/src/fdiff/utils/preprocessing.py index b218204..ff63fa9 100644 --- a/src/fdiff/utils/preprocessing.py +++ b/src/fdiff/utils/preprocessing.py @@ -4,6 +4,7 @@ import pandas as pd import torch from einops import rearrange +from tqdm import tqdm def mimic_imputer(df: pd.DataFrame) -> pd.DataFrame: @@ -84,7 +85,7 @@ def mimic_preprocess(data_dir: Path, random_seed: int, train_frac: float = 0.8) Saves the preprocessed data as .pt files in the same directory. Args: - data_dir (Path): Path in which the raw "all_hourly_data.h5 file is stored. + data_dir (Path): Path in which the raw "all_hourly_data.h5" file is stored. """ dataset_path = data_dir / "all_hourly_data.h5" GAP_TIME = 6 # In hours @@ -177,3 +178,81 @@ def mimic_preprocess(data_dir: Path, random_seed: int, train_frac: float = 0.8) # Save the preprocessed tensors. for X, name in zip([X_train, X_test], ["train", "test"]): torch.save(X, data_dir / f"X_{name}.pt") + + +def nasdaq_preprocess( + data_dir: Path, + random_seed: int, + train_frac: float = 0.9, + start_date: str = "2019-01-01", + end_date: str = "2020-01-01", +) -> None: + """Preprocess the NASDAQ dataset from the raw .csv file in data_dir. + Saves the preprocessed data as .pt files in the same directory. + + Args: + data_dir (Path): Path in which the raw financial data is stored. + """ + + # Collate all stock data into a single dataframe + df_list = [] + stock_paths = list((data_dir / "stocks").glob("*.csv")) + for path in tqdm( + stock_paths, unit="stock", leave=False, desc="Loading stock data", colour="blue" + ): + df_stock = pd.read_csv(path) + df_stock["Name"] = path.stem.strip(".csv") + df_list.append(df_stock) + df = pd.concat(df_list, axis=0, ignore_index=True) + + # Check that all the stocks have been recorded + assert len(df["Name"].unique()) == len(stock_paths) + + # Convert date column to datetime + df["Date"] = pd.to_datetime(df["Date"]) + + start_time = pd.to_datetime(start_date) + end_time = pd.to_datetime(end_date) + + # Remove stocks that are not active in the whole time interval + stocks_older_than_start = set() + stocks_active_in_end = set() + for stock, valid in (df.groupby("Name")["Date"].min() <= start_time).items(): + if valid: + stocks_older_than_start.add(stock) + for stock, valid in (df.groupby("Name")["Date"].max() >= end_time).items(): + if valid: + stocks_active_in_end.add(stock) + valid_stocks = stocks_older_than_start.intersection(stocks_active_in_end) + df = df[ + df["Name"].isin(valid_stocks) + & (df["Date"] >= start_time) + & (df["Date"] < end_time) + ] + + # Remove stocks with missing days + stocks_no_missing_day = set() + for stock, valid in (df.groupby("Name")["Date"].nunique() == 252).items(): + if valid: + stocks_no_missing_day.add(stock) + df = df[df["Name"].isin(stocks_no_missing_day)] + + # Create a tensor of shape (num_stocks, num_days, num_features) from df + df_pivot = df.pivot_table( + index="Name", + columns="Date", + values=["Open", "High", "Low", "Close", "Adj Close", "Volume"], # type: ignore + ) + X = torch.tensor(df_pivot.values, dtype=torch.float32) + X = rearrange(X, "stock (feature day) -> stock day feature", day=252) + + # Train-test split + torch.manual_seed(random_seed) + num_train = int(train_frac * len(X)) + perm_idx = torch.randperm(len(X)) + train_stocks, test_stocks = perm_idx[:num_train], perm_idx[num_train:] + X_train, X_test = X[train_stocks], X[test_stocks] + + # Save the preprocessed tensors. + for X, name in zip([X_train, X_test], ["train", "test"]): + torch.save(X, data_dir / f"X_{name}.pt") From e557b0f40cc1fe89762ba4df864dbc4ab055c3c2 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Tue, 2 Jan 2024 20:33:55 +0100 Subject: [PATCH 17/18] Add a few comments for NASDAQ datamodule --- notebooks/nasdaq_exploration.ipynb | 56 ++++++++++++++++++++++++++++ src/fdiff/dataloaders/datamodules.py | 1 + 2 files changed, 57 insertions(+) diff --git a/notebooks/nasdaq_exploration.ipynb b/notebooks/nasdaq_exploration.ipynb index 78e8f57..720cdcb 100644 --- a/notebooks/nasdaq_exploration.ipynb +++ b/notebooks/nasdaq_exploration.ipynb @@ -1276,6 +1276,62 @@ "X_norm.std(dim=0)" ] }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Date 2019-12-31 00:00:00\n", + "Open 4712.0\n", + "High 4743.709961\n", + "Low 4651.029785\n", + "Close 4699.0\n", + "Adj Close 4688.308594\n", + "Volume 432720700.0\n", + "Name ZYXI\n", + "dtype: object" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.max()" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Date 2019-01-02 00:00:00\n", + "Open 0.004\n", + "High 0.004\n", + "Low 0.0003\n", + "Close 0.003\n", + "Adj Close 0.003\n", + "Volume 0.0\n", + "Name A\n", + "dtype: object" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.min()" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/fdiff/dataloaders/datamodules.py b/src/fdiff/dataloaders/datamodules.py index d234538..18fa534 100644 --- a/src/fdiff/dataloaders/datamodules.py +++ b/src/fdiff/dataloaders/datamodules.py @@ -370,6 +370,7 @@ def setup(self, stage: str = "fit") -> None: assert isinstance(self.X_test, torch.Tensor) assert self.X_train.shape[1:] == self.X_test.shape[1:] == (252, 6) + # Filter out the last feature (volume) due to awkward scaling self.X_train = self.X_train[:, :, :-1] self.X_test = self.X_test[:, :, :-1] From 6e1b719bc693c58343de6c2528f23cf9245c6c63 Mon Sep 17 00:00:00 2001 From: JonathanCrabbe Date: Mon, 8 Jan 2024 12:07:13 +0000 Subject: [PATCH 18/18] Add spectral density calculation --- notebooks/results.ipynb | 885 +++++++++++++++++++++++++++++++++++++ src/fdiff/utils/fourier.py | 37 ++ 2 files changed, 922 insertions(+) create mode 100644 notebooks/results.ipynb diff --git a/notebooks/results.ipynb b/notebooks/results.ipynb new file mode 100644 index 0000000..900af59 --- /dev/null +++ b/notebooks/results.ipynb @@ -0,0 +1,885 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from yaml import safe_load\n", + "from itertools import product\n", + "from pathlib import Path\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import warnings\n", + "import torch\n", + "import math\n", + "\n", + "from fdiff.utils.fourier import spectral_density\n", + "from einops import rearrange\n", + "\n", + "warnings.simplefilter(\"ignore\", (UserWarning, FutureWarning))" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def infer_dataset(datamodule: str) -> str:\n", + " if \"ECG\" in datamodule:\n", + " return \"ECG\"\n", + " if \"MIMICIII\" in datamodule:\n", + " return \"MIMIC-III\"\n", + " if \"NASDAQ\" in datamodule:\n", + " return \"NASDAQ-2019\"\n", + " \n", + "def infer_diffusion_domain(fourier_transform: bool) -> str:\n", + " if fourier_transform:\n", + " return \"Frequency\"\n", + " else:\n", + " return \"Time\" \n", + "\n", + "def calculate_metrics(results: dict) -> list[dict]:\n", + " data = []\n", + " for domain, method in product({\"time\", \"freq\"}, {\"sliced\", \"marginal\"}):\n", + " all_distances = results[f\"{domain}_{method}_wasserstein_all\"] \n", + " data.extend([{\n", + " \"Value\": distance, \n", + " \"Metric Domain\": \"Frequency\" if domain == \"freq\" else \"Time\",\n", + " \"Metric\": \"Sliced Wasserstein\" if method == \"sliced\" else \"Marginal Wasserstein\",\n", + " } for distance in all_distances])\n", + " return data \n", + "\n", + "def calculate_spectral_density(marginal_distances: list[float], dataset_name: str) -> list[float]:\n", + " match dataset_name:\n", + " case \"ECG\":\n", + " max_len = 187\n", + " case \"NASDAQ-2019\":\n", + " max_len = 252\n", + " case \"MIMIC-III\":\n", + " max_len = 24\n", + " case _:\n", + " raise ValueError(\"Dataset not recognized\")\n", + " marginals_tensor = torch.tensor(marginal_distances)\n", + " marginals_tensor = rearrange(marginals_tensor, \"(max_len n_channels) -> 1 max_len n_channels\", max_len =max_len)\n", + " \n", + " # Extract real and imaginary parts\n", + " n_real = math.ceil((max_len + 1) / 2)\n", + " x_re = marginals_tensor[:, :n_real, :]\n", + " x_im = marginals_tensor[:, n_real:, :]\n", + "\n", + " # Create imaginary tensor\n", + " zero_padding = torch.zeros(size=(marginals_tensor.size(0), 1, marginals_tensor.size(2)))\n", + " x_im = torch.cat((zero_padding, x_im), dim=1)\n", + "\n", + " # If number of time steps is even, put the null imaginary part\n", + " if max_len % 2 == 0:\n", + " x_im = torch.cat((x_im, zero_padding), dim=1)\n", + "\n", + " assert (\n", + " x_im.size() == x_re.size()\n", + " ), f\"The real and imaginary parts should have the same shape, got {x_re.size()} and {x_im.size()} instead.\"\n", + "\n", + " return (x_re + x_im).mean(dim=2).flatten().tolist()\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "run_list = [\"xxqse6xu\", \"na9xdfui\", \"c95j8zv7\", \"nzaxqmaz\", \"bf3lrfx9\", \"emk7nyz3\"]\n", + "runs_dir = Path.cwd() / \"../lightning_logs/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ValueMetric DomainMetricDatasetDiffusion Domain
0822.014838FrequencyMarginal WassersteinNASDAQ-2019Frequency
1803.654591FrequencyMarginal WassersteinNASDAQ-2019Frequency
2793.181182FrequencyMarginal WassersteinNASDAQ-2019Frequency
3812.451547FrequencyMarginal WassersteinNASDAQ-2019Frequency
4817.057671FrequencyMarginal WassersteinNASDAQ-2019Frequency
\n", + "
" + ], + "text/plain": [ + " Value Metric Domain Metric Dataset \\\n", + "0 822.014838 Frequency Marginal Wasserstein NASDAQ-2019 \n", + "1 803.654591 Frequency Marginal Wasserstein NASDAQ-2019 \n", + "2 793.181182 Frequency Marginal Wasserstein NASDAQ-2019 \n", + "3 812.451547 Frequency Marginal Wasserstein NASDAQ-2019 \n", + "4 817.057671 Frequency Marginal Wasserstein NASDAQ-2019 \n", + "\n", + " Diffusion Domain \n", + "0 Frequency \n", + "1 Frequency \n", + "2 Frequency \n", + "3 Frequency \n", + "4 Frequency " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_list = []\n", + "for run in run_list:\n", + " with open(runs_dir / f\"{run}/train_config.yaml\", \"r\") as f:\n", + " config = safe_load(f)\n", + " dataset = infer_dataset(config[\"datamodule\"][\"_target_\"])\n", + " domain = infer_diffusion_domain(config[\"fourier_transform\"])\n", + " with open(runs_dir / f\"{run}/results.yaml\", \"r\") as f:\n", + " results = safe_load(f)\n", + " df = pd.DataFrame(calculate_metrics(results))\n", + " df[\"Dataset\"] = dataset\n", + " df[\"Diffusion Domain\"] = domain\n", + " df_list.append(df)\n", + "df = pd.concat(df_list)\n", + "df.head() " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for metric in df.Metric.unique():\n", + " for dataset in df.Dataset.unique():\n", + " ax = sns.boxplot(data=df[(df.Metric == metric) & (df.Dataset == dataset)], \n", + " x=\"Metric Domain\",\n", + " y=\"Value\", \n", + " hue=\"Diffusion Domain\",\n", + " hue_order=[\"Time\", \"Frequency\"],\n", + " showfliers = False,\n", + " )\n", + " plt.title(f\"{metric} on {dataset}\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'Dataset': 'NASDAQ-2019',\n", + " 'Diffusion Domain': 'Frequency',\n", + " 'Specral Density': [809.6719970703125,\n", + " 63.1424674987793,\n", + " 41.79159164428711,\n", + " 22.867511749267578,\n", + " 20.1268367767334,\n", + " 17.066654205322266,\n", + " 15.951713562011719,\n", + " 14.6133394241333,\n", + " 13.042460441589355,\n", + " 9.046859741210938,\n", + " 10.254725456237793,\n", + " 8.590145111083984,\n", + " 10.040194511413574,\n", + " 9.318804740905762,\n", + " 6.75900411605835,\n", + " 6.458128452301025,\n", + " 7.269366264343262,\n", + " 7.896665096282959,\n", + " 6.261915683746338,\n", + " 5.675816535949707,\n", + " 5.243130683898926,\n", + " 4.324759483337402,\n", + " 4.1959943771362305,\n", + " 3.860518217086792,\n", + " 3.261601209640503,\n", + " 4.5958476066589355,\n", + " 4.237555027008057,\n", + " 2.476475477218628,\n", + " 2.710827589035034,\n", + " 2.961428642272949,\n", + " 1.9427402019500732,\n", + " 2.843383312225342,\n", + " 3.726487398147583,\n", + " 3.09312105178833,\n", + " 3.1508617401123047,\n", + " 1.9665400981903076,\n", + " 2.9506115913391113,\n", + " 3.005502223968506,\n", + " 2.503760814666748,\n", + " 2.960820436477661,\n", + " 2.429760456085205,\n", + " 3.090705156326294,\n", + " 2.3071494102478027,\n", + " 2.3879342079162598,\n", + " 1.9158885478973389,\n", + " 2.423311948776245,\n", + " 2.5870561599731445,\n", + " 2.434704542160034,\n", + " 2.3442187309265137,\n", + " 2.5126781463623047,\n", + " 1.5888726711273193,\n", + " 2.06229829788208,\n", + " 1.4203393459320068,\n", + " 2.392314910888672,\n", + " 1.4694560766220093,\n", + " 2.3350865840911865,\n", + " 2.510233163833618,\n", + " 2.150792121887207,\n", + " 2.0455429553985596,\n", + " 1.8673906326293945,\n", + " 2.1512436866760254,\n", + " 2.5633492469787598,\n", + " 2.172374963760376,\n", + " 2.224557399749756,\n", + " 2.687283754348755,\n", + " 2.134669780731201,\n", + " 1.7229011058807373,\n", + " 2.062854051589966,\n", + " 1.736673355102539,\n", + " 1.408514380455017,\n", + " 1.3901562690734863,\n", + " 1.754905343055725,\n", + " 1.630202293395996,\n", + " 1.7062526941299438,\n", + " 1.3567198514938354,\n", + " 1.4484920501708984,\n", + " 2.0163073539733887,\n", + " 1.944770097732544,\n", + " 1.7009433507919312,\n", + " 1.2830599546432495,\n", + " 1.600604772567749,\n", + " 1.260984182357788,\n", + " 1.3775780200958252,\n", + " 1.6140979528427124,\n", + " 1.5085538625717163,\n", + " 1.1868540048599243,\n", + " 1.5596669912338257,\n", + " 1.2716152667999268,\n", + " 1.3503538370132446,\n", + " 1.5247502326965332,\n", + " 1.7421257495880127,\n", + " 1.2147314548492432,\n", + " 1.4585195779800415,\n", + " 1.4786450862884521,\n", + " 1.2293903827667236,\n", + " 1.169764757156372,\n", + " 1.5330572128295898,\n", + " 1.3770751953125,\n", + " 1.5177454948425293,\n", + " 1.0411866903305054,\n", + " 1.176990270614624,\n", + " 1.5929710865020752,\n", + " 1.273655652999878,\n", + " 1.2115203142166138,\n", + " 1.465665578842163,\n", + " 1.317792296409607,\n", + " 1.2582454681396484,\n", + " 1.3971357345581055,\n", + " 1.1022088527679443,\n", + " 1.6739383935928345,\n", + " 1.2187654972076416,\n", + " 1.2316720485687256,\n", + " 1.0234462022781372,\n", + " 1.1572080850601196,\n", + " 1.2384166717529297,\n", + " 1.2634527683258057,\n", + " 0.9976008534431458,\n", + " 1.1428080797195435,\n", + " 1.0337917804718018,\n", + " 1.3488662242889404,\n", + " 0.9418430328369141,\n", + " 1.085737705230713,\n", + " 1.0547775030136108,\n", + " 1.2163989543914795,\n", + " 1.2130433320999146,\n", + " 1.1347191333770752,\n", + " 0.9655811190605164]},\n", + " {'Dataset': 'NASDAQ-2019',\n", + " 'Diffusion Domain': 'Time',\n", + " 'Specral Density': [1261.4736328125,\n", + " 51.95680618286133,\n", + " 41.13398361206055,\n", + " 25.790130615234375,\n", + " 18.712203979492188,\n", + " 20.975643157958984,\n", + " 17.1844482421875,\n", + " 15.567449569702148,\n", + " 12.564851760864258,\n", + " 9.423412322998047,\n", + " 10.37773609161377,\n", + " 9.096792221069336,\n", + " 9.860190391540527,\n", + " 9.757308959960938,\n", + " 7.608933448791504,\n", + " 7.813243865966797,\n", + " 8.650221824645996,\n", + " 8.535463333129883,\n", + " 7.369694709777832,\n", + " 8.230646133422852,\n", + " 7.339835166931152,\n", + " 6.153136253356934,\n", + " 5.889848232269287,\n", + " 6.9708099365234375,\n", + " 7.563066005706787,\n", + " 6.31140661239624,\n", + " 6.54962682723999,\n", + " 6.053887367248535,\n", + " 7.0468597412109375,\n", + " 6.462686061859131,\n", + " 6.74298095703125,\n", + " 5.807658672332764,\n", + " 6.602700710296631,\n", + " 6.496003150939941,\n", + " 6.589041233062744,\n", + " 7.3876166343688965,\n", + " 6.395558834075928,\n", + " 7.420901298522949,\n", + " 6.648940086364746,\n", + " 6.121870517730713,\n", + " 6.351550102233887,\n", + " 6.376594066619873,\n", + " 7.311514377593994,\n", + " 7.136407375335693,\n", + " 7.163454532623291,\n", + " 7.236772060394287,\n", + " 7.3302788734436035,\n", + " 6.881466865539551,\n", + " 6.64810848236084,\n", + " 7.077944755554199,\n", + " 7.153087615966797,\n", + " 7.270644187927246,\n", + " 8.164156913757324,\n", + " 6.849734306335449,\n", + " 7.577398777008057,\n", + " 7.205525875091553,\n", + " 6.967301368713379,\n", + " 7.154146671295166,\n", + " 7.437753200531006,\n", + " 7.226676940917969,\n", + " 7.3449602127075195,\n", + " 7.15991735458374,\n", + " 7.2633209228515625,\n", + " 7.161436557769775,\n", + " 7.807840824127197,\n", + " 7.677984714508057,\n", + " 7.301389217376709,\n", + " 7.373349189758301,\n", + " 7.417212009429932,\n", + " 8.060897827148438,\n", + " 8.100988388061523,\n", + " 7.697656154632568,\n", + " 7.291009426116943,\n", + " 7.513880729675293,\n", + " 7.854189395904541,\n", + " 7.318384647369385,\n", + " 7.711415767669678,\n", + " 7.976170539855957,\n", + " 7.626744270324707,\n", + " 7.643238067626953,\n", + " 8.160436630249023,\n", + " 7.620722770690918,\n", + " 8.199743270874023,\n", + " 7.824179172515869,\n", + " 8.441439628601074,\n", + " 8.00049877166748,\n", + " 7.819683074951172,\n", + " 7.916140079498291,\n", + " 8.370512008666992,\n", + " 7.7811279296875,\n", + " 7.693890571594238,\n", + " 7.649224758148193,\n", + " 7.768673896789551,\n", + " 8.313024520874023,\n", + " 7.963522911071777,\n", + " 8.055624008178711,\n", + " 8.102409362792969,\n", + " 7.7746100425720215,\n", + " 7.664437294006348,\n", + " 8.304519653320312,\n", + " 7.7104291915893555,\n", + " 8.003708839416504,\n", + " 8.62332534790039,\n", + " 8.081354141235352,\n", + " 7.896171569824219,\n", + " 8.346494674682617,\n", + " 8.024124145507812,\n", + " 8.111292839050293,\n", + " 8.588598251342773,\n", + " 7.794381618499756,\n", + " 8.038653373718262,\n", + " 8.10645580291748,\n", + " 8.184476852416992,\n", + " 7.933362007141113,\n", + " 8.029460906982422,\n", + " 8.20036792755127,\n", + " 8.01441764831543,\n", + " 8.272198677062988,\n", + " 8.270940780639648,\n", + " 8.452764511108398,\n", + " 8.323468208312988,\n", + " 8.146561622619629,\n", + " 7.995029449462891,\n", + " 7.707884788513184,\n", + " 8.093329429626465,\n", + " 8.513714790344238,\n", + " 5.611729621887207]},\n", + " {'Dataset': 'MIMIC-III',\n", + " 'Diffusion Domain': 'Frequency',\n", + " 'Specral Density': [1.1951687335968018,\n", + " 0.5400264859199524,\n", + " 0.3033008873462677,\n", + " 0.21802017092704773,\n", + " 0.17315877974033356,\n", + " 0.144281804561615,\n", + " 0.13100117444992065,\n", + " 0.11335435509681702,\n", + " 0.10602040588855743,\n", + " 0.09923595190048218,\n", + " 0.09369400888681412,\n", + " 0.09531673789024353,\n", + " 0.06422290951013565]},\n", + " {'Dataset': 'MIMIC-III',\n", + " 'Diffusion Domain': 'Time',\n", + " 'Specral Density': [29.593759536743164,\n", + " 1.3743444681167603,\n", + " 0.8783009052276611,\n", + " 0.834337592124939,\n", + " 0.8431482911109924,\n", + " 0.8516952395439148,\n", + " 0.8732492327690125,\n", + " 0.8775286078453064,\n", + " 0.8906622529029846,\n", + " 0.889417290687561,\n", + " 0.8951759934425354,\n", + " 0.9018003940582275,\n", + " 0.6377223134040833]},\n", + " {'Dataset': 'ECG',\n", + " 'Diffusion Domain': 'Time',\n", + " 'Specral Density': [0.31288382411003113,\n", + " 0.14417795836925507,\n", + " 0.07312784343957901,\n", + " 0.044816888868808746,\n", + " 0.029094424098730087,\n", + " 0.028485236689448357,\n", + " 0.02473234385251999,\n", + " 0.01725161075592041,\n", + " 0.01910686492919922,\n", + " 0.013572761788964272,\n", + " 0.018845409154891968,\n", + " 0.010211089625954628,\n", + " 0.013956103473901749,\n", + " 0.013813739642500877,\n", + " 0.012982630170881748,\n", + " 0.01045746449381113,\n", + " 0.012070002034306526,\n", + " 0.00873536802828312,\n", + " 0.007358442060649395,\n", + " 0.008154310286045074,\n", + " 0.005633534397929907,\n", + " 0.005339482799172401,\n", + " 0.008128765970468521,\n", + " 0.00561246182769537,\n", + " 0.007130319718271494,\n", + " 0.006290425546467304,\n", + " 0.005823947489261627,\n", + " 0.004996935836970806,\n", + " 0.005852000787854195,\n", + " 0.00567939318716526,\n", + " 0.004956495016813278,\n", + " 0.004763954784721136,\n", + " 0.00573704345151782,\n", + " 0.004699885379523039,\n", + " 0.005827758461236954,\n", + " 0.005510641261935234,\n", + " 0.004243083298206329,\n", + " 0.005468353629112244,\n", + " 0.005513208452612162,\n", + " 0.004461399279534817,\n", + " 0.006241586059331894,\n", + " 0.005249558947980404,\n", + " 0.005654552020132542,\n", + " 0.0055322954431176186,\n", + " 0.005360226146876812,\n", + " 0.005460440181195736,\n", + " 0.004343980457633734,\n", + " 0.005410810466855764,\n", + " 0.00437192665413022,\n", + " 0.004185013938695192,\n", + " 0.004517654422670603,\n", + " 0.005031590349972248,\n", + " 0.004249091260135174,\n", + " 0.004777214024215937,\n", + " 0.005062136799097061,\n", + " 0.004994281567633152,\n", + " 0.004231853410601616,\n", + " 0.0045309350825846195,\n", + " 0.003924088552594185,\n", + " 0.0043556480668485165,\n", + " 0.004606652073562145,\n", + " 0.003768147435039282,\n", + " 0.0041757430881261826,\n", + " 0.004156000912189484,\n", + " 0.004184857942163944,\n", + " 0.004056851379573345,\n", + " 0.004092910327017307,\n", + " 0.003924916498363018,\n", + " 0.004268942400813103,\n", + " 0.003970608580857515,\n", + " 0.004012443125247955,\n", + " 0.0043206168338656425,\n", + " 0.004508567042648792,\n", + " 0.0040132226422429085,\n", + " 0.004424720536917448,\n", + " 0.004243957810103893,\n", + " 0.004366926848888397,\n", + " 0.0041153016500175,\n", + " 0.004229916259646416,\n", + " 0.004367153625935316,\n", + " 0.004294292069971561,\n", + " 0.0044106002897024155,\n", + " 0.0038293637335300446,\n", + " 0.003999907057732344,\n", + " 0.004694904200732708,\n", + " 0.00453600799664855,\n", + " 0.0038958308286964893,\n", + " 0.0043612378649413586,\n", + " 0.0037960356567054987,\n", + " 0.004136254079639912,\n", + " 0.0037839787546545267,\n", + " 0.0028521858621388674,\n", + " 0.0029295526910573244,\n", + " 0.017638619989156723]},\n", + " {'Dataset': 'ECG',\n", + " 'Diffusion Domain': 'Frequency',\n", + " 'Specral Density': [0.17448683083057404,\n", + " 0.1280311942100525,\n", + " 0.04236514866352081,\n", + " 0.02944839373230934,\n", + " 0.03248542547225952,\n", + " 0.01832890696823597,\n", + " 0.019009452313184738,\n", + " 0.016900014132261276,\n", + " 0.020007498562335968,\n", + " 0.014738120138645172,\n", + " 0.01292400248348713,\n", + " 0.012923810631036758,\n", + " 0.011590833775699139,\n", + " 0.008583412505686283,\n", + " 0.01032392866909504,\n", + " 0.007329669781029224,\n", + " 0.007781646214425564,\n", + " 0.007966873236000538,\n", + " 0.008660475723445415,\n", + " 0.008613690733909607,\n", + " 0.008394352160394192,\n", + " 0.006759440526366234,\n", + " 0.007046310696750879,\n", + " 0.006241461727768183,\n", + " 0.006243249401450157,\n", + " 0.00627611018717289,\n", + " 0.007244658190757036,\n", + " 0.007787476759403944,\n", + " 0.008026584051549435,\n", + " 0.008517572656273842,\n", + " 0.00819140300154686,\n", + " 0.008416262455284595,\n", + " 0.008267220109701157,\n", + " 0.008325176313519478,\n", + " 0.00858023390173912,\n", + " 0.007146084681153297,\n", + " 0.00836141686886549,\n", + " 0.007127896882593632,\n", + " 0.008137702941894531,\n", + " 0.008127406239509583,\n", + " 0.006910201162099838,\n", + " 0.007430605590343475,\n", + " 0.006216380745172501,\n", + " 0.006848820485174656,\n", + " 0.006130716763436794,\n", + " 0.006404159590601921,\n", + " 0.006747884675860405,\n", + " 0.006660889834165573,\n", + " 0.005483686923980713,\n", + " 0.006135172210633755,\n", + " 0.0058369869366288185,\n", + " 0.005591580644249916,\n", + " 0.005379164591431618,\n", + " 0.005433778278529644,\n", + " 0.0053059933707118034,\n", + " 0.005148081108927727,\n", + " 0.00505717471241951,\n", + " 0.0048677073791623116,\n", + " 0.004802797455340624,\n", + " 0.005146651063114405,\n", + " 0.004288469906896353,\n", + " 0.004492409061640501,\n", + " 0.004392628557980061,\n", + " 0.003943524323403835,\n", + " 0.004372037015855312,\n", + " 0.003940732218325138,\n", + " 0.0038682599551975727,\n", + " 0.00392887881025672,\n", + " 0.004052453674376011,\n", + " 0.003828209824860096,\n", + " 0.003865094156935811,\n", + " 0.00400838628411293,\n", + " 0.0036092009395360947,\n", + " 0.0038238822016865015,\n", + " 0.0036836685612797737,\n", + " 0.003477112390100956,\n", + " 0.0034669549204409122,\n", + " 0.003540047677233815,\n", + " 0.0034435587003827095,\n", + " 0.0034185070544481277,\n", + " 0.003448782255873084,\n", + " 0.0034099072217941284,\n", + " 0.0034732408821582794,\n", + " 0.003388545708730817,\n", + " 0.002879598643630743,\n", + " 0.0030981528107076883,\n", + " 0.0032046898268163204,\n", + " 0.0031585991382598877,\n", + " 0.003089428413659334,\n", + " 0.003170466050505638,\n", + " 0.003233854891732335,\n", + " 0.0030928533524274826,\n", + " 0.0031858535949140787,\n", + " 0.0031858289148658514]}]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "spectral_density_list = []\n", + "for run in run_list:\n", + " data = {}\n", + " with open(runs_dir / f\"{run}/train_config.yaml\", \"r\") as f:\n", + " config = safe_load(f)\n", + " data[\"Dataset\"] = infer_dataset(config[\"datamodule\"][\"_target_\"])\n", + " data[\"Diffusion Domain\"] = infer_diffusion_domain(config[\"fourier_transform\"])\n", + " with open(runs_dir / f\"{run}/results.yaml\", \"r\") as f:\n", + " results = safe_load(f)\n", + " data[\"Specral Density\"] = calculate_spectral_density(results[\"freq_marginal_wasserstein_all\"], data[\"Dataset\"])\n", + " spectral_density_list.append(data)\n", + "spectral_density_list " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For each dataset, plot the spectral density of the marginals\n", + "for dataset in df.Dataset.unique():\n", + " fig, ax = plt.subplots()\n", + " for data in spectral_density_list:\n", + " if data[\"Dataset\"] == dataset:\n", + " ax.plot(data[\"Specral Density\"], label=data[\"Diffusion Domain\"])\n", + " ax.set_title(f\"Spectral Density of Marginals for {dataset}\")\n", + " ax.set_xlabel(\"Frequency\")\n", + " ax.set_ylabel(\"Spectral Density\")\n", + " ax.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/fdiff/utils/fourier.py b/src/fdiff/utils/fourier.py index f7c53e7..ce88383 100644 --- a/src/fdiff/utils/fourier.py +++ b/src/fdiff/utils/fourier.py @@ -84,3 +84,40 @@ def idft(x: torch.Tensor) -> torch.Tensor: ), f"The inverse DFT and the input should have the same size. Got {x_time.size()} and {x.size()} instead." return x_time.detach() + + +def spectral_density(x: torch.Tensor, apply_dft: bool = True) -> torch.Tensor: + """Compute the spectral density of the input time series. + + Args: + x (torch.Tensor): Time series of shape (batch_size, max_len, n_channels). + apply_dft (bool, optional): Whether to apply the DFT to the input. Defaults to True. + + Returns: + torch.Tensor: Spectral density of x with the size (batch_size, n_frequencies, n_channels). + """ + + max_len = x.size(1) + x = dft(x) if apply_dft else x + + # Extract real and imaginary parts + n_real = math.ceil((max_len + 1) / 2) + x_re = x[:, :n_real, :] + x_im = x[:, n_real:, :] + + # Create imaginary tensor + zero_padding = torch.zeros(size=(x.size(0), 1, x.size(2))) + x_im = torch.cat((zero_padding, x_im), dim=1) + + # If number of time steps is even, put the null imaginary part + if max_len % 2 == 0: + x_im = torch.cat((x_im, zero_padding), dim=1) + + assert ( + x_im.size() == x_re.size() + ), f"The real and imaginary parts should have the same shape, got {x_re.size()} and {x_im.size()} instead." + + # Compute the spectral density + x_dens = x_re**2 + x_im**2 + assert isinstance(x_dens, torch.Tensor) + return x_dens